Vendor dependencies for 0.3.0 release

vendor/bevy_render/Cargo.toml

@@ -0,0 +1,322 @@
+# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO
+#
+# When uploading crates to the registry Cargo will automatically
+# "normalize" Cargo.toml files for maximal compatibility
+# with all versions of Cargo and also rewrite `path` dependencies
+# to registry (e.g., crates.io) dependencies.
+#
+# If you are reading this file be aware that the original Cargo.toml
+# will likely look very different (and much more reasonable).
+# See Cargo.toml.orig for the original contents.
+
+[package]
+edition = "2024"
+name = "bevy_render"
+version = "0.16.1"
+build = false
+autolib = false
+autobins = false
+autoexamples = false
+autotests = false
+autobenches = false
+description = "Provides rendering functionality for Bevy Engine"
+homepage = "https://bevyengine.org"
+readme = "README.md"
+keywords = ["bevy"]
+license = "MIT OR Apache-2.0"
+repository = "https://github.com/bevyengine/bevy"
+resolver = "2"
+
+[package.metadata.docs.rs]
+all-features = true
+rustdoc-args = [
+    "-Zunstable-options",
+    "--generate-link-to-definition",
+]
+
+[features]
+basis-universal = ["bevy_image/basis-universal"]
+ci_limits = []
+dds = ["bevy_image/dds"]
+decoupled_naga = []
+detailed_trace = []
+exr = ["bevy_image/exr"]
+hdr = ["bevy_image/hdr"]
+ktx2 = [
+    "dep:ktx2",
+    "bevy_image/ktx2",
+]
+multi_threaded = ["bevy_tasks/multi_threaded"]
+shader_format_glsl = [
+    "naga/glsl-in",
+    "naga/wgsl-out",
+    "naga_oil/glsl",
+]
+shader_format_spirv = [
+    "wgpu/spirv",
+    "naga/spv-in",
+    "naga/spv-out",
+]
+shader_format_wesl = ["wesl"]
+spirv_shader_passthrough = ["wgpu/spirv"]
+statically-linked-dxc = ["wgpu/static-dxc"]
+trace = ["profiling"]
+tracing-tracy = ["dep:tracy-client"]
+webgl = ["wgpu/webgl"]
+webgpu = ["wgpu/webgpu"]
+
+[lib]
+name = "bevy_render"
+path = "src/lib.rs"
+
+[dependencies.async-channel]
+version = "2.3.0"
+
+[dependencies.bevy_app]
+version = "0.16.1"
+
+[dependencies.bevy_asset]
+version = "0.16.1"
+
+[dependencies.bevy_color]
+version = "0.16.2"
+features = [
+    "serialize",
+    "wgpu-types",
+]
+
+[dependencies.bevy_derive]
+version = "0.16.1"
+
+[dependencies.bevy_diagnostic]
+version = "0.16.1"
+
+[dependencies.bevy_ecs]
+version = "0.16.1"
+
+[dependencies.bevy_encase_derive]
+version = "0.16.1"
+
+[dependencies.bevy_image]
+version = "0.16.1"
+
+[dependencies.bevy_math]
+version = "0.16.1"
+
+[dependencies.bevy_mesh]
+version = "0.16.1"
+
+[dependencies.bevy_platform]
+version = "0.16.1"
+features = [
+    "std",
+    "serialize",
+]
+default-features = false
+
+[dependencies.bevy_reflect]
+version = "0.16.1"
+
+[dependencies.bevy_render_macros]
+version = "0.16.1"
+
+[dependencies.bevy_tasks]
+version = "0.16.1"
+
+[dependencies.bevy_time]
+version = "0.16.1"
+
+[dependencies.bevy_transform]
+version = "0.16.1"
+
+[dependencies.bevy_utils]
+version = "0.16.1"
+
+[dependencies.bevy_window]
+version = "0.16.1"
+
+[dependencies.bitflags]
+version = "2"
+
+[dependencies.bytemuck]
+version = "1.5"
+features = [
+    "derive",
+    "must_cast",
+]
+
+[dependencies.codespan-reporting]
+version = "0.11.0"
+
+[dependencies.derive_more]
+version = "1"
+features = ["from"]
+default-features = false
+
+[dependencies.downcast-rs]
+version = "2"
+features = ["std"]
+default-features = false
+
+[dependencies.encase]
+version = "0.10"
+features = ["glam"]
+
+[dependencies.fixedbitset]
+version = "0.5"
+
+[dependencies.futures-lite]
+version = "2.0.1"
+
+[dependencies.image]
+version = "0.25.2"
+default-features = false
+
+[dependencies.indexmap]
+version = "2"
+
+[dependencies.ktx2]
+version = "0.3.0"
+optional = true
+
+[dependencies.naga]
+version = "24"
+features = ["wgsl-in"]
+
+[dependencies.nonmax]
+version = "0.5"
+
+[dependencies.offset-allocator]
+version = "0.2"
+
+[dependencies.profiling]
+version = "1"
+features = ["profile-with-tracing"]
+optional = true
+
+[dependencies.serde]
+version = "1"
+features = ["derive"]
+
+[dependencies.smallvec]
+version = "1.11"
+features = ["const_new"]
+
+[dependencies.thiserror]
+version = "2"
+default-features = false
+
+[dependencies.tracing]
+version = "0.1"
+features = ["std"]
+default-features = false
+
+[dependencies.tracy-client]
+version = "0.18.0"
+optional = true
+
+[dependencies.variadics_please]
+version = "1.1"
+
+[dependencies.wesl]
+version = "0.1.2"
+optional = true
+
+[dependencies.wgpu]
+version = "24"
+features = [
+    "wgsl",
+    "dx12",
+    "metal",
+    "naga-ir",
+    "fragile-send-sync-non-atomic-wasm",
+]
+default-features = false
+
+[dev-dependencies.proptest]
+version = "1"
+
+[target.'cfg(all(target_arch = "wasm32", target_feature = "atomics"))'.dependencies.send_wrapper]
+version = "0.6.0"
+
+[target.'cfg(not(target_arch = "wasm32"))'.dependencies.naga_oil]
+version = "0.17"
+features = ["test_shader"]
+default-features = false
+
+[target.'cfg(target_arch = "wasm32")'.dependencies.bevy_app]
+version = "0.16.1"
+features = ["web"]
+default-features = false
+
+[target.'cfg(target_arch = "wasm32")'.dependencies.bevy_platform]
+version = "0.16.1"
+features = ["web"]
+default-features = false
+
+[target.'cfg(target_arch = "wasm32")'.dependencies.bevy_reflect]
+version = "0.16.1"
+features = ["web"]
+default-features = false
+
+[target.'cfg(target_arch = "wasm32")'.dependencies.bevy_tasks]
+version = "0.16.1"
+features = ["web"]
+default-features = false
+
+[target.'cfg(target_arch = "wasm32")'.dependencies.js-sys]
+version = "0.3"
+
+[target.'cfg(target_arch = "wasm32")'.dependencies.naga_oil]
+version = "0.17"
+
+[target.'cfg(target_arch = "wasm32")'.dependencies.wasm-bindgen]
+version = "0.2"
+
+[target.'cfg(target_arch = "wasm32")'.dependencies.web-sys]
+version = "0.3.67"
+features = [
+    "Blob",
+    "Document",
+    "Element",
+    "HtmlElement",
+    "Node",
+    "Url",
+    "Window",
+]
+
+[lints.clippy]
+alloc_instead_of_core = "warn"
+allow_attributes = "warn"
+allow_attributes_without_reason = "warn"
+doc_markdown = "warn"
+manual_let_else = "warn"
+match_same_arms = "warn"
+needless_lifetimes = "allow"
+nonstandard_macro_braces = "warn"
+print_stderr = "warn"
+print_stdout = "warn"
+ptr_as_ptr = "warn"
+ptr_cast_constness = "warn"
+redundant_closure_for_method_calls = "warn"
+redundant_else = "warn"
+ref_as_ptr = "warn"
+semicolon_if_nothing_returned = "warn"
+std_instead_of_alloc = "warn"
+std_instead_of_core = "warn"
+too_long_first_doc_paragraph = "allow"
+too_many_arguments = "allow"
+type_complexity = "allow"
+undocumented_unsafe_blocks = "warn"
+unwrap_or_default = "warn"
+
+[lints.rust]
+missing_docs = "warn"
+unsafe_code = "deny"
+unsafe_op_in_unsafe_fn = "warn"
+unused_qualifications = "warn"
+
+[lints.rust.unexpected_cfgs]
+level = "warn"
+priority = 0
+check-cfg = ["cfg(docsrs_dep)"]

vendor/bevy_render/LICENSE-APACHE

@@ -0,0 +1,176 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS

vendor/bevy_render/LICENSE-MIT

@@ -0,0 +1,19 @@
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

vendor/bevy_render/README.md

@@ -0,0 +1,7 @@
+# Bevy Render
+
+[![License](https://img.shields.io/badge/license-MIT%2FApache-blue.svg)](https://github.com/bevyengine/bevy#license)
+[![Crates.io](https://img.shields.io/crates/v/bevy_render.svg)](https://crates.io/crates/bevy_render)
+[![Downloads](https://img.shields.io/crates/d/bevy_render.svg)](https://crates.io/crates/bevy_render)
+[![Docs](https://docs.rs/bevy_render/badge.svg)](https://docs.rs/bevy_render/latest/bevy_render/)
+[![Discord](https://img.shields.io/discord/691052431525675048.svg?label=&logo=discord&logoColor=ffffff&color=7389D8&labelColor=6A7EC2)](https://discord.gg/bevy)

vendor/bevy_render/src/alpha.rs

@@ -0,0 +1,62 @@
+use bevy_reflect::{std_traits::ReflectDefault, Reflect};
+
+// TODO: add discussion about performance.
+/// Sets how a material's base color alpha channel is used for transparency.
+#[derive(Debug, Default, Reflect, Copy, Clone, PartialEq)]
+#[reflect(Default, Debug, Clone)]
+pub enum AlphaMode {
+    /// Base color alpha values are overridden to be fully opaque (1.0).
+    #[default]
+    Opaque,
+    /// Reduce transparency to fully opaque or fully transparent
+    /// based on a threshold.
+    ///
+    /// Compares the base color alpha value to the specified threshold.
+    /// If the value is below the threshold,
+    /// considers the color to be fully transparent (alpha is set to 0.0).
+    /// If it is equal to or above the threshold,
+    /// considers the color to be fully opaque (alpha is set to 1.0).
+    Mask(f32),
+    /// The base color alpha value defines the opacity of the color.
+    /// Standard alpha-blending is used to blend the fragment's color
+    /// with the color behind it.
+    Blend,
+    /// Similar to [`AlphaMode::Blend`], however assumes RGB channel values are
+    /// [premultiplied](https://en.wikipedia.org/wiki/Alpha_compositing#Straight_versus_premultiplied).
+    ///
+    /// For otherwise constant RGB values, behaves more like [`AlphaMode::Blend`] for
+    /// alpha values closer to 1.0, and more like [`AlphaMode::Add`] for
+    /// alpha values closer to 0.0.
+    ///
+    /// Can be used to avoid “border” or “outline” artifacts that can occur
+    /// when using plain alpha-blended textures.
+    Premultiplied,
+    /// Spreads the fragment out over a hardware-dependent number of sample
+    /// locations proportional to the alpha value. This requires multisample
+    /// antialiasing; if MSAA isn't on, this is identical to
+    /// [`AlphaMode::Mask`] with a value of 0.5.
+    ///
+    /// Alpha to coverage provides improved performance and better visual
+    /// fidelity over [`AlphaMode::Blend`], as Bevy doesn't have to sort objects
+    /// when it's in use. It's especially useful for complex transparent objects
+    /// like foliage.
+    ///
+    /// [alpha to coverage]: https://en.wikipedia.org/wiki/Alpha_to_coverage
+    AlphaToCoverage,
+    /// Combines the color of the fragments with the colors behind them in an
+    /// additive process, (i.e. like light) producing lighter results.
+    ///
+    /// Black produces no effect. Alpha values can be used to modulate the result.
+    ///
+    /// Useful for effects like holograms, ghosts, lasers and other energy beams.
+    Add,
+    /// Combines the color of the fragments with the colors behind them in a
+    /// multiplicative process, (i.e. like pigments) producing darker results.
+    ///
+    /// White produces no effect. Alpha values can be used to modulate the result.
+    ///
+    /// Useful for effects like stained glass, window tint film and some colored liquids.
+    Multiply,
+}
+
+impl Eq for AlphaMode {}

vendor/bevy_render/src/batching/mod.rs

@@ -0,0 +1,225 @@
+use bevy_ecs::{
+    component::Component,
+    entity::Entity,
+    system::{ResMut, SystemParam, SystemParamItem},
+};
+use bytemuck::Pod;
+use gpu_preprocessing::UntypedPhaseIndirectParametersBuffers;
+use nonmax::NonMaxU32;
+
+use crate::{
+    render_phase::{
+        BinnedPhaseItem, CachedRenderPipelinePhaseItem, DrawFunctionId, PhaseItemExtraIndex,
+        SortedPhaseItem, SortedRenderPhase, ViewBinnedRenderPhases,
+    },
+    render_resource::{CachedRenderPipelineId, GpuArrayBufferable},
+    sync_world::MainEntity,
+};
+
+pub mod gpu_preprocessing;
+pub mod no_gpu_preprocessing;
+
+/// Add this component to mesh entities to disable automatic batching
+#[derive(Component, Default)]
+pub struct NoAutomaticBatching;
+
+/// Data necessary to be equal for two draw commands to be mergeable
+///
+/// This is based on the following assumptions:
+/// - Only entities with prepared assets (pipelines, materials, meshes) are
+///   queued to phases
+/// - View bindings are constant across a phase for a given draw function as
+///   phases are per-view
+/// - `batch_and_prepare_render_phase` is the only system that performs this
+///   batching and has sole responsibility for preparing the per-object data.
+///   As such the mesh binding and dynamic offsets are assumed to only be
+///   variable as a result of the `batch_and_prepare_render_phase` system, e.g.
+///   due to having to split data across separate uniform bindings within the
+///   same buffer due to the maximum uniform buffer binding size.
+#[derive(PartialEq)]
+struct BatchMeta<T: PartialEq> {
+    /// The pipeline id encompasses all pipeline configuration including vertex
+    /// buffers and layouts, shaders and their specializations, bind group
+    /// layouts, etc.
+    pipeline_id: CachedRenderPipelineId,
+    /// The draw function id defines the `RenderCommands` that are called to
+    /// set the pipeline and bindings, and make the draw command
+    draw_function_id: DrawFunctionId,
+    dynamic_offset: Option<NonMaxU32>,
+    user_data: T,
+}
+
+impl<T: PartialEq> BatchMeta<T> {
+    fn new(item: &impl CachedRenderPipelinePhaseItem, user_data: T) -> Self {
+        BatchMeta {
+            pipeline_id: item.cached_pipeline(),
+            draw_function_id: item.draw_function(),
+            dynamic_offset: match item.extra_index() {
+                PhaseItemExtraIndex::DynamicOffset(dynamic_offset) => {
+                    NonMaxU32::new(dynamic_offset)
+                }
+                PhaseItemExtraIndex::None | PhaseItemExtraIndex::IndirectParametersIndex { .. } => {
+                    None
+                }
+            },
+            user_data,
+        }
+    }
+}
+
+/// A trait to support getting data used for batching draw commands via phase
+/// items.
+///
+/// This is a simple version that only allows for sorting, not binning, as well
+/// as only CPU processing, not GPU preprocessing. For these fancier features,
+/// see [`GetFullBatchData`].
+pub trait GetBatchData {
+    /// The system parameters [`GetBatchData::get_batch_data`] needs in
+    /// order to compute the batch data.
+    type Param: SystemParam + 'static;
+    /// Data used for comparison between phase items. If the pipeline id, draw
+    /// function id, per-instance data buffer dynamic offset and this data
+    /// matches, the draws can be batched.
+    type CompareData: PartialEq;
+    /// The per-instance data to be inserted into the
+    /// [`crate::render_resource::GpuArrayBuffer`] containing these data for all
+    /// instances.
+    type BufferData: GpuArrayBufferable + Sync + Send + 'static;
+    /// Get the per-instance data to be inserted into the
+    /// [`crate::render_resource::GpuArrayBuffer`]. If the instance can be
+    /// batched, also return the data used for comparison when deciding whether
+    /// draws can be batched, else return None for the `CompareData`.
+    ///
+    /// This is only called when building instance data on CPU. In the GPU
+    /// instance data building path, we use
+    /// [`GetFullBatchData::get_index_and_compare_data`] instead.
+    fn get_batch_data(
+        param: &SystemParamItem<Self::Param>,
+        query_item: (Entity, MainEntity),
+    ) -> Option<(Self::BufferData, Option<Self::CompareData>)>;
+}
+
+/// A trait to support getting data used for batching draw commands via phase
+/// items.
+///
+/// This version allows for binning and GPU preprocessing.
+pub trait GetFullBatchData: GetBatchData {
+    /// The per-instance data that was inserted into the
+    /// [`crate::render_resource::BufferVec`] during extraction.
+    type BufferInputData: Pod + Default + Sync + Send;
+
+    /// Get the per-instance data to be inserted into the
+    /// [`crate::render_resource::GpuArrayBuffer`].
+    ///
+    /// This is only called when building uniforms on CPU. In the GPU instance
+    /// buffer building path, we use
+    /// [`GetFullBatchData::get_index_and_compare_data`] instead.
+    fn get_binned_batch_data(
+        param: &SystemParamItem<Self::Param>,
+        query_item: MainEntity,
+    ) -> Option<Self::BufferData>;
+
+    /// Returns the index of the [`GetFullBatchData::BufferInputData`] that the
+    /// GPU preprocessing phase will use.
+    ///
+    /// We already inserted the [`GetFullBatchData::BufferInputData`] during the
+    /// extraction phase before we got here, so this function shouldn't need to
+    /// look up any render data. If CPU instance buffer building is in use, this
+    /// function will never be called.
+    fn get_index_and_compare_data(
+        param: &SystemParamItem<Self::Param>,
+        query_item: MainEntity,
+    ) -> Option<(NonMaxU32, Option<Self::CompareData>)>;
+
+    /// Returns the index of the [`GetFullBatchData::BufferInputData`] that the
+    /// GPU preprocessing phase will use.
+    ///
+    /// We already inserted the [`GetFullBatchData::BufferInputData`] during the
+    /// extraction phase before we got here, so this function shouldn't need to
+    /// look up any render data.
+    ///
+    /// This function is currently only called for unbatchable entities when GPU
+    /// instance buffer building is in use. For batchable entities, the uniform
+    /// index is written during queuing (e.g. in `queue_material_meshes`). In
+    /// the case of CPU instance buffer building, the CPU writes the uniforms,
+    /// so there's no index to return.
+    fn get_binned_index(
+        param: &SystemParamItem<Self::Param>,
+        query_item: MainEntity,
+    ) -> Option<NonMaxU32>;
+
+    /// Writes the [`gpu_preprocessing::IndirectParametersGpuMetadata`]
+    /// necessary to draw this batch into the given metadata buffer at the given
+    /// index.
+    ///
+    /// This is only used if GPU culling is enabled (which requires GPU
+    /// preprocessing).
+    ///
+    /// * `indexed` is true if the mesh is indexed or false if it's non-indexed.
+    ///
+    /// * `base_output_index` is the index of the first mesh instance in this
+    ///   batch in the `MeshUniform` output buffer.
+    ///
+    /// * `batch_set_index` is the index of the batch set in the
+    ///   [`gpu_preprocessing::IndirectBatchSet`] buffer, if this batch belongs to
+    ///   a batch set.
+    ///
+    /// * `indirect_parameters_buffers` is the buffer in which to write the
+    ///   metadata.
+    ///
+    /// * `indirect_parameters_offset` is the index in that buffer at which to
+    ///   write the metadata.
+    fn write_batch_indirect_parameters_metadata(
+        indexed: bool,
+        base_output_index: u32,
+        batch_set_index: Option<NonMaxU32>,
+        indirect_parameters_buffers: &mut UntypedPhaseIndirectParametersBuffers,
+        indirect_parameters_offset: u32,
+    );
+}
+
+/// Sorts a render phase that uses bins.
+pub fn sort_binned_render_phase<BPI>(mut phases: ResMut<ViewBinnedRenderPhases<BPI>>)
+where
+    BPI: BinnedPhaseItem,
+{
+    for phase in phases.values_mut() {
+        phase.multidrawable_meshes.sort_unstable_keys();
+        phase.batchable_meshes.sort_unstable_keys();
+        phase.unbatchable_meshes.sort_unstable_keys();
+        phase.non_mesh_items.sort_unstable_keys();
+    }
+}
+
+/// Batches the items in a sorted render phase.
+///
+/// This means comparing metadata needed to draw each phase item and trying to
+/// combine the draws into a batch.
+///
+/// This is common code factored out from
+/// [`gpu_preprocessing::batch_and_prepare_sorted_render_phase`] and
+/// [`no_gpu_preprocessing::batch_and_prepare_sorted_render_phase`].
+fn batch_and_prepare_sorted_render_phase<I, GBD>(
+    phase: &mut SortedRenderPhase<I>,
+    mut process_item: impl FnMut(&mut I) -> Option<GBD::CompareData>,
+) where
+    I: CachedRenderPipelinePhaseItem + SortedPhaseItem,
+    GBD: GetBatchData,
+{
+    let items = phase.items.iter_mut().map(|item| {
+        let batch_data = match process_item(item) {
+            Some(compare_data) if I::AUTOMATIC_BATCHING => Some(BatchMeta::new(item, compare_data)),
+            _ => None,
+        };
+        (item.batch_range_mut(), batch_data)
+    });
+
+    items.reduce(|(start_range, prev_batch_meta), (range, batch_meta)| {
+        if batch_meta.is_some() && prev_batch_meta == batch_meta {
+            start_range.end = range.end;
+            (start_range, prev_batch_meta)
+        } else {
+            (range, batch_meta)
+        }
+    });
+}

vendor/bevy_render/src/batching/no_gpu_preprocessing.rs

@@ -0,0 +1,182 @@
+//! Batching functionality when GPU preprocessing isn't in use.
+
+use bevy_derive::{Deref, DerefMut};
+use bevy_ecs::entity::Entity;
+use bevy_ecs::resource::Resource;
+use bevy_ecs::system::{Res, ResMut, StaticSystemParam};
+use smallvec::{smallvec, SmallVec};
+use tracing::error;
+use wgpu::BindingResource;
+
+use crate::{
+    render_phase::{
+        BinnedPhaseItem, BinnedRenderPhaseBatch, BinnedRenderPhaseBatchSets,
+        CachedRenderPipelinePhaseItem, PhaseItemExtraIndex, SortedPhaseItem,
+        ViewBinnedRenderPhases, ViewSortedRenderPhases,
+    },
+    render_resource::{GpuArrayBuffer, GpuArrayBufferable},
+    renderer::{RenderDevice, RenderQueue},
+};
+
+use super::{GetBatchData, GetFullBatchData};
+
+/// The GPU buffers holding the data needed to render batches.
+///
+/// For example, in the 3D PBR pipeline this holds `MeshUniform`s, which are the
+/// `BD` type parameter in that mode.
+#[derive(Resource, Deref, DerefMut)]
+pub struct BatchedInstanceBuffer<BD>(pub GpuArrayBuffer<BD>)
+where
+    BD: GpuArrayBufferable + Sync + Send + 'static;
+
+impl<BD> BatchedInstanceBuffer<BD>
+where
+    BD: GpuArrayBufferable + Sync + Send + 'static,
+{
+    /// Creates a new buffer.
+    pub fn new(render_device: &RenderDevice) -> Self {
+        BatchedInstanceBuffer(GpuArrayBuffer::new(render_device))
+    }
+
+    /// Returns the binding of the buffer that contains the per-instance data.
+    ///
+    /// If we're in the GPU instance buffer building mode, this buffer needs to
+    /// be filled in via a compute shader.
+    pub fn instance_data_binding(&self) -> Option<BindingResource> {
+        self.binding()
+    }
+}
+
+/// A system that clears out the [`BatchedInstanceBuffer`] for the frame.
+///
+/// This needs to run before the CPU batched instance buffers are used.
+pub fn clear_batched_cpu_instance_buffers<GBD>(
+    cpu_batched_instance_buffer: Option<ResMut<BatchedInstanceBuffer<GBD::BufferData>>>,
+) where
+    GBD: GetBatchData,
+{
+    if let Some(mut cpu_batched_instance_buffer) = cpu_batched_instance_buffer {
+        cpu_batched_instance_buffer.clear();
+    }
+}
+
+/// Batch the items in a sorted render phase, when GPU instance buffer building
+/// isn't in use. This means comparing metadata needed to draw each phase item
+/// and trying to combine the draws into a batch.
+pub fn batch_and_prepare_sorted_render_phase<I, GBD>(
+    batched_instance_buffer: ResMut<BatchedInstanceBuffer<GBD::BufferData>>,
+    mut phases: ResMut<ViewSortedRenderPhases<I>>,
+    param: StaticSystemParam<GBD::Param>,
+) where
+    I: CachedRenderPipelinePhaseItem + SortedPhaseItem,
+    GBD: GetBatchData,
+{
+    let system_param_item = param.into_inner();
+
+    // We only process CPU-built batch data in this function.
+    let batched_instance_buffer = batched_instance_buffer.into_inner();
+
+    for phase in phases.values_mut() {
+        super::batch_and_prepare_sorted_render_phase::<I, GBD>(phase, |item| {
+            let (buffer_data, compare_data) =
+                GBD::get_batch_data(&system_param_item, (item.entity(), item.main_entity()))?;
+            let buffer_index = batched_instance_buffer.push(buffer_data);
+
+            let index = buffer_index.index;
+            let (batch_range, extra_index) = item.batch_range_and_extra_index_mut();
+            *batch_range = index..index + 1;
+            *extra_index = PhaseItemExtraIndex::maybe_dynamic_offset(buffer_index.dynamic_offset);
+
+            compare_data
+        });
+    }
+}
+
+/// Creates batches for a render phase that uses bins, when GPU batch data
+/// building isn't in use.
+pub fn batch_and_prepare_binned_render_phase<BPI, GFBD>(
+    gpu_array_buffer: ResMut<BatchedInstanceBuffer<GFBD::BufferData>>,
+    mut phases: ResMut<ViewBinnedRenderPhases<BPI>>,
+    param: StaticSystemParam<GFBD::Param>,
+) where
+    BPI: BinnedPhaseItem,
+    GFBD: GetFullBatchData,
+{
+    let gpu_array_buffer = gpu_array_buffer.into_inner();
+    let system_param_item = param.into_inner();
+
+    for phase in phases.values_mut() {
+        // Prepare batchables.
+
+        for bin in phase.batchable_meshes.values_mut() {
+            let mut batch_set: SmallVec<[BinnedRenderPhaseBatch; 1]> = smallvec![];
+            for main_entity in bin.entities().keys() {
+                let Some(buffer_data) =
+                    GFBD::get_binned_batch_data(&system_param_item, *main_entity)
+                else {
+                    continue;
+                };
+                let instance = gpu_array_buffer.push(buffer_data);
+
+                // If the dynamic offset has changed, flush the batch.
+                //
+                // This is the only time we ever have more than one batch per
+                // bin. Note that dynamic offsets are only used on platforms
+                // with no storage buffers.
+                if !batch_set.last().is_some_and(|batch| {
+                    batch.instance_range.end == instance.index
+                        && batch.extra_index
+                            == PhaseItemExtraIndex::maybe_dynamic_offset(instance.dynamic_offset)
+                }) {
+                    batch_set.push(BinnedRenderPhaseBatch {
+                        representative_entity: (Entity::PLACEHOLDER, *main_entity),
+                        instance_range: instance.index..instance.index,
+                        extra_index: PhaseItemExtraIndex::maybe_dynamic_offset(
+                            instance.dynamic_offset,
+                        ),
+                    });
+                }
+
+                if let Some(batch) = batch_set.last_mut() {
+                    batch.instance_range.end = instance.index + 1;
+                }
+            }
+
+            match phase.batch_sets {
+                BinnedRenderPhaseBatchSets::DynamicUniforms(ref mut batch_sets) => {
+                    batch_sets.push(batch_set);
+                }
+                BinnedRenderPhaseBatchSets::Direct(_)
+                | BinnedRenderPhaseBatchSets::MultidrawIndirect { .. } => {
+                    error!(
+                        "Dynamic uniform batch sets should be used when GPU preprocessing is off"
+                    );
+                }
+            }
+        }
+
+        // Prepare unbatchables.
+        for unbatchables in phase.unbatchable_meshes.values_mut() {
+            for main_entity in unbatchables.entities.keys() {
+                let Some(buffer_data) =
+                    GFBD::get_binned_batch_data(&system_param_item, *main_entity)
+                else {
+                    continue;
+                };
+                let instance = gpu_array_buffer.push(buffer_data);
+                unbatchables.buffer_indices.add(instance.into());
+            }
+        }
+    }
+}
+
+/// Writes the instance buffer data to the GPU.
+pub fn write_batched_instance_buffer<GBD>(
+    render_device: Res<RenderDevice>,
+    render_queue: Res<RenderQueue>,
+    mut cpu_batched_instance_buffer: ResMut<BatchedInstanceBuffer<GBD::BufferData>>,
+) where
+    GBD: GetBatchData,
+{
+    cpu_batched_instance_buffer.write_buffer(&render_device, &render_queue);
+}

vendor/bevy_render/src/bindless.wgsl

@@ -0,0 +1,37 @@
+// Defines the common arrays used to access bindless resources.
+//
+// This need to be kept up to date with the `BINDING_NUMBERS` table in
+// `bindless.rs`.
+//
+// You access these by indexing into the bindless index table, and from there
+// indexing into the appropriate binding array. For example, to access the base
+// color texture of a `StandardMaterial` in bindless mode, write
+// `bindless_textures_2d[materials[slot].base_color_texture]`, where
+// `materials` is the bindless index table and `slot` is the index into that
+// table (which can be found in the `Mesh`).
+
+#define_import_path bevy_render::bindless
+
+#ifdef BINDLESS
+
+// Binding 0 is the bindless index table.
+// Filtering samplers.
+@group(2) @binding(1) var bindless_samplers_filtering: binding_array<sampler>;
+// Non-filtering samplers (nearest neighbor).
+@group(2) @binding(2) var bindless_samplers_non_filtering: binding_array<sampler>;
+// Comparison samplers (typically for shadow mapping).
+@group(2) @binding(3) var bindless_samplers_comparison: binding_array<sampler>;
+// 1D textures.
+@group(2) @binding(4) var bindless_textures_1d: binding_array<texture_1d<f32>>;
+// 2D textures.
+@group(2) @binding(5) var bindless_textures_2d: binding_array<texture_2d<f32>>;
+// 2D array textures.
+@group(2) @binding(6) var bindless_textures_2d_array: binding_array<texture_2d_array<f32>>;
+// 3D textures.
+@group(2) @binding(7) var bindless_textures_3d: binding_array<texture_3d<f32>>;
+// Cubemap textures.
+@group(2) @binding(8) var bindless_textures_cube: binding_array<texture_cube<f32>>;
+// Cubemap array textures.
+@group(2) @binding(9) var bindless_textures_cube_array: binding_array<texture_cube_array<f32>>;
+
+#endif  // BINDLESS

vendor/bevy_render/src/camera/camera_driver_node.rs

@@ -0,0 +1,97 @@
+use crate::{
+    camera::{ClearColor, ExtractedCamera, NormalizedRenderTarget, SortedCameras},
+    render_graph::{Node, NodeRunError, RenderGraphContext},
+    renderer::RenderContext,
+    view::ExtractedWindows,
+};
+use bevy_ecs::{entity::ContainsEntity, prelude::QueryState, world::World};
+use bevy_platform::collections::HashSet;
+use wgpu::{LoadOp, Operations, RenderPassColorAttachment, RenderPassDescriptor, StoreOp};
+
+pub struct CameraDriverNode {
+    cameras: QueryState<&'static ExtractedCamera>,
+}
+
+impl CameraDriverNode {
+    pub fn new(world: &mut World) -> Self {
+        Self {
+            cameras: world.query(),
+        }
+    }
+}
+
+impl Node for CameraDriverNode {
+    fn update(&mut self, world: &mut World) {
+        self.cameras.update_archetypes(world);
+    }
+    fn run(
+        &self,
+        graph: &mut RenderGraphContext,
+        render_context: &mut RenderContext,
+        world: &World,
+    ) -> Result<(), NodeRunError> {
+        let sorted_cameras = world.resource::<SortedCameras>();
+        let windows = world.resource::<ExtractedWindows>();
+        let mut camera_windows = <HashSet<_>>::default();
+        for sorted_camera in &sorted_cameras.0 {
+            let Ok(camera) = self.cameras.get_manual(world, sorted_camera.entity) else {
+                continue;
+            };
+
+            let mut run_graph = true;
+            if let Some(NormalizedRenderTarget::Window(window_ref)) = camera.target {
+                let window_entity = window_ref.entity();
+                if windows
+                    .windows
+                    .get(&window_entity)
+                    .is_some_and(|w| w.physical_width > 0 && w.physical_height > 0)
+                {
+                    camera_windows.insert(window_entity);
+                } else {
+                    // The window doesn't exist anymore or zero-sized so we don't need to run the graph
+                    run_graph = false;
+                }
+            }
+            if run_graph {
+                graph.run_sub_graph(camera.render_graph, vec![], Some(sorted_camera.entity))?;
+            }
+        }
+
+        let clear_color_global = world.resource::<ClearColor>();
+
+        // wgpu (and some backends) require doing work for swap chains if you call `get_current_texture()` and `present()`
+        // This ensures that Bevy doesn't crash, even when there are no cameras (and therefore no work submitted).
+        for (id, window) in world.resource::<ExtractedWindows>().iter() {
+            if camera_windows.contains(id) {
+                continue;
+            }
+
+            let Some(swap_chain_texture) = &window.swap_chain_texture_view else {
+                continue;
+            };
+
+            #[cfg(feature = "trace")]
+            let _span = tracing::info_span!("no_camera_clear_pass").entered();
+            let pass_descriptor = RenderPassDescriptor {
+                label: Some("no_camera_clear_pass"),
+                color_attachments: &[Some(RenderPassColorAttachment {
+                    view: swap_chain_texture,
+                    resolve_target: None,
+                    ops: Operations {
+                        load: LoadOp::Clear(clear_color_global.to_linear().into()),
+                        store: StoreOp::Store,
+                    },
+                })],
+                depth_stencil_attachment: None,
+                timestamp_writes: None,
+                occlusion_query_set: None,
+            };
+
+            render_context
+                .command_encoder()
+                .begin_render_pass(&pass_descriptor);
+        }
+
+        Ok(())
+    }
+}

vendor/bevy_render/src/camera/clear_color.rs

@@ -0,0 +1,37 @@
+use crate::extract_resource::ExtractResource;
+use bevy_color::Color;
+use bevy_derive::{Deref, DerefMut};
+use bevy_ecs::prelude::*;
+use bevy_reflect::prelude::*;
+use derive_more::derive::From;
+use serde::{Deserialize, Serialize};
+
+/// For a camera, specifies the color used to clear the viewport before rendering.
+#[derive(Reflect, Serialize, Deserialize, Copy, Clone, Debug, Default, From)]
+#[reflect(Serialize, Deserialize, Default, Clone)]
+pub enum ClearColorConfig {
+    /// The clear color is taken from the world's [`ClearColor`] resource.
+    #[default]
+    Default,
+    /// The given clear color is used, overriding the [`ClearColor`] resource defined in the world.
+    Custom(Color),
+    /// No clear color is used: the camera will simply draw on top of anything already in the viewport.
+    ///
+    /// This can be useful when multiple cameras are rendering to the same viewport.
+    None,
+}
+
+/// A [`Resource`] that stores the color that is used to clear the screen between frames.
+///
+/// This color appears as the "background" color for simple apps,
+/// when there are portions of the screen with nothing rendered.
+#[derive(Resource, Clone, Debug, Deref, DerefMut, ExtractResource, Reflect)]
+#[reflect(Resource, Default, Debug, Clone)]
+pub struct ClearColor(pub Color);
+
+/// Match the dark gray bevy website code block color by default.
+impl Default for ClearColor {
+    fn default() -> Self {
+        Self(Color::srgb_u8(43, 44, 47))
+    }
+}

vendor/bevy_render/src/camera/manual_texture_view.rs

@@ -0,0 +1,48 @@
+use crate::{extract_resource::ExtractResource, render_resource::TextureView};
+use bevy_ecs::{prelude::Component, reflect::ReflectComponent, resource::Resource};
+use bevy_image::BevyDefault as _;
+use bevy_math::UVec2;
+use bevy_platform::collections::HashMap;
+use bevy_reflect::prelude::*;
+use wgpu::TextureFormat;
+
+/// A unique id that corresponds to a specific [`ManualTextureView`] in the [`ManualTextureViews`] collection.
+#[derive(Default, Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord, Component, Reflect)]
+#[reflect(Component, Default, Debug, PartialEq, Hash, Clone)]
+pub struct ManualTextureViewHandle(pub u32);
+
+/// A manually managed [`TextureView`] for use as a [`crate::camera::RenderTarget`].
+#[derive(Debug, Clone, Component)]
+pub struct ManualTextureView {
+    pub texture_view: TextureView,
+    pub size: UVec2,
+    pub format: TextureFormat,
+}
+
+impl ManualTextureView {
+    pub fn with_default_format(texture_view: TextureView, size: UVec2) -> Self {
+        Self {
+            texture_view,
+            size,
+            format: TextureFormat::bevy_default(),
+        }
+    }
+}
+
+/// Stores manually managed [`ManualTextureView`]s for use as a [`crate::camera::RenderTarget`].
+#[derive(Default, Clone, Resource, ExtractResource)]
+pub struct ManualTextureViews(HashMap<ManualTextureViewHandle, ManualTextureView>);
+
+impl core::ops::Deref for ManualTextureViews {
+    type Target = HashMap<ManualTextureViewHandle, ManualTextureView>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl core::ops::DerefMut for ManualTextureViews {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.0
+    }
+}

vendor/bevy_render/src/camera/mod.rs

@@ -0,0 +1,51 @@
+mod camera;
+mod camera_driver_node;
+mod clear_color;
+mod manual_texture_view;
+mod projection;
+
+pub use camera::*;
+pub use camera_driver_node::*;
+pub use clear_color::*;
+pub use manual_texture_view::*;
+pub use projection::*;
+
+use crate::{
+    extract_component::ExtractComponentPlugin, extract_resource::ExtractResourcePlugin,
+    render_graph::RenderGraph, ExtractSchedule, Render, RenderApp, RenderSet,
+};
+use bevy_app::{App, Plugin};
+use bevy_ecs::schedule::IntoScheduleConfigs;
+
+#[derive(Default)]
+pub struct CameraPlugin;
+
+impl Plugin for CameraPlugin {
+    fn build(&self, app: &mut App) {
+        app.register_type::<Camera>()
+            .register_type::<ClearColor>()
+            .register_type::<CameraRenderGraph>()
+            .register_type::<CameraMainTextureUsages>()
+            .register_type::<Exposure>()
+            .register_type::<TemporalJitter>()
+            .register_type::<MipBias>()
+            .init_resource::<ManualTextureViews>()
+            .init_resource::<ClearColor>()
+            .add_plugins((
+                CameraProjectionPlugin,
+                ExtractResourcePlugin::<ManualTextureViews>::default(),
+                ExtractResourcePlugin::<ClearColor>::default(),
+                ExtractComponentPlugin::<CameraMainTextureUsages>::default(),
+            ));
+
+        if let Some(render_app) = app.get_sub_app_mut(RenderApp) {
+            render_app
+                .init_resource::<SortedCameras>()
+                .add_systems(ExtractSchedule, extract_cameras)
+                .add_systems(Render, sort_cameras.in_set(RenderSet::ManageViews));
+            let camera_driver_node = CameraDriverNode::new(render_app.world_mut());
+            let mut render_graph = render_app.world_mut().resource_mut::<RenderGraph>();
+            render_graph.add_node(crate::graph::CameraDriverLabel, camera_driver_node);
+        }
+    }
+}

vendor/bevy_render/src/camera/projection.rs

@@ -0,0 +1,706 @@
+use core::fmt::Debug;
+
+use crate::{primitives::Frustum, view::VisibilitySystems};
+use bevy_app::{App, Plugin, PostStartup, PostUpdate};
+use bevy_asset::AssetEvents;
+use bevy_derive::{Deref, DerefMut};
+use bevy_ecs::prelude::*;
+use bevy_math::{ops, AspectRatio, Mat4, Rect, Vec2, Vec3A, Vec4};
+use bevy_reflect::{std_traits::ReflectDefault, Reflect, ReflectDeserialize, ReflectSerialize};
+use bevy_transform::{components::GlobalTransform, TransformSystem};
+use derive_more::derive::From;
+use serde::{Deserialize, Serialize};
+
+/// Adds [`Camera`](crate::camera::Camera) driver systems for a given projection type.
+///
+/// If you are using `bevy_pbr`, then you need to add `PbrProjectionPlugin` along with this.
+#[derive(Default)]
+pub struct CameraProjectionPlugin;
+
+impl Plugin for CameraProjectionPlugin {
+    fn build(&self, app: &mut App) {
+        app.register_type::<Projection>()
+            .register_type::<PerspectiveProjection>()
+            .register_type::<OrthographicProjection>()
+            .register_type::<CustomProjection>()
+            .add_systems(
+                PostStartup,
+                crate::camera::camera_system.in_set(CameraUpdateSystem),
+            )
+            .add_systems(
+                PostUpdate,
+                (
+                    crate::camera::camera_system
+                        .in_set(CameraUpdateSystem)
+                        .before(AssetEvents),
+                    crate::view::update_frusta
+                        .in_set(VisibilitySystems::UpdateFrusta)
+                        .after(crate::camera::camera_system)
+                        .after(TransformSystem::TransformPropagate),
+                ),
+            );
+    }
+}
+
+/// Label for [`camera_system<T>`], shared across all `T`.
+///
+/// [`camera_system<T>`]: crate::camera::camera_system
+#[derive(SystemSet, Clone, Eq, PartialEq, Hash, Debug)]
+pub struct CameraUpdateSystem;
+
+/// Describes a type that can generate a projection matrix, allowing it to be added to a
+/// [`Camera`]'s [`Projection`] component.
+///
+/// Once implemented, the projection can be added to a camera using [`Projection::custom`].
+///
+/// The projection will be automatically updated as the render area is resized. This is useful when,
+/// for example, a projection type has a field like `fov` that should change when the window width
+/// is changed but not when the height changes.
+///
+/// This trait is implemented by bevy's built-in projections [`PerspectiveProjection`] and
+/// [`OrthographicProjection`].
+///
+/// [`Camera`]: crate::camera::Camera
+pub trait CameraProjection {
+    /// Generate the projection matrix.
+    fn get_clip_from_view(&self) -> Mat4;
+
+    /// Generate the projection matrix for a [`SubCameraView`](super::SubCameraView).
+    fn get_clip_from_view_for_sub(&self, sub_view: &super::SubCameraView) -> Mat4;
+
+    /// When the area this camera renders to changes dimensions, this method will be automatically
+    /// called. Use this to update any projection properties that depend on the aspect ratio or
+    /// dimensions of the render area.
+    fn update(&mut self, width: f32, height: f32);
+
+    /// The far plane distance of the projection.
+    fn far(&self) -> f32;
+
+    /// The eight corners of the camera frustum, as defined by this projection.
+    ///
+    /// The corners should be provided in the following order: first the bottom right, top right,
+    /// top left, bottom left for the near plane, then similar for the far plane.
+    // TODO: This seems somewhat redundant with `compute_frustum`, and similarly should be possible
+    // to compute with a default impl.
+    fn get_frustum_corners(&self, z_near: f32, z_far: f32) -> [Vec3A; 8];
+
+    /// Compute camera frustum for camera with given projection and transform.
+    ///
+    /// This code is called by [`update_frusta`](crate::view::visibility::update_frusta) system
+    /// for each camera to update its frustum.
+    fn compute_frustum(&self, camera_transform: &GlobalTransform) -> Frustum {
+        let clip_from_world =
+            self.get_clip_from_view() * camera_transform.compute_matrix().inverse();
+        Frustum::from_clip_from_world_custom_far(
+            &clip_from_world,
+            &camera_transform.translation(),
+            &camera_transform.back(),
+            self.far(),
+        )
+    }
+}
+
+mod sealed {
+    use super::CameraProjection;
+
+    /// A wrapper trait to make it possible to implement Clone for boxed [`super::CameraProjection`]
+    /// trait objects, without breaking object safety rules by making it `Sized`. Additional bounds
+    /// are included for downcasting, and fulfilling the trait bounds on `Projection`.
+    pub trait DynCameraProjection:
+        CameraProjection + core::fmt::Debug + Send + Sync + downcast_rs::Downcast
+    {
+        fn clone_box(&self) -> Box<dyn DynCameraProjection>;
+    }
+
+    downcast_rs::impl_downcast!(DynCameraProjection);
+
+    impl<T> DynCameraProjection for T
+    where
+        T: 'static + CameraProjection + core::fmt::Debug + Send + Sync + Clone,
+    {
+        fn clone_box(&self) -> Box<dyn DynCameraProjection> {
+            Box::new(self.clone())
+        }
+    }
+}
+
+/// Holds a dynamic [`CameraProjection`] trait object. Use [`Projection::custom()`] to construct a
+/// custom projection.
+///
+/// The contained dynamic object can be downcast into a static type using [`CustomProjection::get`].
+#[derive(Component, Debug, Reflect, Deref, DerefMut)]
+#[reflect(Default, Clone)]
+pub struct CustomProjection {
+    #[reflect(ignore)]
+    #[deref]
+    dyn_projection: Box<dyn sealed::DynCameraProjection>,
+}
+
+impl Default for CustomProjection {
+    fn default() -> Self {
+        Self {
+            dyn_projection: Box::new(PerspectiveProjection::default()),
+        }
+    }
+}
+
+impl Clone for CustomProjection {
+    fn clone(&self) -> Self {
+        Self {
+            dyn_projection: self.dyn_projection.clone_box(),
+        }
+    }
+}
+
+impl CustomProjection {
+    /// Returns a reference to the [`CameraProjection`] `P`.
+    ///
+    /// Returns `None` if this dynamic object is not a projection of type `P`.
+    ///
+    /// ```
+    /// # use bevy_render::prelude::{Projection, PerspectiveProjection};
+    /// // For simplicity's sake, use perspective as a custom projection:
+    /// let projection = Projection::custom(PerspectiveProjection::default());
+    /// let Projection::Custom(custom) = projection else { return };
+    ///
+    /// // At this point the projection type is erased.
+    /// // We can use `get()` if we know what kind of projection we have.
+    /// let perspective = custom.get::<PerspectiveProjection>().unwrap();
+    ///
+    /// assert_eq!(perspective.fov, PerspectiveProjection::default().fov);
+    /// ```
+    pub fn get<P>(&self) -> Option<&P>
+    where
+        P: CameraProjection + Debug + Send + Sync + Clone + 'static,
+    {
+        self.dyn_projection.downcast_ref()
+    }
+
+    /// Returns a mutable  reference to the [`CameraProjection`] `P`.
+    ///
+    /// Returns `None` if this dynamic object is not a projection of type `P`.
+    ///
+    /// ```
+    /// # use bevy_render::prelude::{Projection, PerspectiveProjection};
+    /// // For simplicity's sake, use perspective as a custom projection:
+    /// let mut projection = Projection::custom(PerspectiveProjection::default());
+    /// let Projection::Custom(mut custom) = projection else { return };
+    ///
+    /// // At this point the projection type is erased.
+    /// // We can use `get_mut()` if we know what kind of projection we have.
+    /// let perspective = custom.get_mut::<PerspectiveProjection>().unwrap();
+    ///
+    /// assert_eq!(perspective.fov, PerspectiveProjection::default().fov);
+    /// perspective.fov = 1.0;
+    /// ```
+    pub fn get_mut<P>(&mut self) -> Option<&mut P>
+    where
+        P: CameraProjection + Debug + Send + Sync + Clone + 'static,
+    {
+        self.dyn_projection.downcast_mut()
+    }
+}
+
+/// Component that defines how to compute a [`Camera`]'s projection matrix.
+///
+/// Common projections, like perspective and orthographic, are provided out of the box to handle the
+/// majority of use cases. Custom projections can be added using the [`CameraProjection`] trait and
+/// the [`Projection::custom`] constructor.
+///
+/// ## What's a projection?
+///
+/// A camera projection essentially describes how 3d points from the point of view of a camera are
+/// projected onto a 2d screen. This is where properties like a camera's field of view are defined.
+/// More specifically, a projection is a 4x4 matrix that transforms points from view space (the
+/// point of view of the camera) into clip space. Clip space is almost, but not quite, equivalent to
+/// the rectangle that is rendered to your screen, with a depth axis. Any points that land outside
+/// the bounds of this cuboid are "clipped" and not rendered.
+///
+/// You can also think of the projection as the thing that describes the shape of a camera's
+/// frustum: the volume in 3d space that is visible to a camera.
+///
+/// [`Camera`]: crate::camera::Camera
+#[derive(Component, Debug, Clone, Reflect, From)]
+#[reflect(Component, Default, Debug, Clone)]
+pub enum Projection {
+    Perspective(PerspectiveProjection),
+    Orthographic(OrthographicProjection),
+    Custom(CustomProjection),
+}
+
+impl Projection {
+    /// Construct a new custom camera projection from a type that implements [`CameraProjection`].
+    pub fn custom<P>(projection: P) -> Self
+    where
+        // Implementation note: pushing these trait bounds all the way out to this function makes
+        // errors nice for users. If a trait is missing, they will get a helpful error telling them
+        // that, say, the `Debug` implementation is missing. Wrapping these traits behind a super
+        // trait or some other indirection will make the errors harder to understand.
+        //
+        // For example, we don't use the `DynCameraProjection`` trait bound, because it is not the
+        // trait the user should be implementing - they only need to worry about implementing
+        // `CameraProjection`.
+        P: CameraProjection + Debug + Send + Sync + Clone + 'static,
+    {
+        Projection::Custom(CustomProjection {
+            dyn_projection: Box::new(projection),
+        })
+    }
+}
+
+impl CameraProjection for Projection {
+    fn get_clip_from_view(&self) -> Mat4 {
+        match self {
+            Projection::Perspective(projection) => projection.get_clip_from_view(),
+            Projection::Orthographic(projection) => projection.get_clip_from_view(),
+            Projection::Custom(projection) => projection.get_clip_from_view(),
+        }
+    }
+
+    fn get_clip_from_view_for_sub(&self, sub_view: &super::SubCameraView) -> Mat4 {
+        match self {
+            Projection::Perspective(projection) => projection.get_clip_from_view_for_sub(sub_view),
+            Projection::Orthographic(projection) => projection.get_clip_from_view_for_sub(sub_view),
+            Projection::Custom(projection) => projection.get_clip_from_view_for_sub(sub_view),
+        }
+    }
+
+    fn update(&mut self, width: f32, height: f32) {
+        match self {
+            Projection::Perspective(projection) => projection.update(width, height),
+            Projection::Orthographic(projection) => projection.update(width, height),
+            Projection::Custom(projection) => projection.update(width, height),
+        }
+    }
+
+    fn far(&self) -> f32 {
+        match self {
+            Projection::Perspective(projection) => projection.far(),
+            Projection::Orthographic(projection) => projection.far(),
+            Projection::Custom(projection) => projection.far(),
+        }
+    }
+
+    fn get_frustum_corners(&self, z_near: f32, z_far: f32) -> [Vec3A; 8] {
+        match self {
+            Projection::Perspective(projection) => projection.get_frustum_corners(z_near, z_far),
+            Projection::Orthographic(projection) => projection.get_frustum_corners(z_near, z_far),
+            Projection::Custom(projection) => projection.get_frustum_corners(z_near, z_far),
+        }
+    }
+}
+
+impl Default for Projection {
+    fn default() -> Self {
+        Projection::Perspective(Default::default())
+    }
+}
+
+/// A 3D camera projection in which distant objects appear smaller than close objects.
+#[derive(Debug, Clone, Reflect)]
+#[reflect(Default, Debug, Clone)]
+pub struct PerspectiveProjection {
+    /// The vertical field of view (FOV) in radians.
+    ///
+    /// Defaults to a value of π/4 radians or 45 degrees.
+    pub fov: f32,
+
+    /// The aspect ratio (width divided by height) of the viewing frustum.
+    ///
+    /// Bevy's [`camera_system`](crate::camera::camera_system) automatically
+    /// updates this value when the aspect ratio of the associated window changes.
+    ///
+    /// Defaults to a value of `1.0`.
+    pub aspect_ratio: f32,
+
+    /// The distance from the camera in world units of the viewing frustum's near plane.
+    ///
+    /// Objects closer to the camera than this value will not be visible.
+    ///
+    /// Defaults to a value of `0.1`.
+    pub near: f32,
+
+    /// The distance from the camera in world units of the viewing frustum's far plane.
+    ///
+    /// Objects farther from the camera than this value will not be visible.
+    ///
+    /// Defaults to a value of `1000.0`.
+    pub far: f32,
+}
+
+impl CameraProjection for PerspectiveProjection {
+    fn get_clip_from_view(&self) -> Mat4 {
+        Mat4::perspective_infinite_reverse_rh(self.fov, self.aspect_ratio, self.near)
+    }
+
+    fn get_clip_from_view_for_sub(&self, sub_view: &super::SubCameraView) -> Mat4 {
+        let full_width = sub_view.full_size.x as f32;
+        let full_height = sub_view.full_size.y as f32;
+        let sub_width = sub_view.size.x as f32;
+        let sub_height = sub_view.size.y as f32;
+        let offset_x = sub_view.offset.x;
+        // Y-axis increases from top to bottom
+        let offset_y = full_height - (sub_view.offset.y + sub_height);
+
+        let full_aspect = full_width / full_height;
+
+        // Original frustum parameters
+        let top = self.near * ops::tan(0.5 * self.fov);
+        let bottom = -top;
+        let right = top * full_aspect;
+        let left = -right;
+
+        // Calculate scaling factors
+        let width = right - left;
+        let height = top - bottom;
+
+        // Calculate the new frustum parameters
+        let left_prime = left + (width * offset_x) / full_width;
+        let right_prime = left + (width * (offset_x + sub_width)) / full_width;
+        let bottom_prime = bottom + (height * offset_y) / full_height;
+        let top_prime = bottom + (height * (offset_y + sub_height)) / full_height;
+
+        // Compute the new projection matrix
+        let x = (2.0 * self.near) / (right_prime - left_prime);
+        let y = (2.0 * self.near) / (top_prime - bottom_prime);
+        let a = (right_prime + left_prime) / (right_prime - left_prime);
+        let b = (top_prime + bottom_prime) / (top_prime - bottom_prime);
+
+        Mat4::from_cols(
+            Vec4::new(x, 0.0, 0.0, 0.0),
+            Vec4::new(0.0, y, 0.0, 0.0),
+            Vec4::new(a, b, 0.0, -1.0),
+            Vec4::new(0.0, 0.0, self.near, 0.0),
+        )
+    }
+
+    fn update(&mut self, width: f32, height: f32) {
+        self.aspect_ratio = AspectRatio::try_new(width, height)
+            .expect("Failed to update PerspectiveProjection: width and height must be positive, non-zero values")
+            .ratio();
+    }
+
+    fn far(&self) -> f32 {
+        self.far
+    }
+
+    fn get_frustum_corners(&self, z_near: f32, z_far: f32) -> [Vec3A; 8] {
+        let tan_half_fov = ops::tan(self.fov / 2.);
+        let a = z_near.abs() * tan_half_fov;
+        let b = z_far.abs() * tan_half_fov;
+        let aspect_ratio = self.aspect_ratio;
+        // NOTE: These vertices are in the specific order required by [`calculate_cascade`].
+        [
+            Vec3A::new(a * aspect_ratio, -a, z_near),  // bottom right
+            Vec3A::new(a * aspect_ratio, a, z_near),   // top right
+            Vec3A::new(-a * aspect_ratio, a, z_near),  // top left
+            Vec3A::new(-a * aspect_ratio, -a, z_near), // bottom left
+            Vec3A::new(b * aspect_ratio, -b, z_far),   // bottom right
+            Vec3A::new(b * aspect_ratio, b, z_far),    // top right
+            Vec3A::new(-b * aspect_ratio, b, z_far),   // top left
+            Vec3A::new(-b * aspect_ratio, -b, z_far),  // bottom left
+        ]
+    }
+}
+
+impl Default for PerspectiveProjection {
+    fn default() -> Self {
+        PerspectiveProjection {
+            fov: core::f32::consts::PI / 4.0,
+            near: 0.1,
+            far: 1000.0,
+            aspect_ratio: 1.0,
+        }
+    }
+}
+
+/// Scaling mode for [`OrthographicProjection`].
+///
+/// The effect of these scaling modes are combined with the [`OrthographicProjection::scale`] property.
+///
+/// For example, if the scaling mode is `ScalingMode::Fixed { width: 100.0, height: 300 }` and the scale is `2.0`,
+/// the projection will be 200 world units wide and 600 world units tall.
+///
+/// # Examples
+///
+/// Configure the orthographic projection to two world units per window height:
+///
+/// ```
+/// # use bevy_render::camera::{OrthographicProjection, Projection, ScalingMode};
+/// let projection = Projection::Orthographic(OrthographicProjection {
+///    scaling_mode: ScalingMode::FixedVertical { viewport_height: 2.0 },
+///    ..OrthographicProjection::default_2d()
+/// });
+/// ```
+#[derive(Default, Debug, Clone, Copy, Reflect, Serialize, Deserialize)]
+#[reflect(Serialize, Deserialize, Default, Clone)]
+pub enum ScalingMode {
+    /// Match the viewport size.
+    ///
+    /// With a scale of 1, lengths in world units will map 1:1 with the number of pixels used to render it.
+    /// For example, if we have a 64x64 sprite with a [`Transform::scale`](bevy_transform::prelude::Transform) of 1.0,
+    /// no custom size and no inherited scale, the sprite will be 64 world units wide and 64 world units tall.
+    /// When rendered with [`OrthographicProjection::scaling_mode`] set to `WindowSize` when the window scale factor is 1
+    /// the sprite will be rendered at 64 pixels wide and 64 pixels tall.
+    ///
+    /// Changing any of these properties will multiplicatively affect the final size.
+    #[default]
+    WindowSize,
+    /// Manually specify the projection's size, ignoring window resizing. The image will stretch.
+    ///
+    /// Arguments describe the area of the world that is shown (in world units).
+    Fixed { width: f32, height: f32 },
+    /// Keeping the aspect ratio while the axes can't be smaller than given minimum.
+    ///
+    /// Arguments are in world units.
+    AutoMin { min_width: f32, min_height: f32 },
+    /// Keeping the aspect ratio while the axes can't be bigger than given maximum.
+    ///
+    /// Arguments are in world units.
+    AutoMax { max_width: f32, max_height: f32 },
+    /// Keep the projection's height constant; width will be adjusted to match aspect ratio.
+    ///
+    /// The argument is the desired height of the projection in world units.
+    FixedVertical { viewport_height: f32 },
+    /// Keep the projection's width constant; height will be adjusted to match aspect ratio.
+    ///
+    /// The argument is the desired width of the projection in world units.
+    FixedHorizontal { viewport_width: f32 },
+}
+
+/// Project a 3D space onto a 2D surface using parallel lines, i.e., unlike [`PerspectiveProjection`],
+/// the size of objects remains the same regardless of their distance to the camera.
+///
+/// The volume contained in the projection is called the *view frustum*. Since the viewport is rectangular
+/// and projection lines are parallel, the view frustum takes the shape of a cuboid.
+///
+/// Note that the scale of the projection and the apparent size of objects are inversely proportional.
+/// As the size of the projection increases, the size of objects decreases.
+///
+/// # Examples
+///
+/// Configure the orthographic projection to one world unit per 100 window pixels:
+///
+/// ```
+/// # use bevy_render::camera::{OrthographicProjection, Projection, ScalingMode};
+/// let projection = Projection::Orthographic(OrthographicProjection {
+///     scaling_mode: ScalingMode::WindowSize,
+///     scale: 0.01,
+///     ..OrthographicProjection::default_2d()
+/// });
+/// ```
+#[derive(Debug, Clone, Reflect)]
+#[reflect(Debug, FromWorld, Clone)]
+pub struct OrthographicProjection {
+    /// The distance of the near clipping plane in world units.
+    ///
+    /// Objects closer than this will not be rendered.
+    ///
+    /// Defaults to `0.0`
+    pub near: f32,
+    /// The distance of the far clipping plane in world units.
+    ///
+    /// Objects further than this will not be rendered.
+    ///
+    /// Defaults to `1000.0`
+    pub far: f32,
+    /// Specifies the origin of the viewport as a normalized position from 0 to 1, where (0, 0) is the bottom left
+    /// and (1, 1) is the top right. This determines where the camera's position sits inside the viewport.
+    ///
+    /// When the projection scales due to viewport resizing, the position of the camera, and thereby `viewport_origin`,
+    /// remains at the same relative point.
+    ///
+    /// Consequently, this is pivot point when scaling. With a bottom left pivot, the projection will expand
+    /// upwards and to the right. With a top right pivot, the projection will expand downwards and to the left.
+    /// Values in between will caused the projection to scale proportionally on each axis.
+    ///
+    /// Defaults to `(0.5, 0.5)`, which makes scaling affect opposite sides equally, keeping the center
+    /// point of the viewport centered.
+    pub viewport_origin: Vec2,
+    /// How the projection will scale to the viewport.
+    ///
+    /// Defaults to [`ScalingMode::WindowSize`],
+    /// and works in concert with [`OrthographicProjection::scale`] to determine the final effect.
+    ///
+    /// For simplicity, zooming should be done by changing [`OrthographicProjection::scale`],
+    /// rather than changing the parameters of the scaling mode.
+    pub scaling_mode: ScalingMode,
+    /// Scales the projection.
+    ///
+    /// As scale increases, the apparent size of objects decreases, and vice versa.
+    ///
+    /// Note: scaling can be set by [`scaling_mode`](Self::scaling_mode) as well.
+    /// This parameter scales on top of that.
+    ///
+    /// This property is particularly useful in implementing zoom functionality.
+    ///
+    /// Defaults to `1.0`, which under standard settings corresponds to a 1:1 mapping of world units to rendered pixels.
+    /// See [`ScalingMode::WindowSize`] for more information.
+    pub scale: f32,
+    /// The area that the projection covers relative to `viewport_origin`.
+    ///
+    /// Bevy's [`camera_system`](crate::camera::camera_system) automatically
+    /// updates this value when the viewport is resized depending on `OrthographicProjection`'s other fields.
+    /// In this case, `area` should not be manually modified.
+    ///
+    /// It may be necessary to set this manually for shadow projections and such.
+    pub area: Rect,
+}
+
+impl CameraProjection for OrthographicProjection {
+    fn get_clip_from_view(&self) -> Mat4 {
+        Mat4::orthographic_rh(
+            self.area.min.x,
+            self.area.max.x,
+            self.area.min.y,
+            self.area.max.y,
+            // NOTE: near and far are swapped to invert the depth range from [0,1] to [1,0]
+            // This is for interoperability with pipelines using infinite reverse perspective projections.
+            self.far,
+            self.near,
+        )
+    }
+
+    fn get_clip_from_view_for_sub(&self, sub_view: &super::SubCameraView) -> Mat4 {
+        let full_width = sub_view.full_size.x as f32;
+        let full_height = sub_view.full_size.y as f32;
+        let offset_x = sub_view.offset.x;
+        let offset_y = sub_view.offset.y;
+        let sub_width = sub_view.size.x as f32;
+        let sub_height = sub_view.size.y as f32;
+
+        let full_aspect = full_width / full_height;
+
+        // Base the vertical size on self.area and adjust the horizontal size
+        let top = self.area.max.y;
+        let bottom = self.area.min.y;
+        let ortho_height = top - bottom;
+        let ortho_width = ortho_height * full_aspect;
+
+        // Center the orthographic area horizontally
+        let center_x = (self.area.max.x + self.area.min.x) / 2.0;
+        let left = center_x - ortho_width / 2.0;
+        let right = center_x + ortho_width / 2.0;
+
+        // Calculate scaling factors
+        let scale_w = (right - left) / full_width;
+        let scale_h = (top - bottom) / full_height;
+
+        // Calculate the new orthographic bounds
+        let left_prime = left + scale_w * offset_x;
+        let right_prime = left_prime + scale_w * sub_width;
+        let top_prime = top - scale_h * offset_y;
+        let bottom_prime = top_prime - scale_h * sub_height;
+
+        Mat4::orthographic_rh(
+            left_prime,
+            right_prime,
+            bottom_prime,
+            top_prime,
+            // NOTE: near and far are swapped to invert the depth range from [0,1] to [1,0]
+            // This is for interoperability with pipelines using infinite reverse perspective projections.
+            self.far,
+            self.near,
+        )
+    }
+
+    fn update(&mut self, width: f32, height: f32) {
+        let (projection_width, projection_height) = match self.scaling_mode {
+            ScalingMode::WindowSize => (width, height),
+            ScalingMode::AutoMin {
+                min_width,
+                min_height,
+            } => {
+                // Compare Pixels of current width and minimal height and Pixels of minimal width with current height.
+                // Then use bigger (min_height when true) as what it refers to (height when true) and calculate rest so it can't get under minimum.
+                if width * min_height > min_width * height {
+                    (width * min_height / height, min_height)
+                } else {
+                    (min_width, height * min_width / width)
+                }
+            }
+            ScalingMode::AutoMax {
+                max_width,
+                max_height,
+            } => {
+                // Compare Pixels of current width and maximal height and Pixels of maximal width with current height.
+                // Then use smaller (max_height when true) as what it refers to (height when true) and calculate rest so it can't get over maximum.
+                if width * max_height < max_width * height {
+                    (width * max_height / height, max_height)
+                } else {
+                    (max_width, height * max_width / width)
+                }
+            }
+            ScalingMode::FixedVertical { viewport_height } => {
+                (width * viewport_height / height, viewport_height)
+            }
+            ScalingMode::FixedHorizontal { viewport_width } => {
+                (viewport_width, height * viewport_width / width)
+            }
+            ScalingMode::Fixed { width, height } => (width, height),
+        };
+
+        let origin_x = projection_width * self.viewport_origin.x;
+        let origin_y = projection_height * self.viewport_origin.y;
+
+        self.area = Rect::new(
+            self.scale * -origin_x,
+            self.scale * -origin_y,
+            self.scale * (projection_width - origin_x),
+            self.scale * (projection_height - origin_y),
+        );
+    }
+
+    fn far(&self) -> f32 {
+        self.far
+    }
+
+    fn get_frustum_corners(&self, z_near: f32, z_far: f32) -> [Vec3A; 8] {
+        let area = self.area;
+        // NOTE: These vertices are in the specific order required by [`calculate_cascade`].
+        [
+            Vec3A::new(area.max.x, area.min.y, z_near), // bottom right
+            Vec3A::new(area.max.x, area.max.y, z_near), // top right
+            Vec3A::new(area.min.x, area.max.y, z_near), // top left
+            Vec3A::new(area.min.x, area.min.y, z_near), // bottom left
+            Vec3A::new(area.max.x, area.min.y, z_far),  // bottom right
+            Vec3A::new(area.max.x, area.max.y, z_far),  // top right
+            Vec3A::new(area.min.x, area.max.y, z_far),  // top left
+            Vec3A::new(area.min.x, area.min.y, z_far),  // bottom left
+        ]
+    }
+}
+
+impl FromWorld for OrthographicProjection {
+    fn from_world(_world: &mut World) -> Self {
+        OrthographicProjection::default_3d()
+    }
+}
+
+impl OrthographicProjection {
+    /// Returns the default orthographic projection for a 2D context.
+    ///
+    /// The near plane is set to a negative value so that the camera can still
+    /// render the scene when using positive z coordinates to order foreground elements.
+    pub fn default_2d() -> Self {
+        OrthographicProjection {
+            near: -1000.0,
+            ..OrthographicProjection::default_3d()
+        }
+    }
+
+    /// Returns the default orthographic projection for a 3D context.
+    ///
+    /// The near plane is set to 0.0 so that the camera doesn't render
+    /// objects that are behind it.
+    pub fn default_3d() -> Self {
+        OrthographicProjection {
+            scale: 1.0,
+            near: 0.0,
+            far: 1000.0,
+            viewport_origin: Vec2::new(0.5, 0.5),
+            scaling_mode: ScalingMode::WindowSize,
+            area: Rect::new(-1.0, -1.0, 1.0, 1.0),
+        }
+    }
+}

vendor/bevy_render/src/color_operations.wgsl

@@ -0,0 +1,47 @@
+#define_import_path bevy_render::color_operations
+
+#import bevy_render::maths::FRAC_PI_3
+
+// Converts HSV to RGB.
+//
+// Input: H ∈ [0, 2π), S ∈ [0, 1], V ∈ [0, 1].
+// Output: R ∈ [0, 1], G ∈ [0, 1], B ∈ [0, 1].
+//
+// <https://en.wikipedia.org/wiki/HSL_and_HSV#HSV_to_RGB_alternative>
+fn hsv_to_rgb(hsv: vec3<f32>) -> vec3<f32> {
+    let n = vec3(5.0, 3.0, 1.0);
+    let k = (n + hsv.x / FRAC_PI_3) % 6.0;
+    return hsv.z - hsv.z * hsv.y * max(vec3(0.0), min(k, min(4.0 - k, vec3(1.0))));
+}
+
+// Converts RGB to HSV.
+//
+// Input: R ∈ [0, 1], G ∈ [0, 1], B ∈ [0, 1].
+// Output: H ∈ [0, 2π), S ∈ [0, 1], V ∈ [0, 1].
+//
+// <https://en.wikipedia.org/wiki/HSL_and_HSV#From_RGB>
+fn rgb_to_hsv(rgb: vec3<f32>) -> vec3<f32> {
+    let x_max = max(rgb.r, max(rgb.g, rgb.b));  // i.e. V
+    let x_min = min(rgb.r, min(rgb.g, rgb.b));
+    let c = x_max - x_min;  // chroma
+
+    var swizzle = vec3<f32>(0.0);
+    if (x_max == rgb.r) {
+        swizzle = vec3(rgb.gb, 0.0);
+    } else if (x_max == rgb.g) {
+        swizzle = vec3(rgb.br, 2.0);
+    } else {
+        swizzle = vec3(rgb.rg, 4.0);
+    }
+
+    let h = FRAC_PI_3 * (((swizzle.x - swizzle.y) / c + swizzle.z) % 6.0);
+
+    // Avoid division by zero.
+    var s = 0.0;
+    if (x_max > 0.0) {
+        s = c / x_max;
+    }
+
+    return vec3(h, s, x_max);
+}
+

vendor/bevy_render/src/diagnostic/internal.rs

@@ -0,0 +1,709 @@
+use alloc::{borrow::Cow, sync::Arc};
+use core::{
+    ops::{DerefMut, Range},
+    sync::atomic::{AtomicBool, Ordering},
+};
+use std::thread::{self, ThreadId};
+
+use bevy_diagnostic::{Diagnostic, DiagnosticMeasurement, DiagnosticPath, DiagnosticsStore};
+use bevy_ecs::resource::Resource;
+use bevy_ecs::system::{Res, ResMut};
+use bevy_platform::time::Instant;
+use std::sync::Mutex;
+use wgpu::{
+    Buffer, BufferDescriptor, BufferUsages, CommandEncoder, ComputePass, Features, MapMode,
+    PipelineStatisticsTypes, QuerySet, QuerySetDescriptor, QueryType, RenderPass,
+};
+
+use crate::renderer::{RenderAdapterInfo, RenderDevice, RenderQueue, WgpuWrapper};
+
+use super::RecordDiagnostics;
+
+// buffer offset must be divisible by 256, so this constant must be divisible by 32 (=256/8)
+const MAX_TIMESTAMP_QUERIES: u32 = 256;
+const MAX_PIPELINE_STATISTICS: u32 = 128;
+
+const TIMESTAMP_SIZE: u64 = 8;
+const PIPELINE_STATISTICS_SIZE: u64 = 40;
+
+struct DiagnosticsRecorderInternal {
+    timestamp_period_ns: f32,
+    features: Features,
+    current_frame: Mutex<FrameData>,
+    submitted_frames: Vec<FrameData>,
+    finished_frames: Vec<FrameData>,
+    #[cfg(feature = "tracing-tracy")]
+    tracy_gpu_context: tracy_client::GpuContext,
+}
+
+/// Records diagnostics into [`QuerySet`]'s keeping track of the mapping between
+/// spans and indices to the corresponding entries in the [`QuerySet`].
+#[derive(Resource)]
+pub struct DiagnosticsRecorder(WgpuWrapper<DiagnosticsRecorderInternal>);
+
+impl DiagnosticsRecorder {
+    /// Creates the new `DiagnosticsRecorder`.
+    pub fn new(
+        adapter_info: &RenderAdapterInfo,
+        device: &RenderDevice,
+        queue: &RenderQueue,
+    ) -> DiagnosticsRecorder {
+        let features = device.features();
+
+        #[cfg(feature = "tracing-tracy")]
+        let tracy_gpu_context =
+            super::tracy_gpu::new_tracy_gpu_context(adapter_info, device, queue);
+        let _ = adapter_info; // Prevent unused variable warnings when tracing-tracy is not enabled
+
+        DiagnosticsRecorder(WgpuWrapper::new(DiagnosticsRecorderInternal {
+            timestamp_period_ns: queue.get_timestamp_period(),
+            features,
+            current_frame: Mutex::new(FrameData::new(
+                device,
+                features,
+                #[cfg(feature = "tracing-tracy")]
+                tracy_gpu_context.clone(),
+            )),
+            submitted_frames: Vec::new(),
+            finished_frames: Vec::new(),
+            #[cfg(feature = "tracing-tracy")]
+            tracy_gpu_context,
+        }))
+    }
+
+    fn current_frame_mut(&mut self) -> &mut FrameData {
+        self.0.current_frame.get_mut().expect("lock poisoned")
+    }
+
+    fn current_frame_lock(&self) -> impl DerefMut<Target = FrameData> + '_ {
+        self.0.current_frame.lock().expect("lock poisoned")
+    }
+
+    /// Begins recording diagnostics for a new frame.
+    pub fn begin_frame(&mut self) {
+        let internal = &mut self.0;
+        let mut idx = 0;
+        while idx < internal.submitted_frames.len() {
+            let timestamp = internal.timestamp_period_ns;
+            if internal.submitted_frames[idx].run_mapped_callback(timestamp) {
+                let removed = internal.submitted_frames.swap_remove(idx);
+                internal.finished_frames.push(removed);
+            } else {
+                idx += 1;
+            }
+        }
+
+        self.current_frame_mut().begin();
+    }
+
+    /// Copies data from [`QuerySet`]'s to a [`Buffer`], after which it can be downloaded to CPU.
+    ///
+    /// Should be called before [`DiagnosticsRecorder::finish_frame`].
+    pub fn resolve(&mut self, encoder: &mut CommandEncoder) {
+        self.current_frame_mut().resolve(encoder);
+    }
+
+    /// Finishes recording diagnostics for the current frame.
+    ///
+    /// The specified `callback` will be invoked when diagnostics become available.
+    ///
+    /// Should be called after [`DiagnosticsRecorder::resolve`],
+    /// and **after** all commands buffers have been queued.
+    pub fn finish_frame(
+        &mut self,
+        device: &RenderDevice,
+        callback: impl FnOnce(RenderDiagnostics) + Send + Sync + 'static,
+    ) {
+        #[cfg(feature = "tracing-tracy")]
+        let tracy_gpu_context = self.0.tracy_gpu_context.clone();
+
+        let internal = &mut self.0;
+        internal
+            .current_frame
+            .get_mut()
+            .expect("lock poisoned")
+            .finish(callback);
+
+        // reuse one of the finished frames, if we can
+        let new_frame = match internal.finished_frames.pop() {
+            Some(frame) => frame,
+            None => FrameData::new(
+                device,
+                internal.features,
+                #[cfg(feature = "tracing-tracy")]
+                tracy_gpu_context,
+            ),
+        };
+
+        let old_frame = core::mem::replace(
+            internal.current_frame.get_mut().expect("lock poisoned"),
+            new_frame,
+        );
+        internal.submitted_frames.push(old_frame);
+    }
+}
+
+impl RecordDiagnostics for DiagnosticsRecorder {
+    fn begin_time_span<E: WriteTimestamp>(&self, encoder: &mut E, span_name: Cow<'static, str>) {
+        self.current_frame_lock()
+            .begin_time_span(encoder, span_name);
+    }
+
+    fn end_time_span<E: WriteTimestamp>(&self, encoder: &mut E) {
+        self.current_frame_lock().end_time_span(encoder);
+    }
+
+    fn begin_pass_span<P: Pass>(&self, pass: &mut P, span_name: Cow<'static, str>) {
+        self.current_frame_lock().begin_pass(pass, span_name);
+    }
+
+    fn end_pass_span<P: Pass>(&self, pass: &mut P) {
+        self.current_frame_lock().end_pass(pass);
+    }
+}
+
+struct SpanRecord {
+    thread_id: ThreadId,
+    path_range: Range<usize>,
+    pass_kind: Option<PassKind>,
+    begin_timestamp_index: Option<u32>,
+    end_timestamp_index: Option<u32>,
+    begin_instant: Option<Instant>,
+    end_instant: Option<Instant>,
+    pipeline_statistics_index: Option<u32>,
+}
+
+struct FrameData {
+    timestamps_query_set: Option<QuerySet>,
+    num_timestamps: u32,
+    supports_timestamps_inside_passes: bool,
+    supports_timestamps_inside_encoders: bool,
+    pipeline_statistics_query_set: Option<QuerySet>,
+    num_pipeline_statistics: u32,
+    buffer_size: u64,
+    pipeline_statistics_buffer_offset: u64,
+    resolve_buffer: Option<Buffer>,
+    read_buffer: Option<Buffer>,
+    path_components: Vec<Cow<'static, str>>,
+    open_spans: Vec<SpanRecord>,
+    closed_spans: Vec<SpanRecord>,
+    is_mapped: Arc<AtomicBool>,
+    callback: Option<Box<dyn FnOnce(RenderDiagnostics) + Send + Sync + 'static>>,
+    #[cfg(feature = "tracing-tracy")]
+    tracy_gpu_context: tracy_client::GpuContext,
+}
+
+impl FrameData {
+    fn new(
+        device: &RenderDevice,
+        features: Features,
+        #[cfg(feature = "tracing-tracy")] tracy_gpu_context: tracy_client::GpuContext,
+    ) -> FrameData {
+        let wgpu_device = device.wgpu_device();
+        let mut buffer_size = 0;
+
+        let timestamps_query_set = if features.contains(Features::TIMESTAMP_QUERY) {
+            buffer_size += u64::from(MAX_TIMESTAMP_QUERIES) * TIMESTAMP_SIZE;
+            Some(wgpu_device.create_query_set(&QuerySetDescriptor {
+                label: Some("timestamps_query_set"),
+                ty: QueryType::Timestamp,
+                count: MAX_TIMESTAMP_QUERIES,
+            }))
+        } else {
+            None
+        };
+
+        let pipeline_statistics_buffer_offset = buffer_size;
+
+        let pipeline_statistics_query_set =
+            if features.contains(Features::PIPELINE_STATISTICS_QUERY) {
+                buffer_size += u64::from(MAX_PIPELINE_STATISTICS) * PIPELINE_STATISTICS_SIZE;
+                Some(wgpu_device.create_query_set(&QuerySetDescriptor {
+                    label: Some("pipeline_statistics_query_set"),
+                    ty: QueryType::PipelineStatistics(PipelineStatisticsTypes::all()),
+                    count: MAX_PIPELINE_STATISTICS,
+                }))
+            } else {
+                None
+            };
+
+        let (resolve_buffer, read_buffer) = if buffer_size > 0 {
+            let resolve_buffer = wgpu_device.create_buffer(&BufferDescriptor {
+                label: Some("render_statistics_resolve_buffer"),
+                size: buffer_size,
+                usage: BufferUsages::QUERY_RESOLVE | BufferUsages::COPY_SRC,
+                mapped_at_creation: false,
+            });
+            let read_buffer = wgpu_device.create_buffer(&BufferDescriptor {
+                label: Some("render_statistics_read_buffer"),
+                size: buffer_size,
+                usage: BufferUsages::COPY_DST | BufferUsages::MAP_READ,
+                mapped_at_creation: false,
+            });
+            (Some(resolve_buffer), Some(read_buffer))
+        } else {
+            (None, None)
+        };
+
+        FrameData {
+            timestamps_query_set,
+            num_timestamps: 0,
+            supports_timestamps_inside_passes: features
+                .contains(Features::TIMESTAMP_QUERY_INSIDE_PASSES),
+            supports_timestamps_inside_encoders: features
+                .contains(Features::TIMESTAMP_QUERY_INSIDE_ENCODERS),
+            pipeline_statistics_query_set,
+            num_pipeline_statistics: 0,
+            buffer_size,
+            pipeline_statistics_buffer_offset,
+            resolve_buffer,
+            read_buffer,
+            path_components: Vec::new(),
+            open_spans: Vec::new(),
+            closed_spans: Vec::new(),
+            is_mapped: Arc::new(AtomicBool::new(false)),
+            callback: None,
+            #[cfg(feature = "tracing-tracy")]
+            tracy_gpu_context,
+        }
+    }
+
+    fn begin(&mut self) {
+        self.num_timestamps = 0;
+        self.num_pipeline_statistics = 0;
+        self.path_components.clear();
+        self.open_spans.clear();
+        self.closed_spans.clear();
+    }
+
+    fn write_timestamp(
+        &mut self,
+        encoder: &mut impl WriteTimestamp,
+        is_inside_pass: bool,
+    ) -> Option<u32> {
+        // `encoder.write_timestamp` is unsupported on WebGPU.
+        if !self.supports_timestamps_inside_encoders {
+            return None;
+        }
+
+        if is_inside_pass && !self.supports_timestamps_inside_passes {
+            return None;
+        }
+
+        if self.num_timestamps >= MAX_TIMESTAMP_QUERIES {
+            return None;
+        }
+
+        let set = self.timestamps_query_set.as_ref()?;
+        let index = self.num_timestamps;
+        encoder.write_timestamp(set, index);
+        self.num_timestamps += 1;
+        Some(index)
+    }
+
+    fn write_pipeline_statistics(
+        &mut self,
+        encoder: &mut impl WritePipelineStatistics,
+    ) -> Option<u32> {
+        if self.num_pipeline_statistics >= MAX_PIPELINE_STATISTICS {
+            return None;
+        }
+
+        let set = self.pipeline_statistics_query_set.as_ref()?;
+        let index = self.num_pipeline_statistics;
+        encoder.begin_pipeline_statistics_query(set, index);
+        self.num_pipeline_statistics += 1;
+        Some(index)
+    }
+
+    fn open_span(
+        &mut self,
+        pass_kind: Option<PassKind>,
+        name: Cow<'static, str>,
+    ) -> &mut SpanRecord {
+        let thread_id = thread::current().id();
+
+        let parent = self
+            .open_spans
+            .iter()
+            .filter(|v| v.thread_id == thread_id)
+            .next_back();
+
+        let path_range = match &parent {
+            Some(parent) if parent.path_range.end == self.path_components.len() => {
+                parent.path_range.start..parent.path_range.end + 1
+            }
+            Some(parent) => {
+                self.path_components
+                    .extend_from_within(parent.path_range.clone());
+                self.path_components.len() - parent.path_range.len()..self.path_components.len() + 1
+            }
+            None => self.path_components.len()..self.path_components.len() + 1,
+        };
+
+        self.path_components.push(name);
+
+        self.open_spans.push(SpanRecord {
+            thread_id,
+            path_range,
+            pass_kind,
+            begin_timestamp_index: None,
+            end_timestamp_index: None,
+            begin_instant: None,
+            end_instant: None,
+            pipeline_statistics_index: None,
+        });
+
+        self.open_spans.last_mut().unwrap()
+    }
+
+    fn close_span(&mut self) -> &mut SpanRecord {
+        let thread_id = thread::current().id();
+
+        let iter = self.open_spans.iter();
+        let (index, _) = iter
+            .enumerate()
+            .filter(|(_, v)| v.thread_id == thread_id)
+            .next_back()
+            .unwrap();
+
+        let span = self.open_spans.swap_remove(index);
+        self.closed_spans.push(span);
+        self.closed_spans.last_mut().unwrap()
+    }
+
+    fn begin_time_span(&mut self, encoder: &mut impl WriteTimestamp, name: Cow<'static, str>) {
+        let begin_instant = Instant::now();
+        let begin_timestamp_index = self.write_timestamp(encoder, false);
+
+        let span = self.open_span(None, name);
+        span.begin_instant = Some(begin_instant);
+        span.begin_timestamp_index = begin_timestamp_index;
+    }
+
+    fn end_time_span(&mut self, encoder: &mut impl WriteTimestamp) {
+        let end_timestamp_index = self.write_timestamp(encoder, false);
+
+        let span = self.close_span();
+        span.end_timestamp_index = end_timestamp_index;
+        span.end_instant = Some(Instant::now());
+    }
+
+    fn begin_pass<P: Pass>(&mut self, pass: &mut P, name: Cow<'static, str>) {
+        let begin_instant = Instant::now();
+
+        let begin_timestamp_index = self.write_timestamp(pass, true);
+        let pipeline_statistics_index = self.write_pipeline_statistics(pass);
+
+        let span = self.open_span(Some(P::KIND), name);
+        span.begin_instant = Some(begin_instant);
+        span.begin_timestamp_index = begin_timestamp_index;
+        span.pipeline_statistics_index = pipeline_statistics_index;
+    }
+
+    fn end_pass(&mut self, pass: &mut impl Pass) {
+        let end_timestamp_index = self.write_timestamp(pass, true);
+
+        let span = self.close_span();
+        span.end_timestamp_index = end_timestamp_index;
+
+        if span.pipeline_statistics_index.is_some() {
+            pass.end_pipeline_statistics_query();
+        }
+
+        span.end_instant = Some(Instant::now());
+    }
+
+    fn resolve(&mut self, encoder: &mut CommandEncoder) {
+        let Some(resolve_buffer) = &self.resolve_buffer else {
+            return;
+        };
+
+        match &self.timestamps_query_set {
+            Some(set) if self.num_timestamps > 0 => {
+                encoder.resolve_query_set(set, 0..self.num_timestamps, resolve_buffer, 0);
+            }
+            _ => {}
+        }
+
+        match &self.pipeline_statistics_query_set {
+            Some(set) if self.num_pipeline_statistics > 0 => {
+                encoder.resolve_query_set(
+                    set,
+                    0..self.num_pipeline_statistics,
+                    resolve_buffer,
+                    self.pipeline_statistics_buffer_offset,
+                );
+            }
+            _ => {}
+        }
+
+        let Some(read_buffer) = &self.read_buffer else {
+            return;
+        };
+
+        encoder.copy_buffer_to_buffer(resolve_buffer, 0, read_buffer, 0, self.buffer_size);
+    }
+
+    fn diagnostic_path(&self, range: &Range<usize>, field: &str) -> DiagnosticPath {
+        DiagnosticPath::from_components(
+            core::iter::once("render")
+                .chain(self.path_components[range.clone()].iter().map(|v| &**v))
+                .chain(core::iter::once(field)),
+        )
+    }
+
+    fn finish(&mut self, callback: impl FnOnce(RenderDiagnostics) + Send + Sync + 'static) {
+        let Some(read_buffer) = &self.read_buffer else {
+            // we still have cpu timings, so let's use them
+
+            let mut diagnostics = Vec::new();
+
+            for span in &self.closed_spans {
+                if let (Some(begin), Some(end)) = (span.begin_instant, span.end_instant) {
+                    diagnostics.push(RenderDiagnostic {
+                        path: self.diagnostic_path(&span.path_range, "elapsed_cpu"),
+                        suffix: "ms",
+                        value: (end - begin).as_secs_f64() * 1000.0,
+                    });
+                }
+            }
+
+            callback(RenderDiagnostics(diagnostics));
+            return;
+        };
+
+        self.callback = Some(Box::new(callback));
+
+        let is_mapped = self.is_mapped.clone();
+        read_buffer.slice(..).map_async(MapMode::Read, move |res| {
+            if let Err(e) = res {
+                tracing::warn!("Failed to download render statistics buffer: {e}");
+                return;
+            }
+
+            is_mapped.store(true, Ordering::Release);
+        });
+    }
+
+    // returns true if the frame is considered finished, false otherwise
+    fn run_mapped_callback(&mut self, timestamp_period_ns: f32) -> bool {
+        let Some(read_buffer) = &self.read_buffer else {
+            return true;
+        };
+        if !self.is_mapped.load(Ordering::Acquire) {
+            // need to wait more
+            return false;
+        }
+        let Some(callback) = self.callback.take() else {
+            return true;
+        };
+
+        let data = read_buffer.slice(..).get_mapped_range();
+
+        let timestamps = data[..(self.num_timestamps * 8) as usize]
+            .chunks(8)
+            .map(|v| u64::from_le_bytes(v.try_into().unwrap()))
+            .collect::<Vec<u64>>();
+
+        let start = self.pipeline_statistics_buffer_offset as usize;
+        let len = (self.num_pipeline_statistics as usize) * 40;
+        let pipeline_statistics = data[start..start + len]
+            .chunks(8)
+            .map(|v| u64::from_le_bytes(v.try_into().unwrap()))
+            .collect::<Vec<u64>>();
+
+        let mut diagnostics = Vec::new();
+
+        for span in &self.closed_spans {
+            if let (Some(begin), Some(end)) = (span.begin_instant, span.end_instant) {
+                diagnostics.push(RenderDiagnostic {
+                    path: self.diagnostic_path(&span.path_range, "elapsed_cpu"),
+                    suffix: "ms",
+                    value: (end - begin).as_secs_f64() * 1000.0,
+                });
+            }
+
+            if let (Some(begin), Some(end)) = (span.begin_timestamp_index, span.end_timestamp_index)
+            {
+                let begin = timestamps[begin as usize] as f64;
+                let end = timestamps[end as usize] as f64;
+                let value = (end - begin) * (timestamp_period_ns as f64) / 1e6;
+
+                #[cfg(feature = "tracing-tracy")]
+                {
+                    // Calling span_alloc() and end_zone() here instead of in open_span() and close_span() means that tracy does not know where each GPU command was recorded on the CPU timeline.
+                    // Unfortunately we must do it this way, because tracy does not play nicely with multithreaded command recording. The start/end pairs would get all mixed up.
+                    // The GPU spans themselves are still accurate though, and it's probably safe to assume that each GPU span in frame N belongs to the corresponding CPU render node span from frame N-1.
+                    let name = &self.path_components[span.path_range.clone()].join("/");
+                    let mut tracy_gpu_span =
+                        self.tracy_gpu_context.span_alloc(name, "", "", 0).unwrap();
+                    tracy_gpu_span.end_zone();
+                    tracy_gpu_span.upload_timestamp_start(begin as i64);
+                    tracy_gpu_span.upload_timestamp_end(end as i64);
+                }
+
+                diagnostics.push(RenderDiagnostic {
+                    path: self.diagnostic_path(&span.path_range, "elapsed_gpu"),
+                    suffix: "ms",
+                    value,
+                });
+            }
+
+            if let Some(index) = span.pipeline_statistics_index {
+                let index = (index as usize) * 5;
+
+                if span.pass_kind == Some(PassKind::Render) {
+                    diagnostics.push(RenderDiagnostic {
+                        path: self.diagnostic_path(&span.path_range, "vertex_shader_invocations"),
+                        suffix: "",
+                        value: pipeline_statistics[index] as f64,
+                    });
+
+                    diagnostics.push(RenderDiagnostic {
+                        path: self.diagnostic_path(&span.path_range, "clipper_invocations"),
+                        suffix: "",
+                        value: pipeline_statistics[index + 1] as f64,
+                    });
+
+                    diagnostics.push(RenderDiagnostic {
+                        path: self.diagnostic_path(&span.path_range, "clipper_primitives_out"),
+                        suffix: "",
+                        value: pipeline_statistics[index + 2] as f64,
+                    });
+
+                    diagnostics.push(RenderDiagnostic {
+                        path: self.diagnostic_path(&span.path_range, "fragment_shader_invocations"),
+                        suffix: "",
+                        value: pipeline_statistics[index + 3] as f64,
+                    });
+                }
+
+                if span.pass_kind == Some(PassKind::Compute) {
+                    diagnostics.push(RenderDiagnostic {
+                        path: self.diagnostic_path(&span.path_range, "compute_shader_invocations"),
+                        suffix: "",
+                        value: pipeline_statistics[index + 4] as f64,
+                    });
+                }
+            }
+        }
+
+        callback(RenderDiagnostics(diagnostics));
+
+        drop(data);
+        read_buffer.unmap();
+        self.is_mapped.store(false, Ordering::Release);
+
+        true
+    }
+}
+
+/// Resource which stores render diagnostics of the most recent frame.
+#[derive(Debug, Default, Clone, Resource)]
+pub struct RenderDiagnostics(Vec<RenderDiagnostic>);
+
+/// A render diagnostic which has been recorded, but not yet stored in [`DiagnosticsStore`].
+#[derive(Debug, Clone, Resource)]
+pub struct RenderDiagnostic {
+    pub path: DiagnosticPath,
+    pub suffix: &'static str,
+    pub value: f64,
+}
+
+/// Stores render diagnostics before they can be synced with the main app.
+///
+/// This mutex is locked twice per frame:
+///  1. in `PreUpdate`, during [`sync_diagnostics`],
+///  2. after rendering has finished and statistics have been downloaded from GPU.
+#[derive(Debug, Default, Clone, Resource)]
+pub struct RenderDiagnosticsMutex(pub(crate) Arc<Mutex<Option<RenderDiagnostics>>>);
+
+/// Updates render diagnostics measurements.
+pub fn sync_diagnostics(mutex: Res<RenderDiagnosticsMutex>, mut store: ResMut<DiagnosticsStore>) {
+    let Some(diagnostics) = mutex.0.lock().ok().and_then(|mut v| v.take()) else {
+        return;
+    };
+
+    let time = Instant::now();
+
+    for diagnostic in &diagnostics.0 {
+        if store.get(&diagnostic.path).is_none() {
+            store.add(Diagnostic::new(diagnostic.path.clone()).with_suffix(diagnostic.suffix));
+        }
+
+        store
+            .get_mut(&diagnostic.path)
+            .unwrap()
+            .add_measurement(DiagnosticMeasurement {
+                time,
+                value: diagnostic.value,
+            });
+    }
+}
+
+pub trait WriteTimestamp {
+    fn write_timestamp(&mut self, query_set: &QuerySet, index: u32);
+}
+
+impl WriteTimestamp for CommandEncoder {
+    fn write_timestamp(&mut self, query_set: &QuerySet, index: u32) {
+        CommandEncoder::write_timestamp(self, query_set, index);
+    }
+}
+
+impl WriteTimestamp for RenderPass<'_> {
+    fn write_timestamp(&mut self, query_set: &QuerySet, index: u32) {
+        RenderPass::write_timestamp(self, query_set, index);
+    }
+}
+
+impl WriteTimestamp for ComputePass<'_> {
+    fn write_timestamp(&mut self, query_set: &QuerySet, index: u32) {
+        ComputePass::write_timestamp(self, query_set, index);
+    }
+}
+
+pub trait WritePipelineStatistics {
+    fn begin_pipeline_statistics_query(&mut self, query_set: &QuerySet, index: u32);
+
+    fn end_pipeline_statistics_query(&mut self);
+}
+
+impl WritePipelineStatistics for RenderPass<'_> {
+    fn begin_pipeline_statistics_query(&mut self, query_set: &QuerySet, index: u32) {
+        RenderPass::begin_pipeline_statistics_query(self, query_set, index);
+    }
+
+    fn end_pipeline_statistics_query(&mut self) {
+        RenderPass::end_pipeline_statistics_query(self);
+    }
+}
+
+impl WritePipelineStatistics for ComputePass<'_> {
+    fn begin_pipeline_statistics_query(&mut self, query_set: &QuerySet, index: u32) {
+        ComputePass::begin_pipeline_statistics_query(self, query_set, index);
+    }
+
+    fn end_pipeline_statistics_query(&mut self) {
+        ComputePass::end_pipeline_statistics_query(self);
+    }
+}
+
+pub trait Pass: WritePipelineStatistics + WriteTimestamp {
+    const KIND: PassKind;
+}
+
+impl Pass for RenderPass<'_> {
+    const KIND: PassKind = PassKind::Render;
+}
+
+impl Pass for ComputePass<'_> {
+    const KIND: PassKind = PassKind::Compute;
+}
+
+#[derive(Debug, Clone, Copy, Eq, PartialEq, Hash)]
+pub enum PassKind {
+    Render,
+    Compute,
+}

vendor/bevy_render/src/diagnostic/mod.rs

@@ -0,0 +1,188 @@
+//! Infrastructure for recording render diagnostics.
+//!
+//! For more info, see [`RenderDiagnosticsPlugin`].
+
+pub(crate) mod internal;
+#[cfg(feature = "tracing-tracy")]
+mod tracy_gpu;
+
+use alloc::{borrow::Cow, sync::Arc};
+use core::marker::PhantomData;
+
+use bevy_app::{App, Plugin, PreUpdate};
+
+use crate::{renderer::RenderAdapterInfo, RenderApp};
+
+use self::internal::{
+    sync_diagnostics, DiagnosticsRecorder, Pass, RenderDiagnosticsMutex, WriteTimestamp,
+};
+
+use super::{RenderDevice, RenderQueue};
+
+/// Enables collecting render diagnostics, such as CPU/GPU elapsed time per render pass,
+/// as well as pipeline statistics (number of primitives, number of shader invocations, etc).
+///
+/// To access the diagnostics, you can use the [`DiagnosticsStore`](bevy_diagnostic::DiagnosticsStore) resource,
+/// add [`LogDiagnosticsPlugin`](bevy_diagnostic::LogDiagnosticsPlugin), or use [Tracy](https://github.com/bevyengine/bevy/blob/main/docs/profiling.md#tracy-renderqueue).
+///
+/// To record diagnostics in your own passes:
+///  1. First, obtain the diagnostic recorder using [`RenderContext::diagnostic_recorder`](crate::renderer::RenderContext::diagnostic_recorder).
+///
+///     It won't do anything unless [`RenderDiagnosticsPlugin`] is present,
+///     so you're free to omit `#[cfg]` clauses.
+///     ```ignore
+///     let diagnostics = render_context.diagnostic_recorder();
+///     ```
+///  2. Begin the span inside a command encoder, or a render/compute pass encoder.
+///     ```ignore
+///     let time_span = diagnostics.time_span(render_context.command_encoder(), "shadows");
+///     ```
+///  3. End the span, providing the same encoder.
+///     ```ignore
+///     time_span.end(render_context.command_encoder());
+///     ```
+///
+/// # Supported platforms
+/// Timestamp queries and pipeline statistics are currently supported only on Vulkan and DX12.
+/// On other platforms (Metal, WebGPU, WebGL2) only CPU time will be recorded.
+#[derive(Default)]
+pub struct RenderDiagnosticsPlugin;
+
+impl Plugin for RenderDiagnosticsPlugin {
+    fn build(&self, app: &mut App) {
+        let render_diagnostics_mutex = RenderDiagnosticsMutex::default();
+        app.insert_resource(render_diagnostics_mutex.clone())
+            .add_systems(PreUpdate, sync_diagnostics);
+
+        if let Some(render_app) = app.get_sub_app_mut(RenderApp) {
+            render_app.insert_resource(render_diagnostics_mutex);
+        }
+    }
+
+    fn finish(&self, app: &mut App) {
+        let Some(render_app) = app.get_sub_app_mut(RenderApp) else {
+            return;
+        };
+
+        let adapter_info = render_app.world().resource::<RenderAdapterInfo>();
+        let device = render_app.world().resource::<RenderDevice>();
+        let queue = render_app.world().resource::<RenderQueue>();
+        render_app.insert_resource(DiagnosticsRecorder::new(adapter_info, device, queue));
+    }
+}
+
+/// Allows recording diagnostic spans.
+pub trait RecordDiagnostics: Send + Sync {
+    /// Begin a time span, which will record elapsed CPU and GPU time.
+    ///
+    /// Returns a guard, which will panic on drop unless you end the span.
+    fn time_span<E, N>(&self, encoder: &mut E, name: N) -> TimeSpanGuard<'_, Self, E>
+    where
+        E: WriteTimestamp,
+        N: Into<Cow<'static, str>>,
+    {
+        self.begin_time_span(encoder, name.into());
+        TimeSpanGuard {
+            recorder: self,
+            marker: PhantomData,
+        }
+    }
+
+    /// Begin a pass span, which will record elapsed CPU and GPU time,
+    /// as well as pipeline statistics on supported platforms.
+    ///
+    /// Returns a guard, which will panic on drop unless you end the span.
+    fn pass_span<P, N>(&self, pass: &mut P, name: N) -> PassSpanGuard<'_, Self, P>
+    where
+        P: Pass,
+        N: Into<Cow<'static, str>>,
+    {
+        self.begin_pass_span(pass, name.into());
+        PassSpanGuard {
+            recorder: self,
+            marker: PhantomData,
+        }
+    }
+
+    #[doc(hidden)]
+    fn begin_time_span<E: WriteTimestamp>(&self, encoder: &mut E, name: Cow<'static, str>);
+
+    #[doc(hidden)]
+    fn end_time_span<E: WriteTimestamp>(&self, encoder: &mut E);
+
+    #[doc(hidden)]
+    fn begin_pass_span<P: Pass>(&self, pass: &mut P, name: Cow<'static, str>);
+
+    #[doc(hidden)]
+    fn end_pass_span<P: Pass>(&self, pass: &mut P);
+}
+
+/// Guard returned by [`RecordDiagnostics::time_span`].
+///
+/// Will panic on drop unless [`TimeSpanGuard::end`] is called.
+pub struct TimeSpanGuard<'a, R: ?Sized, E> {
+    recorder: &'a R,
+    marker: PhantomData<E>,
+}
+
+impl<R: RecordDiagnostics + ?Sized, E: WriteTimestamp> TimeSpanGuard<'_, R, E> {
+    /// End the span. You have to provide the same encoder which was used to begin the span.
+    pub fn end(self, encoder: &mut E) {
+        self.recorder.end_time_span(encoder);
+        core::mem::forget(self);
+    }
+}
+
+impl<R: ?Sized, E> Drop for TimeSpanGuard<'_, R, E> {
+    fn drop(&mut self) {
+        panic!("TimeSpanScope::end was never called")
+    }
+}
+
+/// Guard returned by [`RecordDiagnostics::pass_span`].
+///
+/// Will panic on drop unless [`PassSpanGuard::end`] is called.
+pub struct PassSpanGuard<'a, R: ?Sized, P> {
+    recorder: &'a R,
+    marker: PhantomData<P>,
+}
+
+impl<R: RecordDiagnostics + ?Sized, P: Pass> PassSpanGuard<'_, R, P> {
+    /// End the span. You have to provide the same encoder which was used to begin the span.
+    pub fn end(self, pass: &mut P) {
+        self.recorder.end_pass_span(pass);
+        core::mem::forget(self);
+    }
+}
+
+impl<R: ?Sized, P> Drop for PassSpanGuard<'_, R, P> {
+    fn drop(&mut self) {
+        panic!("PassSpanScope::end was never called")
+    }
+}
+
+impl<T: RecordDiagnostics> RecordDiagnostics for Option<Arc<T>> {
+    fn begin_time_span<E: WriteTimestamp>(&self, encoder: &mut E, name: Cow<'static, str>) {
+        if let Some(recorder) = &self {
+            recorder.begin_time_span(encoder, name);
+        }
+    }
+
+    fn end_time_span<E: WriteTimestamp>(&self, encoder: &mut E) {
+        if let Some(recorder) = &self {
+            recorder.end_time_span(encoder);
+        }
+    }
+
+    fn begin_pass_span<P: Pass>(&self, pass: &mut P, name: Cow<'static, str>) {
+        if let Some(recorder) = &self {
+            recorder.begin_pass_span(pass, name);
+        }
+    }
+
+    fn end_pass_span<P: Pass>(&self, pass: &mut P) {
+        if let Some(recorder) = &self {
+            recorder.end_pass_span(pass);
+        }
+    }
+}

vendor/bevy_render/src/diagnostic/tracy_gpu.rs

@@ -0,0 +1,67 @@
+use crate::renderer::{RenderAdapterInfo, RenderDevice, RenderQueue};
+use tracy_client::{Client, GpuContext, GpuContextType};
+use wgpu::{
+    Backend, BufferDescriptor, BufferUsages, CommandEncoderDescriptor, Maintain, MapMode,
+    QuerySetDescriptor, QueryType, QUERY_SIZE,
+};
+
+pub fn new_tracy_gpu_context(
+    adapter_info: &RenderAdapterInfo,
+    device: &RenderDevice,
+    queue: &RenderQueue,
+) -> GpuContext {
+    let tracy_gpu_backend = match adapter_info.backend {
+        Backend::Vulkan => GpuContextType::Vulkan,
+        Backend::Dx12 => GpuContextType::Direct3D12,
+        Backend::Gl => GpuContextType::OpenGL,
+        Backend::Metal | Backend::BrowserWebGpu | Backend::Empty => GpuContextType::Invalid,
+    };
+
+    let tracy_client = Client::running().unwrap();
+    tracy_client
+        .new_gpu_context(
+            Some("RenderQueue"),
+            tracy_gpu_backend,
+            initial_timestamp(device, queue),
+            queue.get_timestamp_period(),
+        )
+        .unwrap()
+}
+
+// Code copied from https://github.com/Wumpf/wgpu-profiler/blob/f9de342a62cb75f50904a98d11dd2bbeb40ceab8/src/tracy.rs
+fn initial_timestamp(device: &RenderDevice, queue: &RenderQueue) -> i64 {
+    let query_set = device.wgpu_device().create_query_set(&QuerySetDescriptor {
+        label: None,
+        ty: QueryType::Timestamp,
+        count: 1,
+    });
+
+    let resolve_buffer = device.create_buffer(&BufferDescriptor {
+        label: None,
+        size: QUERY_SIZE as _,
+        usage: BufferUsages::QUERY_RESOLVE | BufferUsages::COPY_SRC,
+        mapped_at_creation: false,
+    });
+
+    let map_buffer = device.create_buffer(&BufferDescriptor {
+        label: None,
+        size: QUERY_SIZE as _,
+        usage: BufferUsages::MAP_READ | BufferUsages::COPY_DST,
+        mapped_at_creation: false,
+    });
+
+    let mut timestamp_encoder = device.create_command_encoder(&CommandEncoderDescriptor::default());
+    timestamp_encoder.write_timestamp(&query_set, 0);
+    timestamp_encoder.resolve_query_set(&query_set, 0..1, &resolve_buffer, 0);
+    // Workaround for https://github.com/gfx-rs/wgpu/issues/6406
+    // TODO when that bug is fixed, merge these encoders together again
+    let mut copy_encoder = device.create_command_encoder(&CommandEncoderDescriptor::default());
+    copy_encoder.copy_buffer_to_buffer(&resolve_buffer, 0, &map_buffer, 0, QUERY_SIZE as _);
+    queue.submit([timestamp_encoder.finish(), copy_encoder.finish()]);
+
+    map_buffer.slice(..).map_async(MapMode::Read, |_| ());
+    device.poll(Maintain::Wait);
+
+    let view = map_buffer.slice(..).get_mapped_range();
+    i64::from_le_bytes((*view).try_into().unwrap())
+}

vendor/bevy_render/src/experimental/mod.rs

@@ -0,0 +1,6 @@
+//! Experimental rendering features.
+//!
+//! Experimental features are features with known problems, but are included
+//! nonetheless for testing purposes.
+
+pub mod occlusion_culling;

vendor/bevy_render/src/experimental/occlusion_culling/mesh_preprocess_types.wgsl

@@ -0,0 +1,69 @@
+// Types needed for GPU mesh uniform building.
+
+#define_import_path bevy_pbr::mesh_preprocess_types
+
+// Per-frame data that the CPU supplies to the GPU.
+struct MeshInput {
+    // The model transform.
+    world_from_local: mat3x4<f32>,
+    // The lightmap UV rect, packed into 64 bits.
+    lightmap_uv_rect: vec2<u32>,
+    // Various flags.
+    flags: u32,
+    previous_input_index: u32,
+    first_vertex_index: u32,
+    first_index_index: u32,
+    index_count: u32,
+    current_skin_index: u32,
+    // Low 16 bits: index of the material inside the bind group data.
+    // High 16 bits: index of the lightmap in the binding array.
+    material_and_lightmap_bind_group_slot: u32,
+    timestamp: u32,
+    // User supplied index to identify the mesh instance
+    tag: u32,
+    pad: u32,
+}
+
+// The `wgpu` indirect parameters structure. This is a union of two structures.
+// For more information, see the corresponding comment in
+// `gpu_preprocessing.rs`.
+struct IndirectParametersIndexed {
+    // `vertex_count` or `index_count`.
+    index_count: u32,
+    // `instance_count` in both structures.
+    instance_count: u32,
+    // `first_vertex` or `first_index`.
+    first_index: u32,
+    // `base_vertex` or `first_instance`.
+    base_vertex: u32,
+    // A read-only copy of `instance_index`.
+    first_instance: u32,
+}
+
+struct IndirectParametersNonIndexed {
+    vertex_count: u32,
+    instance_count: u32,
+    base_vertex: u32,
+    first_instance: u32,
+}
+
+struct IndirectParametersCpuMetadata {
+    base_output_index: u32,
+    batch_set_index: u32,
+}
+
+struct IndirectParametersGpuMetadata {
+    mesh_index: u32,
+#ifdef WRITE_INDIRECT_PARAMETERS_METADATA
+    early_instance_count: atomic<u32>,
+    late_instance_count: atomic<u32>,
+#else   // WRITE_INDIRECT_PARAMETERS_METADATA
+    early_instance_count: u32,
+    late_instance_count: u32,
+#endif  // WRITE_INDIRECT_PARAMETERS_METADATA
+}
+
+struct IndirectBatchSet {
+    indirect_parameters_count: atomic<u32>,
+    indirect_parameters_base: u32,
+}

vendor/bevy_render/src/experimental/occlusion_culling/mod.rs

@@ -0,0 +1,116 @@
+//! GPU occlusion culling.
+//!
+//! See [`OcclusionCulling`] for a detailed description of occlusion culling in
+//! Bevy.
+
+use bevy_app::{App, Plugin};
+use bevy_asset::{load_internal_asset, weak_handle, Handle};
+use bevy_ecs::{component::Component, entity::Entity, prelude::ReflectComponent};
+use bevy_reflect::{prelude::ReflectDefault, Reflect};
+
+use crate::{
+    extract_component::ExtractComponent,
+    render_resource::{Shader, TextureView},
+};
+
+/// The handle to the `mesh_preprocess_types.wgsl` compute shader.
+pub const MESH_PREPROCESS_TYPES_SHADER_HANDLE: Handle<Shader> =
+    weak_handle!("7bf7bdb1-ec53-4417-987f-9ec36533287c");
+
+/// Enables GPU occlusion culling.
+///
+/// See [`OcclusionCulling`] for a detailed description of occlusion culling in
+/// Bevy.
+pub struct OcclusionCullingPlugin;
+
+impl Plugin for OcclusionCullingPlugin {
+    fn build(&self, app: &mut App) {
+        load_internal_asset!(
+            app,
+            MESH_PREPROCESS_TYPES_SHADER_HANDLE,
+            "mesh_preprocess_types.wgsl",
+            Shader::from_wgsl
+        );
+    }
+}
+
+/// Add this component to a view in order to enable experimental GPU occlusion
+/// culling.
+///
+/// *Bevy's occlusion culling is currently marked as experimental.* There are
+/// known issues whereby, in rare circumstances, occlusion culling can result in
+/// meshes being culled that shouldn't be (i.e. meshes that turn invisible).
+/// Please try it out and report issues.
+///
+/// *Occlusion culling* allows Bevy to avoid rendering objects that are fully
+/// behind other opaque or alpha tested objects. This is different from, and
+/// complements, depth fragment rejection as the `DepthPrepass` enables. While
+/// depth rejection allows Bevy to avoid rendering *pixels* that are behind
+/// other objects, the GPU still has to examine those pixels to reject them,
+/// which requires transforming the vertices of the objects and performing
+/// skinning if the objects were skinned. Occlusion culling allows the GPU to go
+/// a step further, avoiding even transforming the vertices of objects that it
+/// can quickly prove to be behind other objects.
+///
+/// Occlusion culling inherently has some overhead, because Bevy must examine
+/// the objects' bounding boxes, and create an acceleration structure
+/// (hierarchical Z-buffer) to perform the occlusion tests. Therefore, occlusion
+/// culling is disabled by default. Only enable it if you measure it to be a
+/// speedup on your scene. Note that, because Bevy's occlusion culling runs on
+/// the GPU and is quite efficient, it's rare for occlusion culling to result in
+/// a significant slowdown.
+///
+/// Occlusion culling currently requires a `DepthPrepass`. If no depth prepass
+/// is present on the view, the [`OcclusionCulling`] component will be ignored.
+/// Additionally, occlusion culling is currently incompatible with deferred
+/// shading; including both `DeferredPrepass` and [`OcclusionCulling`] results
+/// in unspecified behavior.
+///
+/// The algorithm that Bevy uses is known as [*two-phase occlusion culling*].
+/// When you enable occlusion culling, Bevy splits the depth prepass into two:
+/// an *early* depth prepass and a *late* depth prepass. The early depth prepass
+/// renders all the meshes that were visible last frame to produce a
+/// conservative approximation of the depth buffer. Then, after producing an
+/// acceleration structure known as a hierarchical Z-buffer or depth pyramid,
+/// Bevy tests the bounding boxes of all meshes against that depth buffer. Those
+/// that can be quickly proven to be behind the geometry rendered during the
+/// early depth prepass are skipped entirely. The other potentially-visible
+/// meshes are rendered during the late prepass, and finally all the visible
+/// meshes are rendered as usual during the opaque, transparent, etc. passes.
+///
+/// Unlike other occlusion culling systems you may be familiar with, Bevy's
+/// occlusion culling is fully dynamic and requires no baking step. The CPU
+/// overhead is minimal. Large skinned meshes and other dynamic objects can
+/// occlude other objects.
+///
+/// [*two-phase occlusion culling*]:
+/// https://medium.com/@mil_kru/two-pass-occlusion-culling-4100edcad501
+#[derive(Component, ExtractComponent, Clone, Copy, Default, Reflect)]
+#[reflect(Component, Default, Clone)]
+pub struct OcclusionCulling;
+
+/// A render-world component that contains resources necessary to perform
+/// occlusion culling on any view other than a camera.
+///
+/// Bevy automatically places this component on views created for shadow
+/// mapping. You don't ordinarily need to add this component yourself.
+#[derive(Clone, Component)]
+pub struct OcclusionCullingSubview {
+    /// A texture view of the Z-buffer.
+    pub depth_texture_view: TextureView,
+    /// The size of the texture along both dimensions.
+    ///
+    /// Because [`OcclusionCullingSubview`] is only currently used for shadow
+    /// maps, they're guaranteed to have sizes equal to a power of two, so we
+    /// don't have to store the two dimensions individually here.
+    pub depth_texture_size: u32,
+}
+
+/// A render-world component placed on each camera that stores references to all
+/// entities other than cameras that need occlusion culling.
+///
+/// Bevy automatically places this component on cameras that are drawing
+/// shadows, when those shadows come from lights with occlusion culling enabled.
+/// You don't ordinarily need to add this component yourself.
+#[derive(Clone, Component)]
+pub struct OcclusionCullingSubviewEntities(pub Vec<Entity>);

vendor/bevy_render/src/extract_component.rs

@@ -0,0 +1,236 @@
+use crate::{
+    render_resource::{encase::internal::WriteInto, DynamicUniformBuffer, ShaderType},
+    renderer::{RenderDevice, RenderQueue},
+    sync_component::SyncComponentPlugin,
+    sync_world::RenderEntity,
+    view::ViewVisibility,
+    Extract, ExtractSchedule, Render, RenderApp, RenderSet,
+};
+use bevy_app::{App, Plugin};
+use bevy_ecs::{
+    bundle::NoBundleEffect,
+    component::Component,
+    prelude::*,
+    query::{QueryFilter, QueryItem, ReadOnlyQueryData},
+};
+use core::{marker::PhantomData, ops::Deref};
+
+pub use bevy_render_macros::ExtractComponent;
+
+/// Stores the index of a uniform inside of [`ComponentUniforms`].
+#[derive(Component)]
+pub struct DynamicUniformIndex<C: Component> {
+    index: u32,
+    marker: PhantomData<C>,
+}
+
+impl<C: Component> DynamicUniformIndex<C> {
+    #[inline]
+    pub fn index(&self) -> u32 {
+        self.index
+    }
+}
+
+/// Describes how a component gets extracted for rendering.
+///
+/// Therefore the component is transferred from the "app world" into the "render world"
+/// in the [`ExtractSchedule`] step.
+pub trait ExtractComponent: Component {
+    /// ECS [`ReadOnlyQueryData`] to fetch the components to extract.
+    type QueryData: ReadOnlyQueryData;
+    /// Filters the entities with additional constraints.
+    type QueryFilter: QueryFilter;
+
+    /// The output from extraction.
+    ///
+    /// Returning `None` based on the queried item will remove the component from the entity in
+    /// the render world. This can be used, for example, to conditionally extract camera settings
+    /// in order to disable a rendering feature on the basis of those settings, without removing
+    /// the component from the entity in the main world.
+    ///
+    /// The output may be different from the queried component.
+    /// This can be useful for example if only a subset of the fields are useful
+    /// in the render world.
+    ///
+    /// `Out` has a [`Bundle`] trait bound instead of a [`Component`] trait bound in order to allow use cases
+    /// such as tuples of components as output.
+    type Out: Bundle<Effect: NoBundleEffect>;
+
+    // TODO: https://github.com/rust-lang/rust/issues/29661
+    // type Out: Component = Self;
+
+    /// Defines how the component is transferred into the "render world".
+    fn extract_component(item: QueryItem<'_, Self::QueryData>) -> Option<Self::Out>;
+}
+
+/// This plugin prepares the components of the corresponding type for the GPU
+/// by transforming them into uniforms.
+///
+/// They can then be accessed from the [`ComponentUniforms`] resource.
+/// For referencing the newly created uniforms a [`DynamicUniformIndex`] is inserted
+/// for every processed entity.
+///
+/// Therefore it sets up the [`RenderSet::Prepare`] step
+/// for the specified [`ExtractComponent`].
+pub struct UniformComponentPlugin<C>(PhantomData<fn() -> C>);
+
+impl<C> Default for UniformComponentPlugin<C> {
+    fn default() -> Self {
+        Self(PhantomData)
+    }
+}
+
+impl<C: Component + ShaderType + WriteInto + Clone> Plugin for UniformComponentPlugin<C> {
+    fn build(&self, app: &mut App) {
+        if let Some(render_app) = app.get_sub_app_mut(RenderApp) {
+            render_app
+                .insert_resource(ComponentUniforms::<C>::default())
+                .add_systems(
+                    Render,
+                    prepare_uniform_components::<C>.in_set(RenderSet::PrepareResources),
+                );
+        }
+    }
+}
+
+/// Stores all uniforms of the component type.
+#[derive(Resource)]
+pub struct ComponentUniforms<C: Component + ShaderType> {
+    uniforms: DynamicUniformBuffer<C>,
+}
+
+impl<C: Component + ShaderType> Deref for ComponentUniforms<C> {
+    type Target = DynamicUniformBuffer<C>;
+
+    #[inline]
+    fn deref(&self) -> &Self::Target {
+        &self.uniforms
+    }
+}
+
+impl<C: Component + ShaderType> ComponentUniforms<C> {
+    #[inline]
+    pub fn uniforms(&self) -> &DynamicUniformBuffer<C> {
+        &self.uniforms
+    }
+}
+
+impl<C: Component + ShaderType> Default for ComponentUniforms<C> {
+    fn default() -> Self {
+        Self {
+            uniforms: Default::default(),
+        }
+    }
+}
+
+/// This system prepares all components of the corresponding component type.
+/// They are transformed into uniforms and stored in the [`ComponentUniforms`] resource.
+fn prepare_uniform_components<C>(
+    mut commands: Commands,
+    render_device: Res<RenderDevice>,
+    render_queue: Res<RenderQueue>,
+    mut component_uniforms: ResMut<ComponentUniforms<C>>,
+    components: Query<(Entity, &C)>,
+) where
+    C: Component + ShaderType + WriteInto + Clone,
+{
+    let components_iter = components.iter();
+    let count = components_iter.len();
+    let Some(mut writer) =
+        component_uniforms
+            .uniforms
+            .get_writer(count, &render_device, &render_queue)
+    else {
+        return;
+    };
+    let entities = components_iter
+        .map(|(entity, component)| {
+            (
+                entity,
+                DynamicUniformIndex::<C> {
+                    index: writer.write(component),
+                    marker: PhantomData,
+                },
+            )
+        })
+        .collect::<Vec<_>>();
+    commands.try_insert_batch(entities);
+}
+
+/// This plugin extracts the components into the render world for synced entities.
+///
+/// To do so, it sets up the [`ExtractSchedule`] step for the specified [`ExtractComponent`].
+pub struct ExtractComponentPlugin<C, F = ()> {
+    only_extract_visible: bool,
+    marker: PhantomData<fn() -> (C, F)>,
+}
+
+impl<C, F> Default for ExtractComponentPlugin<C, F> {
+    fn default() -> Self {
+        Self {
+            only_extract_visible: false,
+            marker: PhantomData,
+        }
+    }
+}
+
+impl<C, F> ExtractComponentPlugin<C, F> {
+    pub fn extract_visible() -> Self {
+        Self {
+            only_extract_visible: true,
+            marker: PhantomData,
+        }
+    }
+}
+
+impl<C: ExtractComponent> Plugin for ExtractComponentPlugin<C> {
+    fn build(&self, app: &mut App) {
+        app.add_plugins(SyncComponentPlugin::<C>::default());
+
+        if let Some(render_app) = app.get_sub_app_mut(RenderApp) {
+            if self.only_extract_visible {
+                render_app.add_systems(ExtractSchedule, extract_visible_components::<C>);
+            } else {
+                render_app.add_systems(ExtractSchedule, extract_components::<C>);
+            }
+        }
+    }
+}
+
+/// This system extracts all components of the corresponding [`ExtractComponent`], for entities that are synced via [`crate::sync_world::SyncToRenderWorld`].
+fn extract_components<C: ExtractComponent>(
+    mut commands: Commands,
+    mut previous_len: Local<usize>,
+    query: Extract<Query<(RenderEntity, C::QueryData), C::QueryFilter>>,
+) {
+    let mut values = Vec::with_capacity(*previous_len);
+    for (entity, query_item) in &query {
+        if let Some(component) = C::extract_component(query_item) {
+            values.push((entity, component));
+        } else {
+            commands.entity(entity).remove::<C::Out>();
+        }
+    }
+    *previous_len = values.len();
+    commands.try_insert_batch(values);
+}
+
+/// This system extracts all components of the corresponding [`ExtractComponent`], for entities that are visible and synced via [`crate::sync_world::SyncToRenderWorld`].
+fn extract_visible_components<C: ExtractComponent>(
+    mut commands: Commands,
+    mut previous_len: Local<usize>,
+    query: Extract<Query<(RenderEntity, &ViewVisibility, C::QueryData), C::QueryFilter>>,
+) {
+    let mut values = Vec::with_capacity(*previous_len);
+    for (entity, view_visibility, query_item) in &query {
+        if view_visibility.get() {
+            if let Some(component) = C::extract_component(query_item) {
+                values.push((entity, component));
+            } else {
+                commands.entity(entity).remove::<C::Out>();
+            }
+        }
+    }
+    *previous_len = values.len();
+    commands.try_insert_batch(values);
+}

vendor/bevy_render/src/extract_instances.rs

@@ -0,0 +1,136 @@
+//! Convenience logic for turning components from the main world into extracted
+//! instances in the render world.
+//!
+//! This is essentially the same as the `extract_component` module, but
+//! higher-performance because it avoids the ECS overhead.
+
+use core::marker::PhantomData;
+
+use bevy_app::{App, Plugin};
+use bevy_derive::{Deref, DerefMut};
+use bevy_ecs::{
+    prelude::Entity,
+    query::{QueryFilter, QueryItem, ReadOnlyQueryData},
+    resource::Resource,
+    system::{Query, ResMut},
+};
+
+use crate::sync_world::MainEntityHashMap;
+use crate::{prelude::ViewVisibility, Extract, ExtractSchedule, RenderApp};
+
+/// Describes how to extract data needed for rendering from a component or
+/// components.
+///
+/// Before rendering, any applicable components will be transferred from the
+/// main world to the render world in the [`ExtractSchedule`] step.
+///
+/// This is essentially the same as
+/// [`ExtractComponent`](crate::extract_component::ExtractComponent), but
+/// higher-performance because it avoids the ECS overhead.
+pub trait ExtractInstance: Send + Sync + Sized + 'static {
+    /// ECS [`ReadOnlyQueryData`] to fetch the components to extract.
+    type QueryData: ReadOnlyQueryData;
+    /// Filters the entities with additional constraints.
+    type QueryFilter: QueryFilter;
+
+    /// Defines how the component is transferred into the "render world".
+    fn extract(item: QueryItem<'_, Self::QueryData>) -> Option<Self>;
+}
+
+/// This plugin extracts one or more components into the "render world" as
+/// extracted instances.
+///
+/// Therefore it sets up the [`ExtractSchedule`] step for the specified
+/// [`ExtractedInstances`].
+#[derive(Default)]
+pub struct ExtractInstancesPlugin<EI>
+where
+    EI: ExtractInstance,
+{
+    only_extract_visible: bool,
+    marker: PhantomData<fn() -> EI>,
+}
+
+/// Stores all extract instances of a type in the render world.
+#[derive(Resource, Deref, DerefMut)]
+pub struct ExtractedInstances<EI>(MainEntityHashMap<EI>)
+where
+    EI: ExtractInstance;
+
+impl<EI> Default for ExtractedInstances<EI>
+where
+    EI: ExtractInstance,
+{
+    fn default() -> Self {
+        Self(Default::default())
+    }
+}
+
+impl<EI> ExtractInstancesPlugin<EI>
+where
+    EI: ExtractInstance,
+{
+    /// Creates a new [`ExtractInstancesPlugin`] that unconditionally extracts to
+    /// the render world, whether the entity is visible or not.
+    pub fn new() -> Self {
+        Self {
+            only_extract_visible: false,
+            marker: PhantomData,
+        }
+    }
+
+    /// Creates a new [`ExtractInstancesPlugin`] that extracts to the render world
+    /// if and only if the entity it's attached to is visible.
+    pub fn extract_visible() -> Self {
+        Self {
+            only_extract_visible: true,
+            marker: PhantomData,
+        }
+    }
+}
+
+impl<EI> Plugin for ExtractInstancesPlugin<EI>
+where
+    EI: ExtractInstance,
+{
+    fn build(&self, app: &mut App) {
+        if let Some(render_app) = app.get_sub_app_mut(RenderApp) {
+            render_app.init_resource::<ExtractedInstances<EI>>();
+            if self.only_extract_visible {
+                render_app.add_systems(ExtractSchedule, extract_visible::<EI>);
+            } else {
+                render_app.add_systems(ExtractSchedule, extract_all::<EI>);
+            }
+        }
+    }
+}
+
+fn extract_all<EI>(
+    mut extracted_instances: ResMut<ExtractedInstances<EI>>,
+    query: Extract<Query<(Entity, EI::QueryData), EI::QueryFilter>>,
+) where
+    EI: ExtractInstance,
+{
+    extracted_instances.clear();
+    for (entity, other) in &query {
+        if let Some(extract_instance) = EI::extract(other) {
+            extracted_instances.insert(entity.into(), extract_instance);
+        }
+    }
+}
+
+fn extract_visible<EI>(
+    mut extracted_instances: ResMut<ExtractedInstances<EI>>,
+    query: Extract<Query<(Entity, &ViewVisibility, EI::QueryData), EI::QueryFilter>>,
+) where
+    EI: ExtractInstance,
+{
+    extracted_instances.clear();
+    for (entity, view_visibility, other) in &query {
+        if view_visibility.get() {
+            if let Some(extract_instance) = EI::extract(other) {
+                extracted_instances.insert(entity.into(), extract_instance);
+            }
+        }
+    }
+}

vendor/bevy_render/src/extract_param.rs

@@ -0,0 +1,162 @@
+use crate::MainWorld;
+use bevy_ecs::{
+    component::Tick,
+    prelude::*,
+    system::{
+        ReadOnlySystemParam, SystemMeta, SystemParam, SystemParamItem, SystemParamValidationError,
+        SystemState,
+    },
+    world::unsafe_world_cell::UnsafeWorldCell,
+};
+use core::ops::{Deref, DerefMut};
+
+/// A helper for accessing [`MainWorld`] content using a system parameter.
+///
+/// A [`SystemParam`] adapter which applies the contained `SystemParam` to the [`World`]
+/// contained in [`MainWorld`]. This parameter only works for systems run
+/// during the [`ExtractSchedule`](crate::ExtractSchedule).
+///
+/// This requires that the contained [`SystemParam`] does not mutate the world, as it
+/// uses a read-only reference to [`MainWorld`] internally.
+///
+/// ## Context
+///
+/// [`ExtractSchedule`] is used to extract (move) data from the simulation world ([`MainWorld`]) to the
+/// render world. The render world drives rendering each frame (generally to a `Window`).
+/// This design is used to allow performing calculations related to rendering a prior frame at the same
+/// time as the next frame is simulated, which increases throughput (FPS).
+///
+/// [`Extract`] is used to get data from the main world during [`ExtractSchedule`].
+///
+/// ## Examples
+///
+/// ```
+/// use bevy_ecs::prelude::*;
+/// use bevy_render::Extract;
+/// use bevy_render::sync_world::RenderEntity;
+/// # #[derive(Component)]
+/// // Do make sure to sync the cloud entities before extracting them.
+/// # struct Cloud;
+/// fn extract_clouds(mut commands: Commands, clouds: Extract<Query<RenderEntity, With<Cloud>>>) {
+///     for cloud in &clouds {
+///         commands.entity(cloud).insert(Cloud);
+///     }
+/// }
+/// ```
+///
+/// [`ExtractSchedule`]: crate::ExtractSchedule
+/// [Window]: bevy_window::Window
+pub struct Extract<'w, 's, P>
+where
+    P: ReadOnlySystemParam + 'static,
+{
+    item: SystemParamItem<'w, 's, P>,
+}
+
+#[doc(hidden)]
+pub struct ExtractState<P: SystemParam + 'static> {
+    state: SystemState<P>,
+    main_world_state: <Res<'static, MainWorld> as SystemParam>::State,
+}
+
+// SAFETY: The only `World` access (`Res<MainWorld>`) is read-only.
+unsafe impl<P> ReadOnlySystemParam for Extract<'_, '_, P> where P: ReadOnlySystemParam {}
+
+// SAFETY: The only `World` access is properly registered by `Res<MainWorld>::init_state`.
+// This call will also ensure that there are no conflicts with prior params.
+unsafe impl<P> SystemParam for Extract<'_, '_, P>
+where
+    P: ReadOnlySystemParam,
+{
+    type State = ExtractState<P>;
+    type Item<'w, 's> = Extract<'w, 's, P>;
+
+    fn init_state(world: &mut World, system_meta: &mut SystemMeta) -> Self::State {
+        let mut main_world = world.resource_mut::<MainWorld>();
+        ExtractState {
+            state: SystemState::new(&mut main_world),
+            main_world_state: Res::<MainWorld>::init_state(world, system_meta),
+        }
+    }
+
+    #[inline]
+    unsafe fn validate_param(
+        state: &Self::State,
+        _system_meta: &SystemMeta,
+        world: UnsafeWorldCell,
+    ) -> Result<(), SystemParamValidationError> {
+        // SAFETY: Read-only access to world data registered in `init_state`.
+        let result = unsafe { world.get_resource_by_id(state.main_world_state) };
+        let Some(main_world) = result else {
+            return Err(SystemParamValidationError::invalid::<Self>(
+                "`MainWorld` resource does not exist",
+            ));
+        };
+        // SAFETY: Type is guaranteed by `SystemState`.
+        let main_world: &World = unsafe { main_world.deref() };
+        // SAFETY: We provide the main world on which this system state was initialized on.
+        unsafe {
+            SystemState::<P>::validate_param(
+                &state.state,
+                main_world.as_unsafe_world_cell_readonly(),
+            )
+        }
+    }
+
+    #[inline]
+    unsafe fn get_param<'w, 's>(
+        state: &'s mut Self::State,
+        system_meta: &SystemMeta,
+        world: UnsafeWorldCell<'w>,
+        change_tick: Tick,
+    ) -> Self::Item<'w, 's> {
+        // SAFETY:
+        // - The caller ensures that `world` is the same one that `init_state` was called with.
+        // - The caller ensures that no other `SystemParam`s will conflict with the accesses we have registered.
+        let main_world = unsafe {
+            Res::<MainWorld>::get_param(
+                &mut state.main_world_state,
+                system_meta,
+                world,
+                change_tick,
+            )
+        };
+        let item = state.state.get(main_world.into_inner());
+        Extract { item }
+    }
+}
+
+impl<'w, 's, P> Deref for Extract<'w, 's, P>
+where
+    P: ReadOnlySystemParam,
+{
+    type Target = SystemParamItem<'w, 's, P>;
+
+    #[inline]
+    fn deref(&self) -> &Self::Target {
+        &self.item
+    }
+}
+
+impl<'w, 's, P> DerefMut for Extract<'w, 's, P>
+where
+    P: ReadOnlySystemParam,
+{
+    #[inline]
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.item
+    }
+}
+
+impl<'a, 'w, 's, P> IntoIterator for &'a Extract<'w, 's, P>
+where
+    P: ReadOnlySystemParam,
+    &'a SystemParamItem<'w, 's, P>: IntoIterator,
+{
+    type Item = <&'a SystemParamItem<'w, 's, P> as IntoIterator>::Item;
+    type IntoIter = <&'a SystemParamItem<'w, 's, P> as IntoIterator>::IntoIter;
+
+    fn into_iter(self) -> Self::IntoIter {
+        (&self.item).into_iter()
+    }
+}

vendor/bevy_render/src/extract_resource.rs

@@ -0,0 +1,70 @@
+use core::marker::PhantomData;
+
+use bevy_app::{App, Plugin};
+use bevy_ecs::prelude::*;
+pub use bevy_render_macros::ExtractResource;
+use bevy_utils::once;
+
+use crate::{Extract, ExtractSchedule, RenderApp};
+
+/// Describes how a resource gets extracted for rendering.
+///
+/// Therefore the resource is transferred from the "main world" into the "render world"
+/// in the [`ExtractSchedule`] step.
+pub trait ExtractResource: Resource {
+    type Source: Resource;
+
+    /// Defines how the resource is transferred into the "render world".
+    fn extract_resource(source: &Self::Source) -> Self;
+}
+
+/// This plugin extracts the resources into the "render world".
+///
+/// Therefore it sets up the[`ExtractSchedule`] step
+/// for the specified [`Resource`].
+pub struct ExtractResourcePlugin<R: ExtractResource>(PhantomData<R>);
+
+impl<R: ExtractResource> Default for ExtractResourcePlugin<R> {
+    fn default() -> Self {
+        Self(PhantomData)
+    }
+}
+
+impl<R: ExtractResource> Plugin for ExtractResourcePlugin<R> {
+    fn build(&self, app: &mut App) {
+        if let Some(render_app) = app.get_sub_app_mut(RenderApp) {
+            render_app.add_systems(ExtractSchedule, extract_resource::<R>);
+        } else {
+            once!(tracing::error!(
+                "Render app did not exist when trying to add `extract_resource` for <{}>.",
+                core::any::type_name::<R>()
+            ));
+        }
+    }
+}
+
+/// This system extracts the resource of the corresponding [`Resource`] type
+pub fn extract_resource<R: ExtractResource>(
+    mut commands: Commands,
+    main_resource: Extract<Option<Res<R::Source>>>,
+    target_resource: Option<ResMut<R>>,
+) {
+    if let Some(main_resource) = main_resource.as_ref() {
+        if let Some(mut target_resource) = target_resource {
+            if main_resource.is_changed() {
+                *target_resource = R::extract_resource(main_resource);
+            }
+        } else {
+            #[cfg(debug_assertions)]
+            if !main_resource.is_added() {
+                once!(tracing::warn!(
+                    "Removing resource {} from render world not expected, adding using `Commands`.
+                This may decrease performance",
+                    core::any::type_name::<R>()
+                ));
+            }
+
+            commands.insert_resource(R::extract_resource(main_resource));
+        }
+    }
+}

vendor/bevy_render/src/globals.rs

@@ -0,0 +1,85 @@
+use crate::{
+    extract_resource::ExtractResource,
+    prelude::Shader,
+    render_resource::{ShaderType, UniformBuffer},
+    renderer::{RenderDevice, RenderQueue},
+    Extract, ExtractSchedule, Render, RenderApp, RenderSet,
+};
+use bevy_app::{App, Plugin};
+use bevy_asset::{load_internal_asset, weak_handle, Handle};
+use bevy_diagnostic::FrameCount;
+use bevy_ecs::prelude::*;
+use bevy_reflect::prelude::*;
+use bevy_time::Time;
+
+pub const GLOBALS_TYPE_HANDLE: Handle<Shader> =
+    weak_handle!("9e22a765-30ca-4070-9a4c-34ac08f1c0e7");
+
+pub struct GlobalsPlugin;
+
+impl Plugin for GlobalsPlugin {
+    fn build(&self, app: &mut App) {
+        load_internal_asset!(app, GLOBALS_TYPE_HANDLE, "globals.wgsl", Shader::from_wgsl);
+        app.register_type::<GlobalsUniform>();
+
+        if let Some(render_app) = app.get_sub_app_mut(RenderApp) {
+            render_app
+                .init_resource::<GlobalsBuffer>()
+                .init_resource::<Time>()
+                .add_systems(ExtractSchedule, (extract_frame_count, extract_time))
+                .add_systems(
+                    Render,
+                    prepare_globals_buffer.in_set(RenderSet::PrepareResources),
+                );
+        }
+    }
+}
+
+fn extract_frame_count(mut commands: Commands, frame_count: Extract<Res<FrameCount>>) {
+    commands.insert_resource(**frame_count);
+}
+
+fn extract_time(mut commands: Commands, time: Extract<Res<Time>>) {
+    commands.insert_resource(**time);
+}
+
+/// Contains global values useful when writing shaders.
+/// Currently only contains values related to time.
+#[derive(Default, Clone, Resource, ExtractResource, Reflect, ShaderType)]
+#[reflect(Resource, Default, Clone)]
+pub struct GlobalsUniform {
+    /// The time since startup in seconds.
+    /// Wraps to 0 after 1 hour.
+    time: f32,
+    /// The delta time since the previous frame in seconds
+    delta_time: f32,
+    /// Frame count since the start of the app.
+    /// It wraps to zero when it reaches the maximum value of a u32.
+    frame_count: u32,
+    /// WebGL2 structs must be 16 byte aligned.
+    #[cfg(all(feature = "webgl", target_arch = "wasm32", not(feature = "webgpu")))]
+    _wasm_padding: f32,
+}
+
+/// The buffer containing the [`GlobalsUniform`]
+#[derive(Resource, Default)]
+pub struct GlobalsBuffer {
+    pub buffer: UniformBuffer<GlobalsUniform>,
+}
+
+fn prepare_globals_buffer(
+    render_device: Res<RenderDevice>,
+    render_queue: Res<RenderQueue>,
+    mut globals_buffer: ResMut<GlobalsBuffer>,
+    time: Res<Time>,
+    frame_count: Res<FrameCount>,
+) {
+    let buffer = globals_buffer.buffer.get_mut();
+    buffer.time = time.elapsed_secs_wrapped();
+    buffer.delta_time = time.delta_secs();
+    buffer.frame_count = frame_count.0;
+
+    globals_buffer
+        .buffer
+        .write_buffer(&render_device, &render_queue);
+}

vendor/bevy_render/src/globals.wgsl

@@ -0,0 +1,16 @@
+#define_import_path bevy_render::globals
+
+struct Globals {
+    // The time since startup in seconds
+    // Wraps to 0 after 1 hour.
+    time: f32,
+    // The delta time since the previous frame in seconds
+    delta_time: f32,
+    // Frame count since the start of the app.
+    // It wraps to zero when it reaches the maximum value of a u32.
+    frame_count: u32,
+#ifdef SIXTEEN_BYTE_ALIGNMENT
+    // WebGL2 structs must be 16 byte aligned.
+    _webgl2_padding: f32
+#endif
+};

vendor/bevy_render/src/gpu_component_array_buffer.rs

@@ -0,0 +1,59 @@
+use crate::{
+    render_resource::{GpuArrayBuffer, GpuArrayBufferable},
+    renderer::{RenderDevice, RenderQueue},
+    Render, RenderApp, RenderSet,
+};
+use bevy_app::{App, Plugin};
+use bevy_ecs::{
+    prelude::{Component, Entity},
+    schedule::IntoScheduleConfigs,
+    system::{Commands, Query, Res, ResMut},
+};
+use core::marker::PhantomData;
+
+/// This plugin prepares the components of the corresponding type for the GPU
+/// by storing them in a [`GpuArrayBuffer`].
+pub struct GpuComponentArrayBufferPlugin<C: Component + GpuArrayBufferable>(PhantomData<C>);
+
+impl<C: Component + GpuArrayBufferable> Plugin for GpuComponentArrayBufferPlugin<C> {
+    fn build(&self, app: &mut App) {
+        if let Some(render_app) = app.get_sub_app_mut(RenderApp) {
+            render_app.add_systems(
+                Render,
+                prepare_gpu_component_array_buffers::<C>.in_set(RenderSet::PrepareResources),
+            );
+        }
+    }
+
+    fn finish(&self, app: &mut App) {
+        if let Some(render_app) = app.get_sub_app_mut(RenderApp) {
+            render_app.insert_resource(GpuArrayBuffer::<C>::new(
+                render_app.world().resource::<RenderDevice>(),
+            ));
+        }
+    }
+}
+
+impl<C: Component + GpuArrayBufferable> Default for GpuComponentArrayBufferPlugin<C> {
+    fn default() -> Self {
+        Self(PhantomData::<C>)
+    }
+}
+
+fn prepare_gpu_component_array_buffers<C: Component + GpuArrayBufferable>(
+    mut commands: Commands,
+    render_device: Res<RenderDevice>,
+    render_queue: Res<RenderQueue>,
+    mut gpu_array_buffer: ResMut<GpuArrayBuffer<C>>,
+    components: Query<(Entity, &C)>,
+) {
+    gpu_array_buffer.clear();
+
+    let entities = components
+        .iter()
+        .map(|(entity, component)| (entity, gpu_array_buffer.push(component.clone())))
+        .collect::<Vec<_>>();
+    commands.try_insert_batch(entities);
+
+    gpu_array_buffer.write_buffer(&render_device, &render_queue);
+}

vendor/bevy_render/src/gpu_readback.rs

@@ -0,0 +1,383 @@
+use crate::{
+    extract_component::ExtractComponentPlugin,
+    render_asset::RenderAssets,
+    render_resource::{
+        Buffer, BufferUsages, CommandEncoder, Extent3d, TexelCopyBufferLayout, Texture,
+        TextureFormat,
+    },
+    renderer::{render_system, RenderDevice},
+    storage::{GpuShaderStorageBuffer, ShaderStorageBuffer},
+    sync_world::MainEntity,
+    texture::GpuImage,
+    ExtractSchedule, MainWorld, Render, RenderApp, RenderSet,
+};
+use async_channel::{Receiver, Sender};
+use bevy_app::{App, Plugin};
+use bevy_asset::Handle;
+use bevy_derive::{Deref, DerefMut};
+use bevy_ecs::schedule::IntoScheduleConfigs;
+use bevy_ecs::{
+    change_detection::ResMut,
+    entity::Entity,
+    event::Event,
+    prelude::{Component, Resource, World},
+    system::{Query, Res},
+};
+use bevy_image::{Image, TextureFormatPixelInfo};
+use bevy_platform::collections::HashMap;
+use bevy_reflect::Reflect;
+use bevy_render_macros::ExtractComponent;
+use encase::internal::ReadFrom;
+use encase::private::Reader;
+use encase::ShaderType;
+use tracing::warn;
+
+/// A plugin that enables reading back gpu buffers and textures to the cpu.
+pub struct GpuReadbackPlugin {
+    /// Describes the number of frames a buffer can be unused before it is removed from the pool in
+    /// order to avoid unnecessary reallocations.
+    max_unused_frames: usize,
+}
+
+impl Default for GpuReadbackPlugin {
+    fn default() -> Self {
+        Self {
+            max_unused_frames: 10,
+        }
+    }
+}
+
+impl Plugin for GpuReadbackPlugin {
+    fn build(&self, app: &mut App) {
+        app.add_plugins(ExtractComponentPlugin::<Readback>::default());
+
+        if let Some(render_app) = app.get_sub_app_mut(RenderApp) {
+            render_app
+                .init_resource::<GpuReadbackBufferPool>()
+                .init_resource::<GpuReadbacks>()
+                .insert_resource(GpuReadbackMaxUnusedFrames(self.max_unused_frames))
+                .add_systems(ExtractSchedule, sync_readbacks.ambiguous_with_all())
+                .add_systems(
+                    Render,
+                    (
+                        prepare_buffers.in_set(RenderSet::PrepareResources),
+                        map_buffers.after(render_system).in_set(RenderSet::Render),
+                    ),
+                );
+        }
+    }
+}
+
+/// A component that registers the wrapped handle for gpu readback, either a texture or a buffer.
+///
+/// Data is read asynchronously and will be triggered on the entity via the [`ReadbackComplete`] event
+/// when complete. If this component is not removed, the readback will be attempted every frame
+#[derive(Component, ExtractComponent, Clone, Debug)]
+pub enum Readback {
+    Texture(Handle<Image>),
+    Buffer(Handle<ShaderStorageBuffer>),
+}
+
+impl Readback {
+    /// Create a readback component for a texture using the given handle.
+    pub fn texture(image: Handle<Image>) -> Self {
+        Self::Texture(image)
+    }
+
+    /// Create a readback component for a buffer using the given handle.
+    pub fn buffer(buffer: Handle<ShaderStorageBuffer>) -> Self {
+        Self::Buffer(buffer)
+    }
+}
+
+/// An event that is triggered when a gpu readback is complete.
+///
+/// The event contains the data as a `Vec<u8>`, which can be interpreted as the raw bytes of the
+/// requested buffer or texture.
+#[derive(Event, Deref, DerefMut, Reflect, Debug)]
+#[reflect(Debug)]
+pub struct ReadbackComplete(pub Vec<u8>);
+
+impl ReadbackComplete {
+    /// Convert the raw bytes of the event to a shader type.
+    pub fn to_shader_type<T: ShaderType + ReadFrom + Default>(&self) -> T {
+        let mut val = T::default();
+        let mut reader = Reader::new::<T>(&self.0, 0).expect("Failed to create Reader");
+        T::read_from(&mut val, &mut reader);
+        val
+    }
+}
+
+#[derive(Resource)]
+struct GpuReadbackMaxUnusedFrames(usize);
+
+struct GpuReadbackBuffer {
+    buffer: Buffer,
+    taken: bool,
+    frames_unused: usize,
+}
+
+#[derive(Resource, Default)]
+struct GpuReadbackBufferPool {
+    // Map of buffer size to list of buffers, with a flag for whether the buffer is taken and how
+    // many frames it has been unused for.
+    // TODO: We could ideally write all readback data to one big buffer per frame, the assumption
+    // here is that very few entities well actually be read back at once, and their size is
+    // unlikely to change.
+    buffers: HashMap<u64, Vec<GpuReadbackBuffer>>,
+}
+
+impl GpuReadbackBufferPool {
+    fn get(&mut self, render_device: &RenderDevice, size: u64) -> Buffer {
+        let buffers = self.buffers.entry(size).or_default();
+
+        // find an untaken buffer for this size
+        if let Some(buf) = buffers.iter_mut().find(|x| !x.taken) {
+            buf.taken = true;
+            buf.frames_unused = 0;
+            return buf.buffer.clone();
+        }
+
+        let buffer = render_device.create_buffer(&wgpu::BufferDescriptor {
+            label: Some("Readback Buffer"),
+            size,
+            usage: BufferUsages::COPY_DST | BufferUsages::MAP_READ,
+            mapped_at_creation: false,
+        });
+        buffers.push(GpuReadbackBuffer {
+            buffer: buffer.clone(),
+            taken: true,
+            frames_unused: 0,
+        });
+        buffer
+    }
+
+    // Returns the buffer to the pool so it can be used in a future frame
+    fn return_buffer(&mut self, buffer: &Buffer) {
+        let size = buffer.size();
+        let buffers = self
+            .buffers
+            .get_mut(&size)
+            .expect("Returned buffer of untracked size");
+        if let Some(buf) = buffers.iter_mut().find(|x| x.buffer.id() == buffer.id()) {
+            buf.taken = false;
+        } else {
+            warn!("Returned buffer that was not allocated");
+        }
+    }
+
+    fn update(&mut self, max_unused_frames: usize) {
+        for (_, buffers) in &mut self.buffers {
+            // Tick all the buffers
+            for buf in &mut *buffers {
+                if !buf.taken {
+                    buf.frames_unused += 1;
+                }
+            }
+
+            // Remove buffers that haven't been used for MAX_UNUSED_FRAMES
+            buffers.retain(|x| x.frames_unused < max_unused_frames);
+        }
+
+        // Remove empty buffer sizes
+        self.buffers.retain(|_, buffers| !buffers.is_empty());
+    }
+}
+
+enum ReadbackSource {
+    Texture {
+        texture: Texture,
+        layout: TexelCopyBufferLayout,
+        size: Extent3d,
+    },
+    Buffer {
+        src_start: u64,
+        dst_start: u64,
+        buffer: Buffer,
+    },
+}
+
+#[derive(Resource, Default)]
+struct GpuReadbacks {
+    requested: Vec<GpuReadback>,
+    mapped: Vec<GpuReadback>,
+}
+
+struct GpuReadback {
+    pub entity: Entity,
+    pub src: ReadbackSource,
+    pub buffer: Buffer,
+    pub rx: Receiver<(Entity, Buffer, Vec<u8>)>,
+    pub tx: Sender<(Entity, Buffer, Vec<u8>)>,
+}
+
+fn sync_readbacks(
+    mut main_world: ResMut<MainWorld>,
+    mut buffer_pool: ResMut<GpuReadbackBufferPool>,
+    mut readbacks: ResMut<GpuReadbacks>,
+    max_unused_frames: Res<GpuReadbackMaxUnusedFrames>,
+) {
+    readbacks.mapped.retain(|readback| {
+        if let Ok((entity, buffer, result)) = readback.rx.try_recv() {
+            main_world.trigger_targets(ReadbackComplete(result), entity);
+            buffer_pool.return_buffer(&buffer);
+            false
+        } else {
+            true
+        }
+    });
+
+    buffer_pool.update(max_unused_frames.0);
+}
+
+fn prepare_buffers(
+    render_device: Res<RenderDevice>,
+    mut readbacks: ResMut<GpuReadbacks>,
+    mut buffer_pool: ResMut<GpuReadbackBufferPool>,
+    gpu_images: Res<RenderAssets<GpuImage>>,
+    ssbos: Res<RenderAssets<GpuShaderStorageBuffer>>,
+    handles: Query<(&MainEntity, &Readback)>,
+) {
+    for (entity, readback) in handles.iter() {
+        match readback {
+            Readback::Texture(image) => {
+                if let Some(gpu_image) = gpu_images.get(image) {
+                    let layout = layout_data(gpu_image.size, gpu_image.texture_format);
+                    let buffer = buffer_pool.get(
+                        &render_device,
+                        get_aligned_size(
+                            gpu_image.size,
+                            gpu_image.texture_format.pixel_size() as u32,
+                        ) as u64,
+                    );
+                    let (tx, rx) = async_channel::bounded(1);
+                    readbacks.requested.push(GpuReadback {
+                        entity: entity.id(),
+                        src: ReadbackSource::Texture {
+                            texture: gpu_image.texture.clone(),
+                            layout,
+                            size: gpu_image.size,
+                        },
+                        buffer,
+                        rx,
+                        tx,
+                    });
+                }
+            }
+            Readback::Buffer(buffer) => {
+                if let Some(ssbo) = ssbos.get(buffer) {
+                    let size = ssbo.buffer.size();
+                    let buffer = buffer_pool.get(&render_device, size);
+                    let (tx, rx) = async_channel::bounded(1);
+                    readbacks.requested.push(GpuReadback {
+                        entity: entity.id(),
+                        src: ReadbackSource::Buffer {
+                            src_start: 0,
+                            dst_start: 0,
+                            buffer: ssbo.buffer.clone(),
+                        },
+                        buffer,
+                        rx,
+                        tx,
+                    });
+                }
+            }
+        }
+    }
+}
+
+pub(crate) fn submit_readback_commands(world: &World, command_encoder: &mut CommandEncoder) {
+    let readbacks = world.resource::<GpuReadbacks>();
+    for readback in &readbacks.requested {
+        match &readback.src {
+            ReadbackSource::Texture {
+                texture,
+                layout,
+                size,
+            } => {
+                command_encoder.copy_texture_to_buffer(
+                    texture.as_image_copy(),
+                    wgpu::TexelCopyBufferInfo {
+                        buffer: &readback.buffer,
+                        layout: *layout,
+                    },
+                    *size,
+                );
+            }
+            ReadbackSource::Buffer {
+                src_start,
+                dst_start,
+                buffer,
+            } => {
+                command_encoder.copy_buffer_to_buffer(
+                    buffer,
+                    *src_start,
+                    &readback.buffer,
+                    *dst_start,
+                    buffer.size(),
+                );
+            }
+        }
+    }
+}
+
+/// Move requested readbacks to mapped readbacks after commands have been submitted in render system
+fn map_buffers(mut readbacks: ResMut<GpuReadbacks>) {
+    let requested = readbacks.requested.drain(..).collect::<Vec<GpuReadback>>();
+    for readback in requested {
+        let slice = readback.buffer.slice(..);
+        let entity = readback.entity;
+        let buffer = readback.buffer.clone();
+        let tx = readback.tx.clone();
+        slice.map_async(wgpu::MapMode::Read, move |res| {
+            res.expect("Failed to map buffer");
+            let buffer_slice = buffer.slice(..);
+            let data = buffer_slice.get_mapped_range();
+            let result = Vec::from(&*data);
+            drop(data);
+            buffer.unmap();
+            if let Err(e) = tx.try_send((entity, buffer, result)) {
+                warn!("Failed to send readback result: {}", e);
+            }
+        });
+        readbacks.mapped.push(readback);
+    }
+}
+
+// Utils
+
+/// Round up a given value to be a multiple of [`wgpu::COPY_BYTES_PER_ROW_ALIGNMENT`].
+pub(crate) const fn align_byte_size(value: u32) -> u32 {
+    RenderDevice::align_copy_bytes_per_row(value as usize) as u32
+}
+
+/// Get the size of a image when the size of each row has been rounded up to [`wgpu::COPY_BYTES_PER_ROW_ALIGNMENT`].
+pub(crate) const fn get_aligned_size(extent: Extent3d, pixel_size: u32) -> u32 {
+    extent.height * align_byte_size(extent.width * pixel_size) * extent.depth_or_array_layers
+}
+
+/// Get a [`TexelCopyBufferLayout`] aligned such that the image can be copied into a buffer.
+pub(crate) fn layout_data(extent: Extent3d, format: TextureFormat) -> TexelCopyBufferLayout {
+    TexelCopyBufferLayout {
+        bytes_per_row: if extent.height > 1 || extent.depth_or_array_layers > 1 {
+            // 1 = 1 row
+            Some(get_aligned_size(
+                Extent3d {
+                    width: extent.width,
+                    height: 1,
+                    depth_or_array_layers: 1,
+                },
+                format.pixel_size() as u32,
+            ))
+        } else {
+            None
+        },
+        rows_per_image: if extent.depth_or_array_layers > 1 {
+            let (_, block_dimension_y) = format.block_dimensions();
+            Some(extent.height / block_dimension_y)
+        } else {
+            None
+        },
+        offset: 0,
+    }
+}

vendor/bevy_render/src/lib.rs

@@ -0,0 +1,611 @@
+#![expect(missing_docs, reason = "Not all docs are written yet, see #3492.")]
+#![expect(unsafe_code, reason = "Unsafe code is used to improve performance.")]
+#![cfg_attr(
+    any(docsrs, docsrs_dep),
+    expect(
+        internal_features,
+        reason = "rustdoc_internals is needed for fake_variadic"
+    )
+)]
+#![cfg_attr(any(docsrs, docsrs_dep), feature(doc_auto_cfg, rustdoc_internals))]
+#![doc(
+    html_logo_url = "https://bevyengine.org/assets/icon.png",
+    html_favicon_url = "https://bevyengine.org/assets/icon.png"
+)]
+
+#[cfg(target_pointer_width = "16")]
+compile_error!("bevy_render cannot compile for a 16-bit platform.");
+
+extern crate alloc;
+extern crate core;
+
+// Required to make proc macros work in bevy itself.
+extern crate self as bevy_render;
+
+pub mod alpha;
+pub mod batching;
+pub mod camera;
+pub mod diagnostic;
+pub mod experimental;
+pub mod extract_component;
+pub mod extract_instances;
+mod extract_param;
+pub mod extract_resource;
+pub mod globals;
+pub mod gpu_component_array_buffer;
+pub mod gpu_readback;
+pub mod mesh;
+#[cfg(not(target_arch = "wasm32"))]
+pub mod pipelined_rendering;
+pub mod primitives;
+pub mod render_asset;
+pub mod render_graph;
+pub mod render_phase;
+pub mod render_resource;
+pub mod renderer;
+pub mod settings;
+pub mod storage;
+pub mod sync_component;
+pub mod sync_world;
+pub mod texture;
+pub mod view;
+
+/// The render prelude.
+///
+/// This includes the most common types in this crate, re-exported for your convenience.
+pub mod prelude {
+    #[doc(hidden)]
+    pub use crate::{
+        alpha::AlphaMode,
+        camera::{
+            Camera, ClearColor, ClearColorConfig, OrthographicProjection, PerspectiveProjection,
+            Projection,
+        },
+        mesh::{
+            morph::MorphWeights, primitives::MeshBuilder, primitives::Meshable, Mesh, Mesh2d,
+            Mesh3d,
+        },
+        render_resource::Shader,
+        texture::ImagePlugin,
+        view::{InheritedVisibility, Msaa, ViewVisibility, Visibility},
+        ExtractSchedule,
+    };
+}
+use batching::gpu_preprocessing::BatchingPlugin;
+use bevy_ecs::schedule::ScheduleBuildSettings;
+use bevy_utils::prelude::default;
+pub use extract_param::Extract;
+
+use bevy_window::{PrimaryWindow, RawHandleWrapperHolder};
+use experimental::occlusion_culling::OcclusionCullingPlugin;
+use globals::GlobalsPlugin;
+use render_asset::{
+    extract_render_asset_bytes_per_frame, reset_render_asset_bytes_per_frame,
+    RenderAssetBytesPerFrame, RenderAssetBytesPerFrameLimiter,
+};
+use renderer::{RenderAdapter, RenderDevice, RenderQueue};
+use settings::RenderResources;
+use sync_world::{
+    despawn_temporary_render_entities, entity_sync_system, SyncToRenderWorld, SyncWorldPlugin,
+};
+
+use crate::gpu_readback::GpuReadbackPlugin;
+use crate::{
+    camera::CameraPlugin,
+    mesh::{MeshPlugin, MorphPlugin, RenderMesh},
+    render_asset::prepare_assets,
+    render_resource::{PipelineCache, Shader, ShaderLoader},
+    renderer::{render_system, RenderInstance, WgpuWrapper},
+    settings::RenderCreation,
+    storage::StoragePlugin,
+    view::{ViewPlugin, WindowRenderPlugin},
+};
+use alloc::sync::Arc;
+use bevy_app::{App, AppLabel, Plugin, SubApp};
+use bevy_asset::{load_internal_asset, weak_handle, AssetApp, AssetServer, Handle};
+use bevy_ecs::{prelude::*, schedule::ScheduleLabel};
+use bitflags::bitflags;
+use core::ops::{Deref, DerefMut};
+use std::sync::Mutex;
+use tracing::debug;
+
+/// Contains the default Bevy rendering backend based on wgpu.
+///
+/// Rendering is done in a [`SubApp`], which exchanges data with the main app
+/// between main schedule iterations.
+///
+/// Rendering can be executed between iterations of the main schedule,
+/// or it can be executed in parallel with main schedule when
+/// [`PipelinedRenderingPlugin`](pipelined_rendering::PipelinedRenderingPlugin) is enabled.
+#[derive(Default)]
+pub struct RenderPlugin {
+    pub render_creation: RenderCreation,
+    /// If `true`, disables asynchronous pipeline compilation.
+    /// This has no effect on macOS, Wasm, iOS, or without the `multi_threaded` feature.
+    pub synchronous_pipeline_compilation: bool,
+    /// Debugging flags that can optionally be set when constructing the renderer.
+    pub debug_flags: RenderDebugFlags,
+}
+
+bitflags! {
+    /// Debugging flags that can optionally be set when constructing the renderer.
+    #[derive(Clone, Copy, PartialEq, Default, Debug)]
+    pub struct RenderDebugFlags: u8 {
+        /// If true, this sets the `COPY_SRC` flag on indirect draw parameters
+        /// so that they can be read back to CPU.
+        ///
+        /// This is a debugging feature that may reduce performance. It
+        /// primarily exists for the `occlusion_culling` example.
+        const ALLOW_COPIES_FROM_INDIRECT_PARAMETERS = 1;
+    }
+}
+
+/// The systems sets of the default [`App`] rendering schedule.
+///
+/// These can be useful for ordering, but you almost never want to add your systems to these sets.
+#[derive(Debug, Hash, PartialEq, Eq, Clone, SystemSet)]
+pub enum RenderSet {
+    /// This is used for applying the commands from the [`ExtractSchedule`]
+    ExtractCommands,
+    /// Prepare assets that have been created/modified/removed this frame.
+    PrepareAssets,
+    /// Prepares extracted meshes.
+    PrepareMeshes,
+    /// Create any additional views such as those used for shadow mapping.
+    ManageViews,
+    /// Queue drawable entities as phase items in render phases ready for
+    /// sorting (if necessary)
+    Queue,
+    /// A sub-set within [`Queue`](RenderSet::Queue) where mesh entity queue systems are executed. Ensures `prepare_assets::<RenderMesh>` is completed.
+    QueueMeshes,
+    /// A sub-set within [`Queue`](RenderSet::Queue) where meshes that have
+    /// become invisible or changed phases are removed from the bins.
+    QueueSweep,
+    // TODO: This could probably be moved in favor of a system ordering
+    // abstraction in `Render` or `Queue`
+    /// Sort the [`SortedRenderPhase`](render_phase::SortedRenderPhase)s and
+    /// [`BinKey`](render_phase::BinnedPhaseItem::BinKey)s here.
+    PhaseSort,
+    /// Prepare render resources from extracted data for the GPU based on their sorted order.
+    /// Create [`BindGroups`](render_resource::BindGroup) that depend on those data.
+    Prepare,
+    /// A sub-set within [`Prepare`](RenderSet::Prepare) for initializing buffers, textures and uniforms for use in bind groups.
+    PrepareResources,
+    /// Collect phase buffers after
+    /// [`PrepareResources`](RenderSet::PrepareResources) has run.
+    PrepareResourcesCollectPhaseBuffers,
+    /// Flush buffers after [`PrepareResources`](RenderSet::PrepareResources), but before [`PrepareBindGroups`](RenderSet::PrepareBindGroups).
+    PrepareResourcesFlush,
+    /// A sub-set within [`Prepare`](RenderSet::Prepare) for constructing bind groups, or other data that relies on render resources prepared in [`PrepareResources`](RenderSet::PrepareResources).
+    PrepareBindGroups,
+    /// Actual rendering happens here.
+    /// In most cases, only the render backend should insert resources here.
+    Render,
+    /// Cleanup render resources here.
+    Cleanup,
+    /// Final cleanup occurs: all entities will be despawned.
+    ///
+    /// Runs after [`Cleanup`](RenderSet::Cleanup).
+    PostCleanup,
+}
+
+/// The main render schedule.
+#[derive(ScheduleLabel, Debug, Hash, PartialEq, Eq, Clone, Default)]
+pub struct Render;
+
+impl Render {
+    /// Sets up the base structure of the rendering [`Schedule`].
+    ///
+    /// The sets defined in this enum are configured to run in order.
+    pub fn base_schedule() -> Schedule {
+        use RenderSet::*;
+
+        let mut schedule = Schedule::new(Self);
+
+        schedule.configure_sets(
+            (
+                ExtractCommands,
+                PrepareMeshes,
+                ManageViews,
+                Queue,
+                PhaseSort,
+                Prepare,
+                Render,
+                Cleanup,
+                PostCleanup,
+            )
+                .chain(),
+        );
+
+        schedule.configure_sets((ExtractCommands, PrepareAssets, PrepareMeshes, Prepare).chain());
+        schedule.configure_sets(
+            (QueueMeshes, QueueSweep)
+                .chain()
+                .in_set(Queue)
+                .after(prepare_assets::<RenderMesh>),
+        );
+        schedule.configure_sets(
+            (
+                PrepareResources,
+                PrepareResourcesCollectPhaseBuffers,
+                PrepareResourcesFlush,
+                PrepareBindGroups,
+            )
+                .chain()
+                .in_set(Prepare),
+        );
+
+        schedule
+    }
+}
+
+/// Schedule which extract data from the main world and inserts it into the render world.
+///
+/// This step should be kept as short as possible to increase the "pipelining potential" for
+/// running the next frame while rendering the current frame.
+///
+/// This schedule is run on the main world, but its buffers are not applied
+/// until it is returned to the render world.
+#[derive(ScheduleLabel, PartialEq, Eq, Debug, Clone, Hash, Default)]
+pub struct ExtractSchedule;
+
+/// The simulation [`World`] of the application, stored as a resource.
+///
+/// This resource is only available during [`ExtractSchedule`] and not
+/// during command application of that schedule.
+/// See [`Extract`] for more details.
+#[derive(Resource, Default)]
+pub struct MainWorld(World);
+
+impl Deref for MainWorld {
+    type Target = World;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl DerefMut for MainWorld {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.0
+    }
+}
+
+pub mod graph {
+    use crate::render_graph::RenderLabel;
+
+    #[derive(Debug, Hash, PartialEq, Eq, Clone, RenderLabel)]
+    pub struct CameraDriverLabel;
+}
+
+#[derive(Resource)]
+struct FutureRenderResources(Arc<Mutex<Option<RenderResources>>>);
+
+/// A label for the rendering sub-app.
+#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, AppLabel)]
+pub struct RenderApp;
+
+pub const INSTANCE_INDEX_SHADER_HANDLE: Handle<Shader> =
+    weak_handle!("475c76aa-4afd-4a6b-9878-1fc1e2f41216");
+pub const MATHS_SHADER_HANDLE: Handle<Shader> =
+    weak_handle!("d94d70d4-746d-49c4-bfc3-27d63f2acda0");
+pub const COLOR_OPERATIONS_SHADER_HANDLE: Handle<Shader> =
+    weak_handle!("33a80b2f-aaf7-4c86-b828-e7ae83b72f1a");
+pub const BINDLESS_SHADER_HANDLE: Handle<Shader> =
+    weak_handle!("13f1baaa-41bf-448e-929e-258f9307a522");
+
+impl Plugin for RenderPlugin {
+    /// Initializes the renderer, sets up the [`RenderSet`] and creates the rendering sub-app.
+    fn build(&self, app: &mut App) {
+        app.init_asset::<Shader>()
+            .init_asset_loader::<ShaderLoader>();
+
+        match &self.render_creation {
+            RenderCreation::Manual(resources) => {
+                let future_render_resources_wrapper = Arc::new(Mutex::new(Some(resources.clone())));
+                app.insert_resource(FutureRenderResources(
+                    future_render_resources_wrapper.clone(),
+                ));
+                // SAFETY: Plugins should be set up on the main thread.
+                unsafe { initialize_render_app(app) };
+            }
+            RenderCreation::Automatic(render_creation) => {
+                if let Some(backends) = render_creation.backends {
+                    let future_render_resources_wrapper = Arc::new(Mutex::new(None));
+                    app.insert_resource(FutureRenderResources(
+                        future_render_resources_wrapper.clone(),
+                    ));
+
+                    let primary_window = app
+                        .world_mut()
+                        .query_filtered::<&RawHandleWrapperHolder, With<PrimaryWindow>>()
+                        .single(app.world())
+                        .ok()
+                        .cloned();
+                    let settings = render_creation.clone();
+                    let async_renderer = async move {
+                        let instance = wgpu::Instance::new(&wgpu::InstanceDescriptor {
+                            backends,
+                            flags: settings.instance_flags,
+                            backend_options: wgpu::BackendOptions {
+                                gl: wgpu::GlBackendOptions {
+                                    gles_minor_version: settings.gles3_minor_version,
+                                },
+                                dx12: wgpu::Dx12BackendOptions {
+                                    shader_compiler: settings.dx12_shader_compiler.clone(),
+                                },
+                            },
+                        });
+
+                        let surface = primary_window.and_then(|wrapper| {
+                            let maybe_handle = wrapper.0.lock().expect(
+                                "Couldn't get the window handle in time for renderer initialization",
+                            );
+                            if let Some(wrapper) = maybe_handle.as_ref() {
+                                // SAFETY: Plugins should be set up on the main thread.
+                                let handle = unsafe { wrapper.get_handle() };
+                                Some(
+                                    instance
+                                        .create_surface(handle)
+                                        .expect("Failed to create wgpu surface"),
+                                )
+                            } else {
+                                None
+                            }
+                        });
+
+                        let request_adapter_options = wgpu::RequestAdapterOptions {
+                            power_preference: settings.power_preference,
+                            compatible_surface: surface.as_ref(),
+                            ..Default::default()
+                        };
+
+                        let (device, queue, adapter_info, render_adapter) =
+                            renderer::initialize_renderer(
+                                &instance,
+                                &settings,
+                                &request_adapter_options,
+                            )
+                            .await;
+                        debug!("Configured wgpu adapter Limits: {:#?}", device.limits());
+                        debug!("Configured wgpu adapter Features: {:#?}", device.features());
+                        let mut future_render_resources_inner =
+                            future_render_resources_wrapper.lock().unwrap();
+                        *future_render_resources_inner = Some(RenderResources(
+                            device,
+                            queue,
+                            adapter_info,
+                            render_adapter,
+                            RenderInstance(Arc::new(WgpuWrapper::new(instance))),
+                        ));
+                    };
+                    // In wasm, spawn a task and detach it for execution
+                    #[cfg(target_arch = "wasm32")]
+                    bevy_tasks::IoTaskPool::get()
+                        .spawn_local(async_renderer)
+                        .detach();
+                    // Otherwise, just block for it to complete
+                    #[cfg(not(target_arch = "wasm32"))]
+                    futures_lite::future::block_on(async_renderer);
+
+                    // SAFETY: Plugins should be set up on the main thread.
+                    unsafe { initialize_render_app(app) };
+                }
+            }
+        };
+
+        app.add_plugins((
+            WindowRenderPlugin,
+            CameraPlugin,
+            ViewPlugin,
+            MeshPlugin,
+            GlobalsPlugin,
+            MorphPlugin,
+            BatchingPlugin {
+                debug_flags: self.debug_flags,
+            },
+            SyncWorldPlugin,
+            StoragePlugin,
+            GpuReadbackPlugin::default(),
+            OcclusionCullingPlugin,
+            #[cfg(feature = "tracing-tracy")]
+            diagnostic::RenderDiagnosticsPlugin,
+        ));
+
+        app.init_resource::<RenderAssetBytesPerFrame>();
+        if let Some(render_app) = app.get_sub_app_mut(RenderApp) {
+            render_app.init_resource::<RenderAssetBytesPerFrameLimiter>();
+            render_app
+                .add_systems(ExtractSchedule, extract_render_asset_bytes_per_frame)
+                .add_systems(
+                    Render,
+                    reset_render_asset_bytes_per_frame.in_set(RenderSet::Cleanup),
+                );
+        }
+
+        app.register_type::<alpha::AlphaMode>()
+            // These types cannot be registered in bevy_color, as it does not depend on the rest of Bevy
+            .register_type::<bevy_color::Color>()
+            .register_type::<primitives::Aabb>()
+            .register_type::<primitives::CascadesFrusta>()
+            .register_type::<primitives::CubemapFrusta>()
+            .register_type::<primitives::Frustum>()
+            .register_type::<SyncToRenderWorld>();
+    }
+
+    fn ready(&self, app: &App) -> bool {
+        app.world()
+            .get_resource::<FutureRenderResources>()
+            .and_then(|frr| frr.0.try_lock().map(|locked| locked.is_some()).ok())
+            .unwrap_or(true)
+    }
+
+    fn finish(&self, app: &mut App) {
+        load_internal_asset!(app, MATHS_SHADER_HANDLE, "maths.wgsl", Shader::from_wgsl);
+        load_internal_asset!(
+            app,
+            COLOR_OPERATIONS_SHADER_HANDLE,
+            "color_operations.wgsl",
+            Shader::from_wgsl
+        );
+        load_internal_asset!(
+            app,
+            BINDLESS_SHADER_HANDLE,
+            "bindless.wgsl",
+            Shader::from_wgsl
+        );
+        if let Some(future_render_resources) =
+            app.world_mut().remove_resource::<FutureRenderResources>()
+        {
+            let RenderResources(device, queue, adapter_info, render_adapter, instance) =
+                future_render_resources.0.lock().unwrap().take().unwrap();
+
+            app.insert_resource(device.clone())
+                .insert_resource(queue.clone())
+                .insert_resource(adapter_info.clone())
+                .insert_resource(render_adapter.clone());
+
+            let render_app = app.sub_app_mut(RenderApp);
+
+            render_app
+                .insert_resource(instance)
+                .insert_resource(PipelineCache::new(
+                    device.clone(),
+                    render_adapter.clone(),
+                    self.synchronous_pipeline_compilation,
+                ))
+                .insert_resource(device)
+                .insert_resource(queue)
+                .insert_resource(render_adapter)
+                .insert_resource(adapter_info);
+        }
+    }
+}
+
+/// A "scratch" world used to avoid allocating new worlds every frame when
+/// swapping out the [`MainWorld`] for [`ExtractSchedule`].
+#[derive(Resource, Default)]
+struct ScratchMainWorld(World);
+
+/// Executes the [`ExtractSchedule`] step of the renderer.
+/// This updates the render world with the extracted ECS data of the current frame.
+fn extract(main_world: &mut World, render_world: &mut World) {
+    // temporarily add the app world to the render world as a resource
+    let scratch_world = main_world.remove_resource::<ScratchMainWorld>().unwrap();
+    let inserted_world = core::mem::replace(main_world, scratch_world.0);
+    render_world.insert_resource(MainWorld(inserted_world));
+    render_world.run_schedule(ExtractSchedule);
+
+    // move the app world back, as if nothing happened.
+    let inserted_world = render_world.remove_resource::<MainWorld>().unwrap();
+    let scratch_world = core::mem::replace(main_world, inserted_world.0);
+    main_world.insert_resource(ScratchMainWorld(scratch_world));
+}
+
+/// # Safety
+/// This function must be called from the main thread.
+unsafe fn initialize_render_app(app: &mut App) {
+    app.init_resource::<ScratchMainWorld>();
+
+    let mut render_app = SubApp::new();
+    render_app.update_schedule = Some(Render.intern());
+
+    let mut extract_schedule = Schedule::new(ExtractSchedule);
+    // We skip applying any commands during the ExtractSchedule
+    // so commands can be applied on the render thread.
+    extract_schedule.set_build_settings(ScheduleBuildSettings {
+        auto_insert_apply_deferred: false,
+        ..default()
+    });
+    extract_schedule.set_apply_final_deferred(false);
+
+    render_app
+        .add_schedule(extract_schedule)
+        .add_schedule(Render::base_schedule())
+        .init_resource::<render_graph::RenderGraph>()
+        .insert_resource(app.world().resource::<AssetServer>().clone())
+        .add_systems(ExtractSchedule, PipelineCache::extract_shaders)
+        .add_systems(
+            Render,
+            (
+                // This set applies the commands from the extract schedule while the render schedule
+                // is running in parallel with the main app.
+                apply_extract_commands.in_set(RenderSet::ExtractCommands),
+                (PipelineCache::process_pipeline_queue_system, render_system)
+                    .chain()
+                    .in_set(RenderSet::Render),
+                despawn_temporary_render_entities.in_set(RenderSet::PostCleanup),
+            ),
+        );
+
+    render_app.set_extract(|main_world, render_world| {
+        {
+            #[cfg(feature = "trace")]
+            let _stage_span = tracing::info_span!("entity_sync").entered();
+            entity_sync_system(main_world, render_world);
+        }
+
+        // run extract schedule
+        extract(main_world, render_world);
+    });
+
+    let (sender, receiver) = bevy_time::create_time_channels();
+    render_app.insert_resource(sender);
+    app.insert_resource(receiver);
+    app.insert_sub_app(RenderApp, render_app);
+}
+
+/// Applies the commands from the extract schedule. This happens during
+/// the render schedule rather than during extraction to allow the commands to run in parallel with the
+/// main app when pipelined rendering is enabled.
+fn apply_extract_commands(render_world: &mut World) {
+    render_world.resource_scope(|render_world, mut schedules: Mut<Schedules>| {
+        schedules
+            .get_mut(ExtractSchedule)
+            .unwrap()
+            .apply_deferred(render_world);
+    });
+}
+
+/// If the [`RenderAdapter`] is a Qualcomm Adreno, returns its model number.
+///
+/// This lets us work around hardware bugs.
+pub fn get_adreno_model(adapter: &RenderAdapter) -> Option<u32> {
+    if !cfg!(target_os = "android") {
+        return None;
+    }
+
+    let adapter_name = adapter.get_info().name;
+    let adreno_model = adapter_name.strip_prefix("Adreno (TM) ")?;
+
+    // Take suffixes into account (like Adreno 642L).
+    Some(
+        adreno_model
+            .chars()
+            .map_while(|c| c.to_digit(10))
+            .fold(0, |acc, digit| acc * 10 + digit),
+    )
+}
+
+/// Get the Mali driver version if the adapter is a Mali GPU.
+pub fn get_mali_driver_version(adapter: &RenderAdapter) -> Option<u32> {
+    if !cfg!(target_os = "android") {
+        return None;
+    }
+
+    let driver_name = adapter.get_info().name;
+    if !driver_name.contains("Mali") {
+        return None;
+    }
+    let driver_info = adapter.get_info().driver_info;
+    if let Some(start_pos) = driver_info.find("v1.r") {
+        if let Some(end_pos) = driver_info[start_pos..].find('p') {
+            let start_idx = start_pos + 4; // Skip "v1.r"
+            let end_idx = start_pos + end_pos;
+
+            return driver_info[start_idx..end_idx].parse::<u32>().ok();
+        }
+    }
+
+    None
+}

vendor/bevy_render/src/maths.wgsl

@@ -0,0 +1,156 @@
+#define_import_path bevy_render::maths
+
+const PI: f32 = 3.141592653589793;      // π
+const PI_2: f32 = 6.283185307179586;    // 2π
+const HALF_PI: f32 = 1.57079632679;     // π/2
+const FRAC_PI_3: f32 = 1.0471975512;    // π/3
+const E: f32 = 2.718281828459045;       // exp(1)
+
+fn affine2_to_square(affine: mat3x2<f32>) -> mat3x3<f32> {
+    return mat3x3<f32>(
+        vec3<f32>(affine[0].xy, 0.0),
+        vec3<f32>(affine[1].xy, 0.0),
+        vec3<f32>(affine[2].xy, 1.0),
+    );
+}
+
+fn affine3_to_square(affine: mat3x4<f32>) -> mat4x4<f32> {
+    return transpose(mat4x4<f32>(
+        affine[0],
+        affine[1],
+        affine[2],
+        vec4<f32>(0.0, 0.0, 0.0, 1.0),
+    ));
+}
+
+fn mat2x4_f32_to_mat3x3_unpack(
+    a: mat2x4<f32>,
+    b: f32,
+) -> mat3x3<f32> {
+    return mat3x3<f32>(
+        a[0].xyz,
+        vec3<f32>(a[0].w, a[1].xy),
+        vec3<f32>(a[1].zw, b),
+    );
+}
+
+// Extracts the square portion of an affine matrix: i.e. discards the
+// translation.
+fn affine3_to_mat3x3(affine: mat4x3<f32>) -> mat3x3<f32> {
+    return mat3x3<f32>(affine[0].xyz, affine[1].xyz, affine[2].xyz);
+}
+
+// Returns the inverse of a 3x3 matrix.
+fn inverse_mat3x3(matrix: mat3x3<f32>) -> mat3x3<f32> {
+    let tmp0 = cross(matrix[1], matrix[2]);
+    let tmp1 = cross(matrix[2], matrix[0]);
+    let tmp2 = cross(matrix[0], matrix[1]);
+    let inv_det = 1.0 / dot(matrix[2], tmp2);
+    return transpose(mat3x3<f32>(tmp0 * inv_det, tmp1 * inv_det, tmp2 * inv_det));
+}
+
+// Returns the inverse of an affine matrix.
+//
+// https://en.wikipedia.org/wiki/Affine_transformation#Groups
+fn inverse_affine3(affine: mat4x3<f32>) -> mat4x3<f32> {
+    let matrix3 = affine3_to_mat3x3(affine);
+    let inv_matrix3 = inverse_mat3x3(matrix3);
+    return mat4x3<f32>(inv_matrix3[0], inv_matrix3[1], inv_matrix3[2], -(inv_matrix3 * affine[3]));
+}
+
+// Extracts the upper 3x3 portion of a 4x4 matrix.
+fn mat4x4_to_mat3x3(m: mat4x4<f32>) -> mat3x3<f32> {
+    return mat3x3<f32>(m[0].xyz, m[1].xyz, m[2].xyz);
+}
+
+// Creates an orthonormal basis given a Z vector and an up vector (which becomes
+// Y after orthonormalization).
+//
+// The results are equivalent to the Gram-Schmidt process [1].
+//
+// [1]: https://math.stackexchange.com/a/1849294
+fn orthonormalize(z_unnormalized: vec3<f32>, up: vec3<f32>) -> mat3x3<f32> {
+    let z_basis = normalize(z_unnormalized);
+    let x_basis = normalize(cross(z_basis, up));
+    let y_basis = cross(z_basis, x_basis);
+    return mat3x3(x_basis, y_basis, z_basis);
+}
+
+// Returns true if any part of a sphere is on the positive side of a plane.
+//
+// `sphere_center.w` should be 1.0.
+//
+// This is used for frustum culling.
+fn sphere_intersects_plane_half_space(
+    plane: vec4<f32>,
+    sphere_center: vec4<f32>,
+    sphere_radius: f32
+) -> bool {
+    return dot(plane, sphere_center) + sphere_radius > 0.0;
+}
+
+// pow() but safe for NaNs/negatives
+fn powsafe(color: vec3<f32>, power: f32) -> vec3<f32> {
+    return pow(abs(color), vec3(power)) * sign(color);
+}
+
+// https://en.wikipedia.org/wiki/Vector_projection#Vector_projection_2
+fn project_onto(lhs: vec3<f32>, rhs: vec3<f32>) -> vec3<f32> {
+    let other_len_sq_rcp = 1.0 / dot(rhs, rhs);
+    return rhs * dot(lhs, rhs) * other_len_sq_rcp;
+}
+
+// Below are fast approximations of common irrational and trig functions. These
+// are likely most useful when raymarching, for example, where complete numeric
+// accuracy can be sacrificed for greater sample count.
+
+fn fast_sqrt(x: f32) -> f32 {
+    let n = bitcast<f32>(0x1fbd1df5 + (bitcast<i32>(x) >> 1u));
+    // One Newton's method iteration for better precision
+    return 0.5 * (n + x / n);
+}
+
+// Slightly less accurate than fast_acos_4, but much simpler.
+fn fast_acos(in_x: f32) -> f32 {
+    let x = abs(in_x);
+    var res = -0.156583 * x + HALF_PI;
+    res *= fast_sqrt(1.0 - x);
+    return select(PI - res, res, in_x >= 0.0);
+}
+
+// 4th order polynomial approximation
+// 4 VGRP, 16 ALU Full Rate
+// 7 * 10^-5 radians precision
+// Reference : Handbook of Mathematical Functions (chapter : Elementary Transcendental Functions), M. Abramowitz and I.A. Stegun, Ed.
+fn fast_acos_4(x: f32) -> f32 {
+    let x1 = abs(x);
+    let x2 = x1 * x1;
+    let x3 = x2 * x1;
+    var s: f32;
+
+    s = -0.2121144 * x1 + 1.5707288;
+    s = 0.0742610 * x2 + s;
+    s = -0.0187293 * x3 + s;
+    s = fast_sqrt(1.0 - x1) * s;
+
+	// acos function mirroring
+    return select(PI - s, s, x >= 0.0);
+}
+
+fn fast_atan2(y: f32, x: f32) -> f32 {
+    var t0 = max(abs(x), abs(y));
+    var t1 = min(abs(x), abs(y));
+    var t3 = t1 / t0;
+    var t4 = t3 * t3;
+
+    t0 = 0.0872929;
+    t0 = t0 * t4 - 0.301895;
+    t0 = t0 * t4 + 1.0;
+    t3 = t0 * t3;
+
+    t3 = select(t3, (0.5 * PI) - t3, abs(y) > abs(x));
+    t3 = select(t3, PI - t3, x < 0);
+    t3 = select(-t3, t3, y > 0);
+
+    return t3;
+}

vendor/bevy_render/src/mesh/components.rs

@@ -0,0 +1,157 @@
+use crate::{
+    mesh::Mesh,
+    view::{self, Visibility, VisibilityClass},
+};
+use bevy_asset::{AsAssetId, AssetEvent, AssetId, Handle};
+use bevy_derive::{Deref, DerefMut};
+use bevy_ecs::{
+    change_detection::DetectChangesMut, component::Component, event::EventReader,
+    reflect::ReflectComponent, system::Query,
+};
+use bevy_platform::{collections::HashSet, hash::FixedHasher};
+use bevy_reflect::{std_traits::ReflectDefault, Reflect};
+use bevy_transform::components::Transform;
+use derive_more::derive::From;
+
+/// A component for 2D meshes. Requires a [`MeshMaterial2d`] to be rendered, commonly using a [`ColorMaterial`].
+///
+/// [`MeshMaterial2d`]: <https://docs.rs/bevy/latest/bevy/sprite/struct.MeshMaterial2d.html>
+/// [`ColorMaterial`]: <https://docs.rs/bevy/latest/bevy/sprite/struct.ColorMaterial.html>
+///
+/// # Example
+///
+/// ```ignore
+/// # use bevy_sprite::{ColorMaterial, Mesh2d, MeshMaterial2d};
+/// # use bevy_ecs::prelude::*;
+/// # use bevy_render::mesh::Mesh;
+/// # use bevy_color::palettes::basic::RED;
+/// # use bevy_asset::Assets;
+/// # use bevy_math::primitives::Circle;
+/// #
+/// // Spawn an entity with a mesh using `ColorMaterial`.
+/// fn setup(
+///     mut commands: Commands,
+///     mut meshes: ResMut<Assets<Mesh>>,
+///     mut materials: ResMut<Assets<ColorMaterial>>,
+/// ) {
+///     commands.spawn((
+///         Mesh2d(meshes.add(Circle::new(50.0))),
+///         MeshMaterial2d(materials.add(ColorMaterial::from_color(RED))),
+///     ));
+/// }
+/// ```
+#[derive(Component, Clone, Debug, Default, Deref, DerefMut, Reflect, PartialEq, Eq, From)]
+#[reflect(Component, Default, Clone, PartialEq)]
+#[require(Transform, Visibility, VisibilityClass)]
+#[component(on_add = view::add_visibility_class::<Mesh2d>)]
+pub struct Mesh2d(pub Handle<Mesh>);
+
+impl From<Mesh2d> for AssetId<Mesh> {
+    fn from(mesh: Mesh2d) -> Self {
+        mesh.id()
+    }
+}
+
+impl From<&Mesh2d> for AssetId<Mesh> {
+    fn from(mesh: &Mesh2d) -> Self {
+        mesh.id()
+    }
+}
+
+impl AsAssetId for Mesh2d {
+    type Asset = Mesh;
+
+    fn as_asset_id(&self) -> AssetId<Self::Asset> {
+        self.id()
+    }
+}
+
+/// A component for 3D meshes. Requires a [`MeshMaterial3d`] to be rendered, commonly using a [`StandardMaterial`].
+///
+/// [`MeshMaterial3d`]: <https://docs.rs/bevy/latest/bevy/pbr/struct.MeshMaterial3d.html>
+/// [`StandardMaterial`]: <https://docs.rs/bevy/latest/bevy/pbr/struct.StandardMaterial.html>
+///
+/// # Example
+///
+/// ```ignore
+/// # use bevy_pbr::{Material, MeshMaterial3d, StandardMaterial};
+/// # use bevy_ecs::prelude::*;
+/// # use bevy_render::mesh::{Mesh, Mesh3d};
+/// # use bevy_color::palettes::basic::RED;
+/// # use bevy_asset::Assets;
+/// # use bevy_math::primitives::Capsule3d;
+/// #
+/// // Spawn an entity with a mesh using `StandardMaterial`.
+/// fn setup(
+///     mut commands: Commands,
+///     mut meshes: ResMut<Assets<Mesh>>,
+///     mut materials: ResMut<Assets<StandardMaterial>>,
+/// ) {
+///     commands.spawn((
+///         Mesh3d(meshes.add(Capsule3d::default())),
+///         MeshMaterial3d(materials.add(StandardMaterial {
+///             base_color: RED.into(),
+///             ..Default::default()
+///         })),
+///     ));
+/// }
+/// ```
+#[derive(Component, Clone, Debug, Default, Deref, DerefMut, Reflect, PartialEq, Eq, From)]
+#[reflect(Component, Default, Clone, PartialEq)]
+#[require(Transform, Visibility, VisibilityClass)]
+#[component(on_add = view::add_visibility_class::<Mesh3d>)]
+pub struct Mesh3d(pub Handle<Mesh>);
+
+impl From<Mesh3d> for AssetId<Mesh> {
+    fn from(mesh: Mesh3d) -> Self {
+        mesh.id()
+    }
+}
+
+impl From<&Mesh3d> for AssetId<Mesh> {
+    fn from(mesh: &Mesh3d) -> Self {
+        mesh.id()
+    }
+}
+
+impl AsAssetId for Mesh3d {
+    type Asset = Mesh;
+
+    fn as_asset_id(&self) -> AssetId<Self::Asset> {
+        self.id()
+    }
+}
+
+/// A system that marks a [`Mesh3d`] as changed if the associated [`Mesh`] asset
+/// has changed.
+///
+/// This is needed because the systems that extract meshes, such as
+/// `extract_meshes_for_gpu_building`, write some metadata about the mesh (like
+/// the location within each slab) into the GPU structures that they build that
+/// needs to be kept up to date if the contents of the mesh change.
+pub fn mark_3d_meshes_as_changed_if_their_assets_changed(
+    mut meshes_3d: Query<&mut Mesh3d>,
+    mut mesh_asset_events: EventReader<AssetEvent<Mesh>>,
+) {
+    let mut changed_meshes: HashSet<AssetId<Mesh>, FixedHasher> = HashSet::default();
+    for mesh_asset_event in mesh_asset_events.read() {
+        if let AssetEvent::Modified { id } = mesh_asset_event {
+            changed_meshes.insert(*id);
+        }
+    }
+
+    if changed_meshes.is_empty() {
+        return;
+    }
+
+    for mut mesh_3d in &mut meshes_3d {
+        if changed_meshes.contains(&mesh_3d.0.id()) {
+            mesh_3d.set_changed();
+        }
+    }
+}
+
+/// A component that stores an arbitrary index used to identify the mesh instance when rendering.
+#[derive(Component, Clone, Debug, Default, Deref, DerefMut, Reflect, PartialEq, Eq)]
+#[reflect(Component, Default, Clone, PartialEq)]
+pub struct MeshTag(pub u32);

vendor/bevy_render/src/mesh/mod.rs

@@ -0,0 +1,248 @@
+use bevy_math::Vec3;
+pub use bevy_mesh::*;
+use morph::{MeshMorphWeights, MorphWeights};
+pub mod allocator;
+mod components;
+use crate::{
+    primitives::Aabb,
+    render_asset::{PrepareAssetError, RenderAsset, RenderAssetPlugin, RenderAssets},
+    render_resource::TextureView,
+    texture::GpuImage,
+    view::VisibilitySystems,
+    RenderApp,
+};
+use allocator::MeshAllocatorPlugin;
+use bevy_app::{App, Plugin, PostUpdate};
+use bevy_asset::{AssetApp, AssetEvents, AssetId, RenderAssetUsages};
+use bevy_ecs::{
+    prelude::*,
+    system::{
+        lifetimeless::{SRes, SResMut},
+        SystemParamItem,
+    },
+};
+pub use components::{mark_3d_meshes_as_changed_if_their_assets_changed, Mesh2d, Mesh3d, MeshTag};
+use wgpu::IndexFormat;
+
+/// Registers all [`MeshBuilder`] types.
+pub struct MeshBuildersPlugin;
+
+impl Plugin for MeshBuildersPlugin {
+    fn build(&self, app: &mut App) {
+        // 2D Mesh builders
+        app.register_type::<CircleMeshBuilder>()
+            .register_type::<CircularSectorMeshBuilder>()
+            .register_type::<CircularSegmentMeshBuilder>()
+            .register_type::<RegularPolygonMeshBuilder>()
+            .register_type::<EllipseMeshBuilder>()
+            .register_type::<AnnulusMeshBuilder>()
+            .register_type::<RhombusMeshBuilder>()
+            .register_type::<Triangle2dMeshBuilder>()
+            .register_type::<RectangleMeshBuilder>()
+            .register_type::<Capsule2dMeshBuilder>()
+            // 3D Mesh builders
+            .register_type::<Capsule3dMeshBuilder>()
+            .register_type::<ConeMeshBuilder>()
+            .register_type::<ConicalFrustumMeshBuilder>()
+            .register_type::<CuboidMeshBuilder>()
+            .register_type::<CylinderMeshBuilder>()
+            .register_type::<PlaneMeshBuilder>()
+            .register_type::<SphereMeshBuilder>()
+            .register_type::<TetrahedronMeshBuilder>()
+            .register_type::<TorusMeshBuilder>()
+            .register_type::<Triangle3dMeshBuilder>();
+    }
+}
+
+/// Adds the [`Mesh`] as an asset and makes sure that they are extracted and prepared for the GPU.
+pub struct MeshPlugin;
+
+impl Plugin for MeshPlugin {
+    fn build(&self, app: &mut App) {
+        app.init_asset::<Mesh>()
+            .init_asset::<skinning::SkinnedMeshInverseBindposes>()
+            .register_asset_reflect::<Mesh>()
+            .register_type::<Mesh3d>()
+            .register_type::<skinning::SkinnedMesh>()
+            .register_type::<Vec<Entity>>()
+            .add_plugins(MeshBuildersPlugin)
+            // 'Mesh' must be prepared after 'Image' as meshes rely on the morph target image being ready
+            .add_plugins(RenderAssetPlugin::<RenderMesh, GpuImage>::default())
+            .add_plugins(MeshAllocatorPlugin)
+            .add_systems(
+                PostUpdate,
+                mark_3d_meshes_as_changed_if_their_assets_changed
+                    .ambiguous_with(VisibilitySystems::CalculateBounds)
+                    .before(AssetEvents),
+            );
+
+        let Some(render_app) = app.get_sub_app_mut(RenderApp) else {
+            return;
+        };
+
+        render_app.init_resource::<MeshVertexBufferLayouts>();
+    }
+}
+
+/// [Inherit weights](inherit_weights) from glTF mesh parent entity to direct
+/// bevy mesh child entities (ie: glTF primitive).
+pub struct MorphPlugin;
+impl Plugin for MorphPlugin {
+    fn build(&self, app: &mut App) {
+        app.register_type::<MorphWeights>()
+            .register_type::<MeshMorphWeights>()
+            .add_systems(PostUpdate, inherit_weights);
+    }
+}
+
+/// Bevy meshes are gltf primitives, [`MorphWeights`] on the bevy node entity
+/// should be inherited by children meshes.
+///
+/// Only direct children are updated, to fulfill the expectations of glTF spec.
+pub fn inherit_weights(
+    morph_nodes: Query<(&Children, &MorphWeights), (Without<Mesh3d>, Changed<MorphWeights>)>,
+    mut morph_primitives: Query<&mut MeshMorphWeights, With<Mesh3d>>,
+) {
+    for (children, parent_weights) in &morph_nodes {
+        let mut iter = morph_primitives.iter_many_mut(children);
+        while let Some(mut child_weight) = iter.fetch_next() {
+            child_weight.clear_weights();
+            child_weight.extend_weights(parent_weights.weights());
+        }
+    }
+}
+
+pub trait MeshAabb {
+    /// Compute the Axis-Aligned Bounding Box of the mesh vertices in model space
+    ///
+    /// Returns `None` if `self` doesn't have [`Mesh::ATTRIBUTE_POSITION`] of
+    /// type [`VertexAttributeValues::Float32x3`], or if `self` doesn't have any vertices.
+    fn compute_aabb(&self) -> Option<Aabb>;
+}
+
+impl MeshAabb for Mesh {
+    fn compute_aabb(&self) -> Option<Aabb> {
+        let Some(VertexAttributeValues::Float32x3(values)) =
+            self.attribute(Mesh::ATTRIBUTE_POSITION)
+        else {
+            return None;
+        };
+
+        Aabb::enclosing(values.iter().map(|p| Vec3::from_slice(p)))
+    }
+}
+
+/// The render world representation of a [`Mesh`].
+#[derive(Debug, Clone)]
+pub struct RenderMesh {
+    /// The number of vertices in the mesh.
+    pub vertex_count: u32,
+
+    /// Morph targets for the mesh, if present.
+    pub morph_targets: Option<TextureView>,
+
+    /// Information about the mesh data buffers, including whether the mesh uses
+    /// indices or not.
+    pub buffer_info: RenderMeshBufferInfo,
+
+    /// Precomputed pipeline key bits for this mesh.
+    pub key_bits: BaseMeshPipelineKey,
+
+    /// A reference to the vertex buffer layout.
+    ///
+    /// Combined with [`RenderMesh::buffer_info`], this specifies the complete
+    /// layout of the buffers associated with this mesh.
+    pub layout: MeshVertexBufferLayoutRef,
+}
+
+impl RenderMesh {
+    /// Returns the primitive topology of this mesh (triangles, triangle strips,
+    /// etc.)
+    #[inline]
+    pub fn primitive_topology(&self) -> PrimitiveTopology {
+        self.key_bits.primitive_topology()
+    }
+
+    /// Returns true if this mesh uses an index buffer or false otherwise.
+    #[inline]
+    pub fn indexed(&self) -> bool {
+        matches!(self.buffer_info, RenderMeshBufferInfo::Indexed { .. })
+    }
+}
+
+/// The index/vertex buffer info of a [`RenderMesh`].
+#[derive(Debug, Clone)]
+pub enum RenderMeshBufferInfo {
+    Indexed {
+        count: u32,
+        index_format: IndexFormat,
+    },
+    NonIndexed,
+}
+
+impl RenderAsset for RenderMesh {
+    type SourceAsset = Mesh;
+    type Param = (
+        SRes<RenderAssets<GpuImage>>,
+        SResMut<MeshVertexBufferLayouts>,
+    );
+
+    #[inline]
+    fn asset_usage(mesh: &Self::SourceAsset) -> RenderAssetUsages {
+        mesh.asset_usage
+    }
+
+    fn byte_len(mesh: &Self::SourceAsset) -> Option<usize> {
+        let mut vertex_size = 0;
+        for attribute_data in mesh.attributes() {
+            let vertex_format = attribute_data.0.format;
+            vertex_size += vertex_format.size() as usize;
+        }
+
+        let vertex_count = mesh.count_vertices();
+        let index_bytes = mesh.get_index_buffer_bytes().map(<[_]>::len).unwrap_or(0);
+        Some(vertex_size * vertex_count + index_bytes)
+    }
+
+    /// Converts the extracted mesh into a [`RenderMesh`].
+    fn prepare_asset(
+        mesh: Self::SourceAsset,
+        _: AssetId<Self::SourceAsset>,
+        (images, mesh_vertex_buffer_layouts): &mut SystemParamItem<Self::Param>,
+    ) -> Result<Self, PrepareAssetError<Self::SourceAsset>> {
+        let morph_targets = match mesh.morph_targets() {
+            Some(mt) => {
+                let Some(target_image) = images.get(mt) else {
+                    return Err(PrepareAssetError::RetryNextUpdate(mesh));
+                };
+                Some(target_image.texture_view.clone())
+            }
+            None => None,
+        };
+
+        let buffer_info = match mesh.indices() {
+            Some(indices) => RenderMeshBufferInfo::Indexed {
+                count: indices.len() as u32,
+                index_format: indices.into(),
+            },
+            None => RenderMeshBufferInfo::NonIndexed,
+        };
+
+        let mesh_vertex_buffer_layout =
+            mesh.get_mesh_vertex_buffer_layout(mesh_vertex_buffer_layouts);
+
+        let mut key_bits = BaseMeshPipelineKey::from_primitive_topology(mesh.primitive_topology());
+        key_bits.set(
+            BaseMeshPipelineKey::MORPH_TARGETS,
+            mesh.morph_targets().is_some(),
+        );
+
+        Ok(RenderMesh {
+            vertex_count: mesh.count_vertices() as u32,
+            buffer_info,
+            key_bits,
+            layout: mesh_vertex_buffer_layout,
+            morph_targets,
+        })
+    }
+}

vendor/bevy_render/src/pipelined_rendering.rs

@@ -0,0 +1,204 @@
+use async_channel::{Receiver, Sender};
+
+use bevy_app::{App, AppExit, AppLabel, Plugin, SubApp};
+use bevy_ecs::{
+    resource::Resource,
+    schedule::MainThreadExecutor,
+    world::{Mut, World},
+};
+use bevy_tasks::ComputeTaskPool;
+
+use crate::RenderApp;
+
+/// A Label for the sub app that runs the parts of pipelined rendering that need to run on the main thread.
+///
+/// The Main schedule of this app can be used to run logic after the render schedule starts, but
+/// before I/O processing. This can be useful for something like frame pacing.
+#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, AppLabel)]
+pub struct RenderExtractApp;
+
+/// Channels used by the main app to send and receive the render app.
+#[derive(Resource)]
+pub struct RenderAppChannels {
+    app_to_render_sender: Sender<SubApp>,
+    render_to_app_receiver: Receiver<SubApp>,
+    render_app_in_render_thread: bool,
+}
+
+impl RenderAppChannels {
+    /// Create a `RenderAppChannels` from a [`async_channel::Receiver`] and [`async_channel::Sender`]
+    pub fn new(
+        app_to_render_sender: Sender<SubApp>,
+        render_to_app_receiver: Receiver<SubApp>,
+    ) -> Self {
+        Self {
+            app_to_render_sender,
+            render_to_app_receiver,
+            render_app_in_render_thread: false,
+        }
+    }
+
+    /// Send the `render_app` to the rendering thread.
+    pub fn send_blocking(&mut self, render_app: SubApp) {
+        self.app_to_render_sender.send_blocking(render_app).unwrap();
+        self.render_app_in_render_thread = true;
+    }
+
+    /// Receive the `render_app` from the rendering thread.
+    /// Return `None` if the render thread has panicked.
+    pub async fn recv(&mut self) -> Option<SubApp> {
+        let render_app = self.render_to_app_receiver.recv().await.ok()?;
+        self.render_app_in_render_thread = false;
+        Some(render_app)
+    }
+}
+
+impl Drop for RenderAppChannels {
+    fn drop(&mut self) {
+        if self.render_app_in_render_thread {
+            // Any non-send data in the render world was initialized on the main thread.
+            // So on dropping the main world and ending the app, we block and wait for
+            // the render world to return to drop it. Which allows the non-send data
+            // drop methods to run on the correct thread.
+            self.render_to_app_receiver.recv_blocking().ok();
+        }
+    }
+}
+
+/// The [`PipelinedRenderingPlugin`] can be added to your application to enable pipelined rendering.
+///
+/// This moves rendering into a different thread, so that the Nth frame's rendering can
+/// be run at the same time as the N + 1 frame's simulation.
+///
+/// ```text
+/// |--------------------|--------------------|--------------------|--------------------|
+/// | simulation thread  | frame 1 simulation | frame 2 simulation | frame 3 simulation |
+/// |--------------------|--------------------|--------------------|--------------------|
+/// | rendering thread   |                    | frame 1 rendering  | frame 2 rendering  |
+/// |--------------------|--------------------|--------------------|--------------------|
+/// ```
+///
+/// The plugin is dependent on the [`RenderApp`] added by [`crate::RenderPlugin`] and so must
+/// be added after that plugin. If it is not added after, the plugin will do nothing.
+///
+/// A single frame of execution looks something like below
+///
+/// ```text
+/// |---------------------------------------------------------------------------|
+/// |      |         | RenderExtractApp schedule | winit events | main schedule |
+/// | sync | extract |----------------------------------------------------------|
+/// |      |         | extract commands | rendering schedule                    |
+/// |---------------------------------------------------------------------------|
+/// ```
+///
+/// - `sync` is the step where the entity-entity mapping between the main and render world is updated.
+///   This is run on the main app's thread. For more information checkout [`SyncWorldPlugin`].
+/// - `extract` is the step where data is copied from the main world to the render world.
+///   This is run on the main app's thread.
+/// - On the render thread, we first apply the `extract commands`. This is not run during extract, so the
+///   main schedule can start sooner.
+/// - Then the `rendering schedule` is run. See [`RenderSet`](crate::RenderSet) for the standard steps in this process.
+/// - In parallel to the rendering thread the [`RenderExtractApp`] schedule runs. By
+///   default, this schedule is empty. But it is useful if you need something to run before I/O processing.
+/// - Next all the `winit events` are processed.
+/// - And finally the `main app schedule` is run.
+/// - Once both the `main app schedule` and the `render schedule` are finished running, `extract` is run again.
+///
+/// [`SyncWorldPlugin`]: crate::sync_world::SyncWorldPlugin
+#[derive(Default)]
+pub struct PipelinedRenderingPlugin;
+
+impl Plugin for PipelinedRenderingPlugin {
+    fn build(&self, app: &mut App) {
+        // Don't add RenderExtractApp if RenderApp isn't initialized.
+        if app.get_sub_app(RenderApp).is_none() {
+            return;
+        }
+        app.insert_resource(MainThreadExecutor::new());
+
+        let mut sub_app = SubApp::new();
+        sub_app.set_extract(renderer_extract);
+        app.insert_sub_app(RenderExtractApp, sub_app);
+    }
+
+    // Sets up the render thread and inserts resources into the main app used for controlling the render thread.
+    fn cleanup(&self, app: &mut App) {
+        // skip setting up when headless
+        if app.get_sub_app(RenderExtractApp).is_none() {
+            return;
+        }
+
+        let (app_to_render_sender, app_to_render_receiver) = async_channel::bounded::<SubApp>(1);
+        let (render_to_app_sender, render_to_app_receiver) = async_channel::bounded::<SubApp>(1);
+
+        let mut render_app = app
+            .remove_sub_app(RenderApp)
+            .expect("Unable to get RenderApp. Another plugin may have removed the RenderApp before PipelinedRenderingPlugin");
+
+        // clone main thread executor to render world
+        let executor = app.world().get_resource::<MainThreadExecutor>().unwrap();
+        render_app.world_mut().insert_resource(executor.clone());
+
+        render_to_app_sender.send_blocking(render_app).unwrap();
+
+        app.insert_resource(RenderAppChannels::new(
+            app_to_render_sender,
+            render_to_app_receiver,
+        ));
+
+        std::thread::spawn(move || {
+            #[cfg(feature = "trace")]
+            let _span = tracing::info_span!("render thread").entered();
+
+            let compute_task_pool = ComputeTaskPool::get();
+            loop {
+                // run a scope here to allow main world to use this thread while it's waiting for the render app
+                let sent_app = compute_task_pool
+                    .scope(|s| {
+                        s.spawn(async { app_to_render_receiver.recv().await });
+                    })
+                    .pop();
+                let Some(Ok(mut render_app)) = sent_app else {
+                    break;
+                };
+
+                {
+                    #[cfg(feature = "trace")]
+                    let _sub_app_span = tracing::info_span!("sub app", name = ?RenderApp).entered();
+                    render_app.update();
+                }
+
+                if render_to_app_sender.send_blocking(render_app).is_err() {
+                    break;
+                }
+            }
+
+            tracing::debug!("exiting pipelined rendering thread");
+        });
+    }
+}
+
+// This function waits for the rendering world to be received,
+// runs extract, and then sends the rendering world back to the render thread.
+fn renderer_extract(app_world: &mut World, _world: &mut World) {
+    app_world.resource_scope(|world, main_thread_executor: Mut<MainThreadExecutor>| {
+        world.resource_scope(|world, mut render_channels: Mut<RenderAppChannels>| {
+            // we use a scope here to run any main thread tasks that the render world still needs to run
+            // while we wait for the render world to be received.
+            if let Some(mut render_app) = ComputeTaskPool::get()
+                .scope_with_executor(true, Some(&*main_thread_executor.0), |s| {
+                    s.spawn(async { render_channels.recv().await });
+                })
+                .pop()
+                .unwrap()
+            {
+                render_app.extract(world);
+
+                render_channels.send_blocking(render_app);
+            } else {
+                // Renderer thread panicked
+                world.send_event(AppExit::error());
+            }
+        });
+    });
+}

vendor/bevy_render/src/primitives/mod.rs

@@ -0,0 +1,626 @@
+use core::borrow::Borrow;
+
+use bevy_ecs::{component::Component, entity::EntityHashMap, reflect::ReflectComponent};
+use bevy_math::{Affine3A, Mat3A, Mat4, Vec3, Vec3A, Vec4, Vec4Swizzles};
+use bevy_reflect::prelude::*;
+
+/// An axis-aligned bounding box, defined by:
+/// - a center,
+/// - the distances from the center to each faces along the axis,
+///   the faces are orthogonal to the axis.
+///
+/// It is typically used as a component on an entity to represent the local space
+/// occupied by this entity, with faces orthogonal to its local axis.
+///
+/// This component is notably used during "frustum culling", a process to determine
+/// if an entity should be rendered by a [`Camera`] if its bounding box intersects
+/// with the camera's [`Frustum`].
+///
+/// It will be added automatically by the systems in [`CalculateBounds`] to entities that:
+/// - could be subject to frustum culling, for example with a [`Mesh3d`]
+///   or `Sprite` component,
+/// - don't have the [`NoFrustumCulling`] component.
+///
+/// It won't be updated automatically if the space occupied by the entity changes,
+/// for example if the vertex positions of a [`Mesh3d`] are updated.
+///
+/// [`Camera`]: crate::camera::Camera
+/// [`NoFrustumCulling`]: crate::view::visibility::NoFrustumCulling
+/// [`CalculateBounds`]: crate::view::visibility::VisibilitySystems::CalculateBounds
+/// [`Mesh3d`]: crate::mesh::Mesh
+#[derive(Component, Clone, Copy, Debug, Default, Reflect, PartialEq)]
+#[reflect(Component, Default, Debug, PartialEq, Clone)]
+pub struct Aabb {
+    pub center: Vec3A,
+    pub half_extents: Vec3A,
+}
+
+impl Aabb {
+    #[inline]
+    pub fn from_min_max(minimum: Vec3, maximum: Vec3) -> Self {
+        let minimum = Vec3A::from(minimum);
+        let maximum = Vec3A::from(maximum);
+        let center = 0.5 * (maximum + minimum);
+        let half_extents = 0.5 * (maximum - minimum);
+        Self {
+            center,
+            half_extents,
+        }
+    }
+
+    /// Returns a bounding box enclosing the specified set of points.
+    ///
+    /// Returns `None` if the iterator is empty.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use bevy_math::{Vec3, Vec3A};
+    /// # use bevy_render::primitives::Aabb;
+    /// let bb = Aabb::enclosing([Vec3::X, Vec3::Z * 2.0, Vec3::Y * -0.5]).unwrap();
+    /// assert_eq!(bb.min(), Vec3A::new(0.0, -0.5, 0.0));
+    /// assert_eq!(bb.max(), Vec3A::new(1.0, 0.0, 2.0));
+    /// ```
+    pub fn enclosing<T: Borrow<Vec3>>(iter: impl IntoIterator<Item = T>) -> Option<Self> {
+        let mut iter = iter.into_iter().map(|p| *p.borrow());
+        let mut min = iter.next()?;
+        let mut max = min;
+        for v in iter {
+            min = Vec3::min(min, v);
+            max = Vec3::max(max, v);
+        }
+        Some(Self::from_min_max(min, max))
+    }
+
+    /// Calculate the relative radius of the AABB with respect to a plane
+    #[inline]
+    pub fn relative_radius(&self, p_normal: &Vec3A, world_from_local: &Mat3A) -> f32 {
+        // NOTE: dot products on Vec3A use SIMD and even with the overhead of conversion are net faster than Vec3
+        let half_extents = self.half_extents;
+        Vec3A::new(
+            p_normal.dot(world_from_local.x_axis),
+            p_normal.dot(world_from_local.y_axis),
+            p_normal.dot(world_from_local.z_axis),
+        )
+        .abs()
+        .dot(half_extents)
+    }
+
+    #[inline]
+    pub fn min(&self) -> Vec3A {
+        self.center - self.half_extents
+    }
+
+    #[inline]
+    pub fn max(&self) -> Vec3A {
+        self.center + self.half_extents
+    }
+
+    /// Check if the AABB is at the front side of the bisecting plane.
+    /// Referenced from: [AABB Plane intersection](https://gdbooks.gitbooks.io/3dcollisions/content/Chapter2/static_aabb_plane.html)
+    #[inline]
+    pub fn is_in_half_space(&self, half_space: &HalfSpace, world_from_local: &Affine3A) -> bool {
+        // transform the half-extents into world space.
+        let half_extents_world = world_from_local.matrix3.abs() * self.half_extents.abs();
+        // collapse the half-extents onto the plane normal.
+        let p_normal = half_space.normal();
+        let r = half_extents_world.dot(p_normal.abs());
+        let aabb_center_world = world_from_local.transform_point3a(self.center);
+        let signed_distance = p_normal.dot(aabb_center_world) + half_space.d();
+        signed_distance > r
+    }
+}
+
+impl From<Sphere> for Aabb {
+    #[inline]
+    fn from(sphere: Sphere) -> Self {
+        Self {
+            center: sphere.center,
+            half_extents: Vec3A::splat(sphere.radius),
+        }
+    }
+}
+
+#[derive(Clone, Debug, Default)]
+pub struct Sphere {
+    pub center: Vec3A,
+    pub radius: f32,
+}
+
+impl Sphere {
+    #[inline]
+    pub fn intersects_obb(&self, aabb: &Aabb, world_from_local: &Affine3A) -> bool {
+        let aabb_center_world = world_from_local.transform_point3a(aabb.center);
+        let v = aabb_center_world - self.center;
+        let d = v.length();
+        let relative_radius = aabb.relative_radius(&(v / d), &world_from_local.matrix3);
+        d < self.radius + relative_radius
+    }
+}
+
+/// A region of 3D space, specifically an open set whose border is a bisecting 2D plane.
+///
+/// This bisecting plane partitions 3D space into two infinite regions,
+/// the half-space is one of those regions and excludes the bisecting plane.
+///
+/// Each instance of this type is characterized by:
+/// - the bisecting plane's unit normal, normalized and pointing "inside" the half-space,
+/// - the signed distance along the normal from the bisecting plane to the origin of 3D space.
+///
+/// The distance can also be seen as:
+/// - the distance along the inverse of the normal from the origin of 3D space to the bisecting plane,
+/// - the opposite of the distance along the normal from the origin of 3D space to the bisecting plane.
+///
+/// Any point `p` is considered to be within the `HalfSpace` when the length of the projection
+/// of p on the normal is greater or equal than the opposite of the distance,
+/// meaning: if the equation `normal.dot(p) + distance > 0.` is satisfied.
+///
+/// For example, the half-space containing all the points with a z-coordinate lesser
+/// or equal than `8.0` would be defined by: `HalfSpace::new(Vec3::NEG_Z.extend(-8.0))`.
+/// It includes all the points from the bisecting plane towards `NEG_Z`, and the distance
+/// from the plane to the origin is `-8.0` along `NEG_Z`.
+///
+/// It is used to define a [`Frustum`], but is also a useful mathematical primitive for rendering tasks such as  light computation.
+#[derive(Clone, Copy, Debug, Default)]
+pub struct HalfSpace {
+    normal_d: Vec4,
+}
+
+impl HalfSpace {
+    /// Constructs a `HalfSpace` from a 4D vector whose first 3 components
+    /// represent the bisecting plane's unit normal, and the last component is
+    /// the signed distance along the normal from the plane to the origin.
+    /// The constructor ensures the normal vector is normalized and the distance is appropriately scaled.
+    #[inline]
+    pub fn new(normal_d: Vec4) -> Self {
+        Self {
+            normal_d: normal_d * normal_d.xyz().length_recip(),
+        }
+    }
+
+    /// Returns the unit normal vector of the bisecting plane that characterizes the `HalfSpace`.
+    #[inline]
+    pub fn normal(&self) -> Vec3A {
+        Vec3A::from_vec4(self.normal_d)
+    }
+
+    /// Returns the signed distance from the bisecting plane to the origin along
+    /// the plane's unit normal vector.
+    #[inline]
+    pub fn d(&self) -> f32 {
+        self.normal_d.w
+    }
+
+    /// Returns the bisecting plane's unit normal vector and the signed distance
+    /// from the plane to the origin.
+    #[inline]
+    pub fn normal_d(&self) -> Vec4 {
+        self.normal_d
+    }
+}
+
+/// A region of 3D space defined by the intersection of 6 [`HalfSpace`]s.
+///
+/// Frustums are typically an apex-truncated square pyramid (a pyramid without the top) or a cuboid.
+///
+/// Half spaces are ordered left, right, top, bottom, near, far. The normal vectors
+/// of the half-spaces point towards the interior of the frustum.
+///
+/// A frustum component is used on an entity with a [`Camera`] component to
+/// determine which entities will be considered for rendering by this camera.
+/// All entities with an [`Aabb`] component that are not contained by (or crossing
+/// the boundary of) the frustum will not be rendered, and not be used in rendering computations.
+///
+/// This process is called frustum culling, and entities can opt out of it using
+/// the [`NoFrustumCulling`] component.
+///
+/// The frustum component is typically added automatically for cameras, either `Camera2d` or `Camera3d`.
+/// It is usually updated automatically by [`update_frusta`] from the
+/// [`CameraProjection`] component and [`GlobalTransform`] of the camera entity.
+///
+/// [`Camera`]: crate::camera::Camera
+/// [`NoFrustumCulling`]: crate::view::visibility::NoFrustumCulling
+/// [`update_frusta`]: crate::view::visibility::update_frusta
+/// [`CameraProjection`]: crate::camera::CameraProjection
+/// [`GlobalTransform`]: bevy_transform::components::GlobalTransform
+#[derive(Component, Clone, Copy, Debug, Default, Reflect)]
+#[reflect(Component, Default, Debug, Clone)]
+pub struct Frustum {
+    #[reflect(ignore, clone)]
+    pub half_spaces: [HalfSpace; 6],
+}
+
+impl Frustum {
+    /// Returns a frustum derived from `clip_from_world`.
+    #[inline]
+    pub fn from_clip_from_world(clip_from_world: &Mat4) -> Self {
+        let mut frustum = Frustum::from_clip_from_world_no_far(clip_from_world);
+        frustum.half_spaces[5] = HalfSpace::new(clip_from_world.row(2));
+        frustum
+    }
+
+    /// Returns a frustum derived from `clip_from_world`,
+    /// but with a custom far plane.
+    #[inline]
+    pub fn from_clip_from_world_custom_far(
+        clip_from_world: &Mat4,
+        view_translation: &Vec3,
+        view_backward: &Vec3,
+        far: f32,
+    ) -> Self {
+        let mut frustum = Frustum::from_clip_from_world_no_far(clip_from_world);
+        let far_center = *view_translation - far * *view_backward;
+        frustum.half_spaces[5] =
+            HalfSpace::new(view_backward.extend(-view_backward.dot(far_center)));
+        frustum
+    }
+
+    // NOTE: This approach of extracting the frustum half-space from the view
+    // projection matrix is from Foundations of Game Engine Development 2
+    // Rendering by Lengyel.
+    /// Returns a frustum derived from `view_projection`,
+    /// without a far plane.
+    fn from_clip_from_world_no_far(clip_from_world: &Mat4) -> Self {
+        let row3 = clip_from_world.row(3);
+        let mut half_spaces = [HalfSpace::default(); 6];
+        for (i, half_space) in half_spaces.iter_mut().enumerate().take(5) {
+            let row = clip_from_world.row(i / 2);
+            *half_space = HalfSpace::new(if (i & 1) == 0 && i != 4 {
+                row3 + row
+            } else {
+                row3 - row
+            });
+        }
+        Self { half_spaces }
+    }
+
+    /// Checks if a sphere intersects the frustum.
+    #[inline]
+    pub fn intersects_sphere(&self, sphere: &Sphere, intersect_far: bool) -> bool {
+        let sphere_center = sphere.center.extend(1.0);
+        let max = if intersect_far { 6 } else { 5 };
+        for half_space in &self.half_spaces[..max] {
+            if half_space.normal_d().dot(sphere_center) + sphere.radius <= 0.0 {
+                return false;
+            }
+        }
+        true
+    }
+
+    /// Checks if an Oriented Bounding Box (obb) intersects the frustum.
+    #[inline]
+    pub fn intersects_obb(
+        &self,
+        aabb: &Aabb,
+        world_from_local: &Affine3A,
+        intersect_near: bool,
+        intersect_far: bool,
+    ) -> bool {
+        let aabb_center_world = world_from_local.transform_point3a(aabb.center).extend(1.0);
+        for (idx, half_space) in self.half_spaces.into_iter().enumerate() {
+            if idx == 4 && !intersect_near {
+                continue;
+            }
+            if idx == 5 && !intersect_far {
+                continue;
+            }
+            let p_normal = half_space.normal();
+            let relative_radius = aabb.relative_radius(&p_normal, &world_from_local.matrix3);
+            if half_space.normal_d().dot(aabb_center_world) + relative_radius <= 0.0 {
+                return false;
+            }
+        }
+        true
+    }
+
+    /// Check if the frustum contains the Axis-Aligned Bounding Box (AABB).
+    /// Referenced from: [Frustum Culling](https://learnopengl.com/Guest-Articles/2021/Scene/Frustum-Culling)
+    #[inline]
+    pub fn contains_aabb(&self, aabb: &Aabb, world_from_local: &Affine3A) -> bool {
+        for half_space in &self.half_spaces {
+            if !aabb.is_in_half_space(half_space, world_from_local) {
+                return false;
+            }
+        }
+        true
+    }
+}
+
+#[derive(Component, Clone, Debug, Default, Reflect)]
+#[reflect(Component, Default, Debug, Clone)]
+pub struct CubemapFrusta {
+    #[reflect(ignore, clone)]
+    pub frusta: [Frustum; 6],
+}
+
+impl CubemapFrusta {
+    pub fn iter(&self) -> impl DoubleEndedIterator<Item = &Frustum> {
+        self.frusta.iter()
+    }
+    pub fn iter_mut(&mut self) -> impl DoubleEndedIterator<Item = &mut Frustum> {
+        self.frusta.iter_mut()
+    }
+}
+
+#[derive(Component, Debug, Default, Reflect, Clone)]
+#[reflect(Component, Default, Debug, Clone)]
+pub struct CascadesFrusta {
+    #[reflect(ignore, clone)]
+    pub frusta: EntityHashMap<Vec<Frustum>>,
+}
+
+#[cfg(test)]
+mod tests {
+    use core::f32::consts::PI;
+
+    use bevy_math::{ops, Quat};
+    use bevy_transform::components::GlobalTransform;
+
+    use crate::camera::{CameraProjection, PerspectiveProjection};
+
+    use super::*;
+
+    // A big, offset frustum
+    fn big_frustum() -> Frustum {
+        Frustum {
+            half_spaces: [
+                HalfSpace::new(Vec4::new(-0.9701, -0.2425, -0.0000, 7.7611)),
+                HalfSpace::new(Vec4::new(-0.0000, 1.0000, -0.0000, 4.0000)),
+                HalfSpace::new(Vec4::new(-0.0000, -0.2425, -0.9701, 2.9104)),
+                HalfSpace::new(Vec4::new(-0.0000, -1.0000, -0.0000, 4.0000)),
+                HalfSpace::new(Vec4::new(-0.0000, -0.2425, 0.9701, 2.9104)),
+                HalfSpace::new(Vec4::new(0.9701, -0.2425, -0.0000, -1.9403)),
+            ],
+        }
+    }
+
+    #[test]
+    fn intersects_sphere_big_frustum_outside() {
+        // Sphere outside frustum
+        let frustum = big_frustum();
+        let sphere = Sphere {
+            center: Vec3A::new(0.9167, 0.0000, 0.0000),
+            radius: 0.7500,
+        };
+        assert!(!frustum.intersects_sphere(&sphere, true));
+    }
+
+    #[test]
+    fn intersects_sphere_big_frustum_intersect() {
+        // Sphere intersects frustum boundary
+        let frustum = big_frustum();
+        let sphere = Sphere {
+            center: Vec3A::new(7.9288, 0.0000, 2.9728),
+            radius: 2.0000,
+        };
+        assert!(frustum.intersects_sphere(&sphere, true));
+    }
+
+    // A frustum
+    fn frustum() -> Frustum {
+        Frustum {
+            half_spaces: [
+                HalfSpace::new(Vec4::new(-0.9701, -0.2425, -0.0000, 0.7276)),
+                HalfSpace::new(Vec4::new(-0.0000, 1.0000, -0.0000, 1.0000)),
+                HalfSpace::new(Vec4::new(-0.0000, -0.2425, -0.9701, 0.7276)),
+                HalfSpace::new(Vec4::new(-0.0000, -1.0000, -0.0000, 1.0000)),
+                HalfSpace::new(Vec4::new(-0.0000, -0.2425, 0.9701, 0.7276)),
+                HalfSpace::new(Vec4::new(0.9701, -0.2425, -0.0000, 0.7276)),
+            ],
+        }
+    }
+
+    #[test]
+    fn intersects_sphere_frustum_surrounding() {
+        // Sphere surrounds frustum
+        let frustum = frustum();
+        let sphere = Sphere {
+            center: Vec3A::new(0.0000, 0.0000, 0.0000),
+            radius: 3.0000,
+        };
+        assert!(frustum.intersects_sphere(&sphere, true));
+    }
+
+    #[test]
+    fn intersects_sphere_frustum_contained() {
+        // Sphere is contained in frustum
+        let frustum = frustum();
+        let sphere = Sphere {
+            center: Vec3A::new(0.0000, 0.0000, 0.0000),
+            radius: 0.7000,
+        };
+        assert!(frustum.intersects_sphere(&sphere, true));
+    }
+
+    #[test]
+    fn intersects_sphere_frustum_intersects_plane() {
+        // Sphere intersects a plane
+        let frustum = frustum();
+        let sphere = Sphere {
+            center: Vec3A::new(0.0000, 0.0000, 0.9695),
+            radius: 0.7000,
+        };
+        assert!(frustum.intersects_sphere(&sphere, true));
+    }
+
+    #[test]
+    fn intersects_sphere_frustum_intersects_2_planes() {
+        // Sphere intersects 2 planes
+        let frustum = frustum();
+        let sphere = Sphere {
+            center: Vec3A::new(1.2037, 0.0000, 0.9695),
+            radius: 0.7000,
+        };
+        assert!(frustum.intersects_sphere(&sphere, true));
+    }
+
+    #[test]
+    fn intersects_sphere_frustum_intersects_3_planes() {
+        // Sphere intersects 3 planes
+        let frustum = frustum();
+        let sphere = Sphere {
+            center: Vec3A::new(1.2037, -1.0988, 0.9695),
+            radius: 0.7000,
+        };
+        assert!(frustum.intersects_sphere(&sphere, true));
+    }
+
+    #[test]
+    fn intersects_sphere_frustum_dodges_1_plane() {
+        // Sphere avoids intersecting the frustum by 1 plane
+        let frustum = frustum();
+        let sphere = Sphere {
+            center: Vec3A::new(-1.7020, 0.0000, 0.0000),
+            radius: 0.7000,
+        };
+        assert!(!frustum.intersects_sphere(&sphere, true));
+    }
+
+    // A long frustum.
+    fn long_frustum() -> Frustum {
+        Frustum {
+            half_spaces: [
+                HalfSpace::new(Vec4::new(-0.9998, -0.0222, -0.0000, -1.9543)),
+                HalfSpace::new(Vec4::new(-0.0000, 1.0000, -0.0000, 45.1249)),
+                HalfSpace::new(Vec4::new(-0.0000, -0.0168, -0.9999, 2.2718)),
+                HalfSpace::new(Vec4::new(-0.0000, -1.0000, -0.0000, 45.1249)),
+                HalfSpace::new(Vec4::new(-0.0000, -0.0168, 0.9999, 2.2718)),
+                HalfSpace::new(Vec4::new(0.9998, -0.0222, -0.0000, 7.9528)),
+            ],
+        }
+    }
+
+    #[test]
+    fn intersects_sphere_long_frustum_outside() {
+        // Sphere outside frustum
+        let frustum = long_frustum();
+        let sphere = Sphere {
+            center: Vec3A::new(-4.4889, 46.9021, 0.0000),
+            radius: 0.7500,
+        };
+        assert!(!frustum.intersects_sphere(&sphere, true));
+    }
+
+    #[test]
+    fn intersects_sphere_long_frustum_intersect() {
+        // Sphere intersects frustum boundary
+        let frustum = long_frustum();
+        let sphere = Sphere {
+            center: Vec3A::new(-4.9957, 0.0000, -0.7396),
+            radius: 4.4094,
+        };
+        assert!(frustum.intersects_sphere(&sphere, true));
+    }
+
+    #[test]
+    fn aabb_enclosing() {
+        assert_eq!(Aabb::enclosing(<[Vec3; 0]>::default()), None);
+        assert_eq!(
+            Aabb::enclosing(vec![Vec3::ONE]).unwrap(),
+            Aabb::from_min_max(Vec3::ONE, Vec3::ONE)
+        );
+        assert_eq!(
+            Aabb::enclosing(&[Vec3::Y, Vec3::X, Vec3::Z][..]).unwrap(),
+            Aabb::from_min_max(Vec3::ZERO, Vec3::ONE)
+        );
+        assert_eq!(
+            Aabb::enclosing([
+                Vec3::NEG_X,
+                Vec3::X * 2.0,
+                Vec3::NEG_Y * 5.0,
+                Vec3::Z,
+                Vec3::ZERO
+            ])
+            .unwrap(),
+            Aabb::from_min_max(Vec3::new(-1.0, -5.0, 0.0), Vec3::new(2.0, 0.0, 1.0))
+        );
+    }
+
+    // A frustum with an offset for testing the [`Frustum::contains_aabb`] algorithm.
+    fn contains_aabb_test_frustum() -> Frustum {
+        let proj = PerspectiveProjection {
+            fov: 90.0_f32.to_radians(),
+            aspect_ratio: 1.0,
+            near: 1.0,
+            far: 100.0,
+        };
+        proj.compute_frustum(&GlobalTransform::from_translation(Vec3::new(2.0, 2.0, 0.0)))
+    }
+
+    fn contains_aabb_test_frustum_with_rotation() -> Frustum {
+        let half_extent_world = (((49.5 * 49.5) * 0.5) as f32).sqrt() + 0.5f32.sqrt();
+        let near = 50.5 - half_extent_world;
+        let far = near + 2.0 * half_extent_world;
+        let fov = 2.0 * ops::atan(half_extent_world / near);
+        let proj = PerspectiveProjection {
+            aspect_ratio: 1.0,
+            near,
+            far,
+            fov,
+        };
+        proj.compute_frustum(&GlobalTransform::IDENTITY)
+    }
+
+    #[test]
+    fn aabb_inside_frustum() {
+        let frustum = contains_aabb_test_frustum();
+        let aabb = Aabb {
+            center: Vec3A::ZERO,
+            half_extents: Vec3A::new(0.99, 0.99, 49.49),
+        };
+        let model = Affine3A::from_translation(Vec3::new(2.0, 2.0, -50.5));
+        assert!(frustum.contains_aabb(&aabb, &model));
+    }
+
+    #[test]
+    fn aabb_intersect_frustum() {
+        let frustum = contains_aabb_test_frustum();
+        let aabb = Aabb {
+            center: Vec3A::ZERO,
+            half_extents: Vec3A::new(0.99, 0.99, 49.6),
+        };
+        let model = Affine3A::from_translation(Vec3::new(2.0, 2.0, -50.5));
+        assert!(!frustum.contains_aabb(&aabb, &model));
+    }
+
+    #[test]
+    fn aabb_outside_frustum() {
+        let frustum = contains_aabb_test_frustum();
+        let aabb = Aabb {
+            center: Vec3A::ZERO,
+            half_extents: Vec3A::new(0.99, 0.99, 0.99),
+        };
+        let model = Affine3A::from_translation(Vec3::new(0.0, 0.0, 49.6));
+        assert!(!frustum.contains_aabb(&aabb, &model));
+    }
+
+    #[test]
+    fn aabb_inside_frustum_rotation() {
+        let frustum = contains_aabb_test_frustum_with_rotation();
+        let aabb = Aabb {
+            center: Vec3A::new(0.0, 0.0, 0.0),
+            half_extents: Vec3A::new(0.99, 0.99, 49.49),
+        };
+
+        let model = Affine3A::from_rotation_translation(
+            Quat::from_rotation_x(PI / 4.0),
+            Vec3::new(0.0, 0.0, -50.5),
+        );
+        assert!(frustum.contains_aabb(&aabb, &model));
+    }
+
+    #[test]
+    fn aabb_intersect_frustum_rotation() {
+        let frustum = contains_aabb_test_frustum_with_rotation();
+        let aabb = Aabb {
+            center: Vec3A::new(0.0, 0.0, 0.0),
+            half_extents: Vec3A::new(0.99, 0.99, 49.6),
+        };
+
+        let model = Affine3A::from_rotation_translation(
+            Quat::from_rotation_x(PI / 4.0),
+            Vec3::new(0.0, 0.0, -50.5),
+        );
+        assert!(!frustum.contains_aabb(&aabb, &model));
+    }
+}

vendor/bevy_render/src/render_asset.rs

@@ -0,0 +1,511 @@
+use crate::{
+    render_resource::AsBindGroupError, Extract, ExtractSchedule, MainWorld, Render, RenderApp,
+    RenderSet, Res,
+};
+use bevy_app::{App, Plugin, SubApp};
+pub use bevy_asset::RenderAssetUsages;
+use bevy_asset::{Asset, AssetEvent, AssetId, Assets};
+use bevy_ecs::{
+    prelude::{Commands, EventReader, IntoScheduleConfigs, ResMut, Resource},
+    schedule::{ScheduleConfigs, SystemSet},
+    system::{ScheduleSystem, StaticSystemParam, SystemParam, SystemParamItem, SystemState},
+    world::{FromWorld, Mut},
+};
+use bevy_platform::collections::{HashMap, HashSet};
+use core::marker::PhantomData;
+use core::sync::atomic::{AtomicUsize, Ordering};
+use thiserror::Error;
+use tracing::{debug, error};
+
+#[derive(Debug, Error)]
+pub enum PrepareAssetError<E: Send + Sync + 'static> {
+    #[error("Failed to prepare asset")]
+    RetryNextUpdate(E),
+    #[error("Failed to build bind group: {0}")]
+    AsBindGroupError(AsBindGroupError),
+}
+
+/// The system set during which we extract modified assets to the render world.
+#[derive(SystemSet, Clone, PartialEq, Eq, Debug, Hash)]
+pub struct ExtractAssetsSet;
+
+/// Describes how an asset gets extracted and prepared for rendering.
+///
+/// In the [`ExtractSchedule`] step the [`RenderAsset::SourceAsset`] is transferred
+/// from the "main world" into the "render world".
+///
+/// After that in the [`RenderSet::PrepareAssets`] step the extracted asset
+/// is transformed into its GPU-representation of type [`RenderAsset`].
+pub trait RenderAsset: Send + Sync + 'static + Sized {
+    /// The representation of the asset in the "main world".
+    type SourceAsset: Asset + Clone;
+
+    /// Specifies all ECS data required by [`RenderAsset::prepare_asset`].
+    ///
+    /// For convenience use the [`lifetimeless`](bevy_ecs::system::lifetimeless) [`SystemParam`].
+    type Param: SystemParam;
+
+    /// Whether or not to unload the asset after extracting it to the render world.
+    #[inline]
+    fn asset_usage(_source_asset: &Self::SourceAsset) -> RenderAssetUsages {
+        RenderAssetUsages::default()
+    }
+
+    /// Size of the data the asset will upload to the gpu. Specifying a return value
+    /// will allow the asset to be throttled via [`RenderAssetBytesPerFrame`].
+    #[inline]
+    #[expect(
+        unused_variables,
+        reason = "The parameters here are intentionally unused by the default implementation; however, putting underscores here will result in the underscores being copied by rust-analyzer's tab completion."
+    )]
+    fn byte_len(source_asset: &Self::SourceAsset) -> Option<usize> {
+        None
+    }
+
+    /// Prepares the [`RenderAsset::SourceAsset`] for the GPU by transforming it into a [`RenderAsset`].
+    ///
+    /// ECS data may be accessed via `param`.
+    fn prepare_asset(
+        source_asset: Self::SourceAsset,
+        asset_id: AssetId<Self::SourceAsset>,
+        param: &mut SystemParamItem<Self::Param>,
+    ) -> Result<Self, PrepareAssetError<Self::SourceAsset>>;
+
+    /// Called whenever the [`RenderAsset::SourceAsset`] has been removed.
+    ///
+    /// You can implement this method if you need to access ECS data (via
+    /// `_param`) in order to perform cleanup tasks when the asset is removed.
+    ///
+    /// The default implementation does nothing.
+    fn unload_asset(
+        _source_asset: AssetId<Self::SourceAsset>,
+        _param: &mut SystemParamItem<Self::Param>,
+    ) {
+    }
+}
+
+/// This plugin extracts the changed assets from the "app world" into the "render world"
+/// and prepares them for the GPU. They can then be accessed from the [`RenderAssets`] resource.
+///
+/// Therefore it sets up the [`ExtractSchedule`] and
+/// [`RenderSet::PrepareAssets`] steps for the specified [`RenderAsset`].
+///
+/// The `AFTER` generic parameter can be used to specify that `A::prepare_asset` should not be run until
+/// `prepare_assets::<AFTER>` has completed. This allows the `prepare_asset` function to depend on another
+/// prepared [`RenderAsset`], for example `Mesh::prepare_asset` relies on `RenderAssets::<GpuImage>` for morph
+/// targets, so the plugin is created as `RenderAssetPlugin::<RenderMesh, GpuImage>::default()`.
+pub struct RenderAssetPlugin<A: RenderAsset, AFTER: RenderAssetDependency + 'static = ()> {
+    phantom: PhantomData<fn() -> (A, AFTER)>,
+}
+
+impl<A: RenderAsset, AFTER: RenderAssetDependency + 'static> Default
+    for RenderAssetPlugin<A, AFTER>
+{
+    fn default() -> Self {
+        Self {
+            phantom: Default::default(),
+        }
+    }
+}
+
+impl<A: RenderAsset, AFTER: RenderAssetDependency + 'static> Plugin
+    for RenderAssetPlugin<A, AFTER>
+{
+    fn build(&self, app: &mut App) {
+        app.init_resource::<CachedExtractRenderAssetSystemState<A>>();
+        if let Some(render_app) = app.get_sub_app_mut(RenderApp) {
+            render_app
+                .init_resource::<ExtractedAssets<A>>()
+                .init_resource::<RenderAssets<A>>()
+                .init_resource::<PrepareNextFrameAssets<A>>()
+                .add_systems(
+                    ExtractSchedule,
+                    extract_render_asset::<A>.in_set(ExtractAssetsSet),
+                );
+            AFTER::register_system(
+                render_app,
+                prepare_assets::<A>.in_set(RenderSet::PrepareAssets),
+            );
+        }
+    }
+}
+
+// helper to allow specifying dependencies between render assets
+pub trait RenderAssetDependency {
+    fn register_system(render_app: &mut SubApp, system: ScheduleConfigs<ScheduleSystem>);
+}
+
+impl RenderAssetDependency for () {
+    fn register_system(render_app: &mut SubApp, system: ScheduleConfigs<ScheduleSystem>) {
+        render_app.add_systems(Render, system);
+    }
+}
+
+impl<A: RenderAsset> RenderAssetDependency for A {
+    fn register_system(render_app: &mut SubApp, system: ScheduleConfigs<ScheduleSystem>) {
+        render_app.add_systems(Render, system.after(prepare_assets::<A>));
+    }
+}
+
+/// Temporarily stores the extracted and removed assets of the current frame.
+#[derive(Resource)]
+pub struct ExtractedAssets<A: RenderAsset> {
+    /// The assets extracted this frame.
+    ///
+    /// These are assets that were either added or modified this frame.
+    pub extracted: Vec<(AssetId<A::SourceAsset>, A::SourceAsset)>,
+
+    /// IDs of the assets that were removed this frame.
+    ///
+    /// These assets will not be present in [`ExtractedAssets::extracted`].
+    pub removed: HashSet<AssetId<A::SourceAsset>>,
+
+    /// IDs of the assets that were modified this frame.
+    pub modified: HashSet<AssetId<A::SourceAsset>>,
+
+    /// IDs of the assets that were added this frame.
+    pub added: HashSet<AssetId<A::SourceAsset>>,
+}
+
+impl<A: RenderAsset> Default for ExtractedAssets<A> {
+    fn default() -> Self {
+        Self {
+            extracted: Default::default(),
+            removed: Default::default(),
+            modified: Default::default(),
+            added: Default::default(),
+        }
+    }
+}
+
+/// Stores all GPU representations ([`RenderAsset`])
+/// of [`RenderAsset::SourceAsset`] as long as they exist.
+#[derive(Resource)]
+pub struct RenderAssets<A: RenderAsset>(HashMap<AssetId<A::SourceAsset>, A>);
+
+impl<A: RenderAsset> Default for RenderAssets<A> {
+    fn default() -> Self {
+        Self(Default::default())
+    }
+}
+
+impl<A: RenderAsset> RenderAssets<A> {
+    pub fn get(&self, id: impl Into<AssetId<A::SourceAsset>>) -> Option<&A> {
+        self.0.get(&id.into())
+    }
+
+    pub fn get_mut(&mut self, id: impl Into<AssetId<A::SourceAsset>>) -> Option<&mut A> {
+        self.0.get_mut(&id.into())
+    }
+
+    pub fn insert(&mut self, id: impl Into<AssetId<A::SourceAsset>>, value: A) -> Option<A> {
+        self.0.insert(id.into(), value)
+    }
+
+    pub fn remove(&mut self, id: impl Into<AssetId<A::SourceAsset>>) -> Option<A> {
+        self.0.remove(&id.into())
+    }
+
+    pub fn iter(&self) -> impl Iterator<Item = (AssetId<A::SourceAsset>, &A)> {
+        self.0.iter().map(|(k, v)| (*k, v))
+    }
+
+    pub fn iter_mut(&mut self) -> impl Iterator<Item = (AssetId<A::SourceAsset>, &mut A)> {
+        self.0.iter_mut().map(|(k, v)| (*k, v))
+    }
+}
+
+#[derive(Resource)]
+struct CachedExtractRenderAssetSystemState<A: RenderAsset> {
+    state: SystemState<(
+        EventReader<'static, 'static, AssetEvent<A::SourceAsset>>,
+        ResMut<'static, Assets<A::SourceAsset>>,
+    )>,
+}
+
+impl<A: RenderAsset> FromWorld for CachedExtractRenderAssetSystemState<A> {
+    fn from_world(world: &mut bevy_ecs::world::World) -> Self {
+        Self {
+            state: SystemState::new(world),
+        }
+    }
+}
+
+/// This system extracts all created or modified assets of the corresponding [`RenderAsset::SourceAsset`] type
+/// into the "render world".
+pub(crate) fn extract_render_asset<A: RenderAsset>(
+    mut commands: Commands,
+    mut main_world: ResMut<MainWorld>,
+) {
+    main_world.resource_scope(
+        |world, mut cached_state: Mut<CachedExtractRenderAssetSystemState<A>>| {
+            let (mut events, mut assets) = cached_state.state.get_mut(world);
+
+            let mut needs_extracting = <HashSet<_>>::default();
+            let mut removed = <HashSet<_>>::default();
+            let mut modified = <HashSet<_>>::default();
+
+            for event in events.read() {
+                #[expect(
+                    clippy::match_same_arms,
+                    reason = "LoadedWithDependencies is marked as a TODO, so it's likely this will no longer lint soon."
+                )]
+                match event {
+                    AssetEvent::Added { id } => {
+                        needs_extracting.insert(*id);
+                    }
+                    AssetEvent::Modified { id } => {
+                        needs_extracting.insert(*id);
+                        modified.insert(*id);
+                    }
+                    AssetEvent::Removed { .. } => {
+                        // We don't care that the asset was removed from Assets<T> in the main world.
+                        // An asset is only removed from RenderAssets<T> when its last handle is dropped (AssetEvent::Unused).
+                    }
+                    AssetEvent::Unused { id } => {
+                        needs_extracting.remove(id);
+                        modified.remove(id);
+                        removed.insert(*id);
+                    }
+                    AssetEvent::LoadedWithDependencies { .. } => {
+                        // TODO: handle this
+                    }
+                }
+            }
+
+            let mut extracted_assets = Vec::new();
+            let mut added = <HashSet<_>>::default();
+            for id in needs_extracting.drain() {
+                if let Some(asset) = assets.get(id) {
+                    let asset_usage = A::asset_usage(asset);
+                    if asset_usage.contains(RenderAssetUsages::RENDER_WORLD) {
+                        if asset_usage == RenderAssetUsages::RENDER_WORLD {
+                            if let Some(asset) = assets.remove(id) {
+                                extracted_assets.push((id, asset));
+                                added.insert(id);
+                            }
+                        } else {
+                            extracted_assets.push((id, asset.clone()));
+                            added.insert(id);
+                        }
+                    }
+                }
+            }
+
+            commands.insert_resource(ExtractedAssets::<A> {
+                extracted: extracted_assets,
+                removed,
+                modified,
+                added,
+            });
+            cached_state.state.apply(world);
+        },
+    );
+}
+
+// TODO: consider storing inside system?
+/// All assets that should be prepared next frame.
+#[derive(Resource)]
+pub struct PrepareNextFrameAssets<A: RenderAsset> {
+    assets: Vec<(AssetId<A::SourceAsset>, A::SourceAsset)>,
+}
+
+impl<A: RenderAsset> Default for PrepareNextFrameAssets<A> {
+    fn default() -> Self {
+        Self {
+            assets: Default::default(),
+        }
+    }
+}
+
+/// This system prepares all assets of the corresponding [`RenderAsset::SourceAsset`] type
+/// which where extracted this frame for the GPU.
+pub fn prepare_assets<A: RenderAsset>(
+    mut extracted_assets: ResMut<ExtractedAssets<A>>,
+    mut render_assets: ResMut<RenderAssets<A>>,
+    mut prepare_next_frame: ResMut<PrepareNextFrameAssets<A>>,
+    param: StaticSystemParam<<A as RenderAsset>::Param>,
+    bpf: Res<RenderAssetBytesPerFrameLimiter>,
+) {
+    let mut wrote_asset_count = 0;
+
+    let mut param = param.into_inner();
+    let queued_assets = core::mem::take(&mut prepare_next_frame.assets);
+    for (id, extracted_asset) in queued_assets {
+        if extracted_assets.removed.contains(&id) || extracted_assets.added.contains(&id) {
+            // skip previous frame's assets that have been removed or updated
+            continue;
+        }
+
+        let write_bytes = if let Some(size) = A::byte_len(&extracted_asset) {
+            // we could check if available bytes > byte_len here, but we want to make some
+            // forward progress even if the asset is larger than the max bytes per frame.
+            // this way we always write at least one (sized) asset per frame.
+            // in future we could also consider partial asset uploads.
+            if bpf.exhausted() {
+                prepare_next_frame.assets.push((id, extracted_asset));
+                continue;
+            }
+            size
+        } else {
+            0
+        };
+
+        match A::prepare_asset(extracted_asset, id, &mut param) {
+            Ok(prepared_asset) => {
+                render_assets.insert(id, prepared_asset);
+                bpf.write_bytes(write_bytes);
+                wrote_asset_count += 1;
+            }
+            Err(PrepareAssetError::RetryNextUpdate(extracted_asset)) => {
+                prepare_next_frame.assets.push((id, extracted_asset));
+            }
+            Err(PrepareAssetError::AsBindGroupError(e)) => {
+                error!(
+                    "{} Bind group construction failed: {e}",
+                    core::any::type_name::<A>()
+                );
+            }
+        }
+    }
+
+    for removed in extracted_assets.removed.drain() {
+        render_assets.remove(removed);
+        A::unload_asset(removed, &mut param);
+    }
+
+    for (id, extracted_asset) in extracted_assets.extracted.drain(..) {
+        // we remove previous here to ensure that if we are updating the asset then
+        // any users will not see the old asset after a new asset is extracted,
+        // even if the new asset is not yet ready or we are out of bytes to write.
+        render_assets.remove(id);
+
+        let write_bytes = if let Some(size) = A::byte_len(&extracted_asset) {
+            if bpf.exhausted() {
+                prepare_next_frame.assets.push((id, extracted_asset));
+                continue;
+            }
+            size
+        } else {
+            0
+        };
+
+        match A::prepare_asset(extracted_asset, id, &mut param) {
+            Ok(prepared_asset) => {
+                render_assets.insert(id, prepared_asset);
+                bpf.write_bytes(write_bytes);
+                wrote_asset_count += 1;
+            }
+            Err(PrepareAssetError::RetryNextUpdate(extracted_asset)) => {
+                prepare_next_frame.assets.push((id, extracted_asset));
+            }
+            Err(PrepareAssetError::AsBindGroupError(e)) => {
+                error!(
+                    "{} Bind group construction failed: {e}",
+                    core::any::type_name::<A>()
+                );
+            }
+        }
+    }
+
+    if bpf.exhausted() && !prepare_next_frame.assets.is_empty() {
+        debug!(
+            "{} write budget exhausted with {} assets remaining (wrote {})",
+            core::any::type_name::<A>(),
+            prepare_next_frame.assets.len(),
+            wrote_asset_count
+        );
+    }
+}
+
+pub fn reset_render_asset_bytes_per_frame(
+    mut bpf_limiter: ResMut<RenderAssetBytesPerFrameLimiter>,
+) {
+    bpf_limiter.reset();
+}
+
+pub fn extract_render_asset_bytes_per_frame(
+    bpf: Extract<Res<RenderAssetBytesPerFrame>>,
+    mut bpf_limiter: ResMut<RenderAssetBytesPerFrameLimiter>,
+) {
+    bpf_limiter.max_bytes = bpf.max_bytes;
+}
+
+/// A resource that defines the amount of data allowed to be transferred from CPU to GPU
+/// each frame, preventing choppy frames at the cost of waiting longer for GPU assets
+/// to become available.
+#[derive(Resource, Default)]
+pub struct RenderAssetBytesPerFrame {
+    pub max_bytes: Option<usize>,
+}
+
+impl RenderAssetBytesPerFrame {
+    /// `max_bytes`: the number of bytes to write per frame.
+    ///
+    /// This is a soft limit: only full assets are written currently, uploading stops
+    /// after the first asset that exceeds the limit.
+    ///
+    /// To participate, assets should implement [`RenderAsset::byte_len`]. If the default
+    /// is not overridden, the assets are assumed to be small enough to upload without restriction.
+    pub fn new(max_bytes: usize) -> Self {
+        Self {
+            max_bytes: Some(max_bytes),
+        }
+    }
+}
+
+/// A render-world resource that facilitates limiting the data transferred from CPU to GPU
+/// each frame, preventing choppy frames at the cost of waiting longer for GPU assets
+/// to become available.
+#[derive(Resource, Default)]
+pub struct RenderAssetBytesPerFrameLimiter {
+    /// Populated by [`RenderAssetBytesPerFrame`] during extraction.
+    pub max_bytes: Option<usize>,
+    /// Bytes written this frame.
+    pub bytes_written: AtomicUsize,
+}
+
+impl RenderAssetBytesPerFrameLimiter {
+    /// Reset the available bytes. Called once per frame during extraction by [`crate::RenderPlugin`].
+    pub fn reset(&mut self) {
+        if self.max_bytes.is_none() {
+            return;
+        }
+        self.bytes_written.store(0, Ordering::Relaxed);
+    }
+
+    /// Check how many bytes are available for writing.
+    pub fn available_bytes(&self, required_bytes: usize) -> usize {
+        if let Some(max_bytes) = self.max_bytes {
+            let total_bytes = self
+                .bytes_written
+                .fetch_add(required_bytes, Ordering::Relaxed);
+
+            // The bytes available is the inverse of the amount we overshot max_bytes
+            if total_bytes >= max_bytes {
+                required_bytes.saturating_sub(total_bytes - max_bytes)
+            } else {
+                required_bytes
+            }
+        } else {
+            required_bytes
+        }
+    }
+
+    /// Decreases the available bytes for the current frame.
+    fn write_bytes(&self, bytes: usize) {
+        if self.max_bytes.is_some() && bytes > 0 {
+            self.bytes_written.fetch_add(bytes, Ordering::Relaxed);
+        }
+    }
+
+    /// Returns `true` if there are no remaining bytes available for writing this frame.
+    fn exhausted(&self) -> bool {
+        if let Some(max_bytes) = self.max_bytes {
+            let bytes_written = self.bytes_written.load(Ordering::Relaxed);
+            bytes_written >= max_bytes
+        } else {
+            false
+        }
+    }
+}

vendor/bevy_render/src/render_graph/app.rs

@@ -0,0 +1,137 @@
+use bevy_app::{App, SubApp};
+use bevy_ecs::world::FromWorld;
+use tracing::warn;
+
+use super::{IntoRenderNodeArray, Node, RenderGraph, RenderLabel, RenderSubGraph};
+
+/// Adds common [`RenderGraph`] operations to [`SubApp`] (and [`App`]).
+pub trait RenderGraphApp {
+    // Add a sub graph to the [`RenderGraph`]
+    fn add_render_sub_graph(&mut self, sub_graph: impl RenderSubGraph) -> &mut Self;
+    /// Add a [`Node`] to the [`RenderGraph`]:
+    /// * Create the [`Node`] using the [`FromWorld`] implementation
+    /// * Add it to the graph
+    fn add_render_graph_node<T: Node + FromWorld>(
+        &mut self,
+        sub_graph: impl RenderSubGraph,
+        node_label: impl RenderLabel,
+    ) -> &mut Self;
+    /// Automatically add the required node edges based on the given ordering
+    fn add_render_graph_edges<const N: usize>(
+        &mut self,
+        sub_graph: impl RenderSubGraph,
+        edges: impl IntoRenderNodeArray<N>,
+    ) -> &mut Self;
+
+    /// Add node edge to the specified graph
+    fn add_render_graph_edge(
+        &mut self,
+        sub_graph: impl RenderSubGraph,
+        output_node: impl RenderLabel,
+        input_node: impl RenderLabel,
+    ) -> &mut Self;
+}
+
+impl RenderGraphApp for SubApp {
+    fn add_render_graph_node<T: Node + FromWorld>(
+        &mut self,
+        sub_graph: impl RenderSubGraph,
+        node_label: impl RenderLabel,
+    ) -> &mut Self {
+        let sub_graph = sub_graph.intern();
+        let node = T::from_world(self.world_mut());
+        let mut render_graph = self.world_mut().get_resource_mut::<RenderGraph>().expect(
+            "RenderGraph not found. Make sure you are using add_render_graph_node on the RenderApp",
+        );
+        if let Some(graph) = render_graph.get_sub_graph_mut(sub_graph) {
+            graph.add_node(node_label, node);
+        } else {
+            warn!(
+                "Tried adding a render graph node to {sub_graph:?} but the sub graph doesn't exist"
+            );
+        }
+        self
+    }
+
+    fn add_render_graph_edges<const N: usize>(
+        &mut self,
+        sub_graph: impl RenderSubGraph,
+        edges: impl IntoRenderNodeArray<N>,
+    ) -> &mut Self {
+        let sub_graph = sub_graph.intern();
+        let mut render_graph = self.world_mut().get_resource_mut::<RenderGraph>().expect(
+            "RenderGraph not found. Make sure you are using add_render_graph_edges on the RenderApp",
+        );
+        if let Some(graph) = render_graph.get_sub_graph_mut(sub_graph) {
+            graph.add_node_edges(edges);
+        } else {
+            warn!(
+                "Tried adding render graph edges to {sub_graph:?} but the sub graph doesn't exist"
+            );
+        }
+        self
+    }
+
+    fn add_render_graph_edge(
+        &mut self,
+        sub_graph: impl RenderSubGraph,
+        output_node: impl RenderLabel,
+        input_node: impl RenderLabel,
+    ) -> &mut Self {
+        let sub_graph = sub_graph.intern();
+        let mut render_graph = self.world_mut().get_resource_mut::<RenderGraph>().expect(
+            "RenderGraph not found. Make sure you are using add_render_graph_edge on the RenderApp",
+        );
+        if let Some(graph) = render_graph.get_sub_graph_mut(sub_graph) {
+            graph.add_node_edge(output_node, input_node);
+        } else {
+            warn!(
+                "Tried adding a render graph edge to {sub_graph:?} but the sub graph doesn't exist"
+            );
+        }
+        self
+    }
+
+    fn add_render_sub_graph(&mut self, sub_graph: impl RenderSubGraph) -> &mut Self {
+        let mut render_graph = self.world_mut().get_resource_mut::<RenderGraph>().expect(
+            "RenderGraph not found. Make sure you are using add_render_sub_graph on the RenderApp",
+        );
+        render_graph.add_sub_graph(sub_graph, RenderGraph::default());
+        self
+    }
+}
+
+impl RenderGraphApp for App {
+    fn add_render_graph_node<T: Node + FromWorld>(
+        &mut self,
+        sub_graph: impl RenderSubGraph,
+        node_label: impl RenderLabel,
+    ) -> &mut Self {
+        SubApp::add_render_graph_node::<T>(self.main_mut(), sub_graph, node_label);
+        self
+    }
+
+    fn add_render_graph_edge(
+        &mut self,
+        sub_graph: impl RenderSubGraph,
+        output_node: impl RenderLabel,
+        input_node: impl RenderLabel,
+    ) -> &mut Self {
+        SubApp::add_render_graph_edge(self.main_mut(), sub_graph, output_node, input_node);
+        self
+    }
+
+    fn add_render_graph_edges<const N: usize>(
+        &mut self,
+        sub_graph: impl RenderSubGraph,
+        edges: impl IntoRenderNodeArray<N>,
+    ) -> &mut Self {
+        SubApp::add_render_graph_edges(self.main_mut(), sub_graph, edges);
+        self
+    }
+
+    fn add_render_sub_graph(&mut self, sub_graph: impl RenderSubGraph) -> &mut Self {
+        SubApp::add_render_sub_graph(self.main_mut(), sub_graph);
+        self
+    }
+}

vendor/bevy_render/src/render_graph/context.rs

@@ -0,0 +1,283 @@
+use crate::{
+    render_graph::{NodeState, RenderGraph, SlotInfos, SlotLabel, SlotType, SlotValue},
+    render_resource::{Buffer, Sampler, TextureView},
+};
+use alloc::borrow::Cow;
+use bevy_ecs::{entity::Entity, intern::Interned};
+use thiserror::Error;
+
+use super::{InternedRenderSubGraph, RenderLabel, RenderSubGraph};
+
+/// A command that signals the graph runner to run the sub graph corresponding to the `sub_graph`
+/// with the specified `inputs` next.
+pub struct RunSubGraph {
+    pub sub_graph: InternedRenderSubGraph,
+    pub inputs: Vec<SlotValue>,
+    pub view_entity: Option<Entity>,
+}
+
+/// The context with all graph information required to run a [`Node`](super::Node).
+/// This context is created for each node by the render graph runner.
+///
+/// The slot input can be read from here and the outputs must be written back to the context for
+/// passing them onto the next node.
+///
+/// Sub graphs can be queued for running by adding a [`RunSubGraph`] command to the context.
+/// After the node has finished running the graph runner is responsible for executing the sub graphs.
+pub struct RenderGraphContext<'a> {
+    graph: &'a RenderGraph,
+    node: &'a NodeState,
+    inputs: &'a [SlotValue],
+    outputs: &'a mut [Option<SlotValue>],
+    run_sub_graphs: Vec<RunSubGraph>,
+    /// The `view_entity` associated with the render graph being executed
+    /// This is optional because you aren't required to have a `view_entity` for a node.
+    /// For example, compute shader nodes don't have one.
+    /// It should always be set when the [`RenderGraph`] is running on a View.
+    view_entity: Option<Entity>,
+}
+
+impl<'a> RenderGraphContext<'a> {
+    /// Creates a new render graph context for the `node`.
+    pub fn new(
+        graph: &'a RenderGraph,
+        node: &'a NodeState,
+        inputs: &'a [SlotValue],
+        outputs: &'a mut [Option<SlotValue>],
+    ) -> Self {
+        Self {
+            graph,
+            node,
+            inputs,
+            outputs,
+            run_sub_graphs: Vec::new(),
+            view_entity: None,
+        }
+    }
+
+    /// Returns the input slot values for the node.
+    #[inline]
+    pub fn inputs(&self) -> &[SlotValue] {
+        self.inputs
+    }
+
+    /// Returns the [`SlotInfos`] of the inputs.
+    pub fn input_info(&self) -> &SlotInfos {
+        &self.node.input_slots
+    }
+
+    /// Returns the [`SlotInfos`] of the outputs.
+    pub fn output_info(&self) -> &SlotInfos {
+        &self.node.output_slots
+    }
+
+    /// Retrieves the input slot value referenced by the `label`.
+    pub fn get_input(&self, label: impl Into<SlotLabel>) -> Result<&SlotValue, InputSlotError> {
+        let label = label.into();
+        let index = self
+            .input_info()
+            .get_slot_index(label.clone())
+            .ok_or(InputSlotError::InvalidSlot(label))?;
+        Ok(&self.inputs[index])
+    }
+
+    // TODO: should this return an Arc or a reference?
+    /// Retrieves the input slot value referenced by the `label` as a [`TextureView`].
+    pub fn get_input_texture(
+        &self,
+        label: impl Into<SlotLabel>,
+    ) -> Result<&TextureView, InputSlotError> {
+        let label = label.into();
+        match self.get_input(label.clone())? {
+            SlotValue::TextureView(value) => Ok(value),
+            value => Err(InputSlotError::MismatchedSlotType {
+                label,
+                actual: value.slot_type(),
+                expected: SlotType::TextureView,
+            }),
+        }
+    }
+
+    /// Retrieves the input slot value referenced by the `label` as a [`Sampler`].
+    pub fn get_input_sampler(
+        &self,
+        label: impl Into<SlotLabel>,
+    ) -> Result<&Sampler, InputSlotError> {
+        let label = label.into();
+        match self.get_input(label.clone())? {
+            SlotValue::Sampler(value) => Ok(value),
+            value => Err(InputSlotError::MismatchedSlotType {
+                label,
+                actual: value.slot_type(),
+                expected: SlotType::Sampler,
+            }),
+        }
+    }
+
+    /// Retrieves the input slot value referenced by the `label` as a [`Buffer`].
+    pub fn get_input_buffer(&self, label: impl Into<SlotLabel>) -> Result<&Buffer, InputSlotError> {
+        let label = label.into();
+        match self.get_input(label.clone())? {
+            SlotValue::Buffer(value) => Ok(value),
+            value => Err(InputSlotError::MismatchedSlotType {
+                label,
+                actual: value.slot_type(),
+                expected: SlotType::Buffer,
+            }),
+        }
+    }
+
+    /// Retrieves the input slot value referenced by the `label` as an [`Entity`].
+    pub fn get_input_entity(&self, label: impl Into<SlotLabel>) -> Result<Entity, InputSlotError> {
+        let label = label.into();
+        match self.get_input(label.clone())? {
+            SlotValue::Entity(value) => Ok(*value),
+            value => Err(InputSlotError::MismatchedSlotType {
+                label,
+                actual: value.slot_type(),
+                expected: SlotType::Entity,
+            }),
+        }
+    }
+
+    /// Sets the output slot value referenced by the `label`.
+    pub fn set_output(
+        &mut self,
+        label: impl Into<SlotLabel>,
+        value: impl Into<SlotValue>,
+    ) -> Result<(), OutputSlotError> {
+        let label = label.into();
+        let value = value.into();
+        let slot_index = self
+            .output_info()
+            .get_slot_index(label.clone())
+            .ok_or_else(|| OutputSlotError::InvalidSlot(label.clone()))?;
+        let slot = self
+            .output_info()
+            .get_slot(slot_index)
+            .expect("slot is valid");
+        if value.slot_type() != slot.slot_type {
+            return Err(OutputSlotError::MismatchedSlotType {
+                label,
+                actual: slot.slot_type,
+                expected: value.slot_type(),
+            });
+        }
+        self.outputs[slot_index] = Some(value);
+        Ok(())
+    }
+
+    pub fn view_entity(&self) -> Entity {
+        self.view_entity.unwrap()
+    }
+
+    pub fn get_view_entity(&self) -> Option<Entity> {
+        self.view_entity
+    }
+
+    pub fn set_view_entity(&mut self, view_entity: Entity) {
+        self.view_entity = Some(view_entity);
+    }
+
+    /// Queues up a sub graph for execution after the node has finished running.
+    pub fn run_sub_graph(
+        &mut self,
+        name: impl RenderSubGraph,
+        inputs: Vec<SlotValue>,
+        view_entity: Option<Entity>,
+    ) -> Result<(), RunSubGraphError> {
+        let name = name.intern();
+        let sub_graph = self
+            .graph
+            .get_sub_graph(name)
+            .ok_or(RunSubGraphError::MissingSubGraph(name))?;
+        if let Some(input_node) = sub_graph.get_input_node() {
+            for (i, input_slot) in input_node.input_slots.iter().enumerate() {
+                if let Some(input_value) = inputs.get(i) {
+                    if input_slot.slot_type != input_value.slot_type() {
+                        return Err(RunSubGraphError::MismatchedInputSlotType {
+                            graph_name: name,
+                            slot_index: i,
+                            actual: input_value.slot_type(),
+                            expected: input_slot.slot_type,
+                            label: input_slot.name.clone().into(),
+                        });
+                    }
+                } else {
+                    return Err(RunSubGraphError::MissingInput {
+                        slot_index: i,
+                        slot_name: input_slot.name.clone(),
+                        graph_name: name,
+                    });
+                }
+            }
+        } else if !inputs.is_empty() {
+            return Err(RunSubGraphError::SubGraphHasNoInputs(name));
+        }
+
+        self.run_sub_graphs.push(RunSubGraph {
+            sub_graph: name,
+            inputs,
+            view_entity,
+        });
+
+        Ok(())
+    }
+
+    /// Returns a human-readable label for this node, for debugging purposes.
+    pub fn label(&self) -> Interned<dyn RenderLabel> {
+        self.node.label
+    }
+
+    /// Finishes the context for this [`Node`](super::Node) by
+    /// returning the sub graphs to run next.
+    pub fn finish(self) -> Vec<RunSubGraph> {
+        self.run_sub_graphs
+    }
+}
+
+#[derive(Error, Debug, Eq, PartialEq)]
+pub enum RunSubGraphError {
+    #[error("attempted to run sub-graph `{0:?}`, but it does not exist")]
+    MissingSubGraph(InternedRenderSubGraph),
+    #[error("attempted to pass inputs to sub-graph `{0:?}`, which has no input slots")]
+    SubGraphHasNoInputs(InternedRenderSubGraph),
+    #[error("sub graph (name: `{graph_name:?}`) could not be run because slot `{slot_name}` at index {slot_index} has no value")]
+    MissingInput {
+        slot_index: usize,
+        slot_name: Cow<'static, str>,
+        graph_name: InternedRenderSubGraph,
+    },
+    #[error("attempted to use the wrong type for input slot")]
+    MismatchedInputSlotType {
+        graph_name: InternedRenderSubGraph,
+        slot_index: usize,
+        label: SlotLabel,
+        expected: SlotType,
+        actual: SlotType,
+    },
+}
+
+#[derive(Error, Debug, Eq, PartialEq)]
+pub enum OutputSlotError {
+    #[error("output slot `{0:?}` does not exist")]
+    InvalidSlot(SlotLabel),
+    #[error("attempted to output a value of type `{actual}` to output slot `{label:?}`, which has type `{expected}`")]
+    MismatchedSlotType {
+        label: SlotLabel,
+        expected: SlotType,
+        actual: SlotType,
+    },
+}
+
+#[derive(Error, Debug, Eq, PartialEq)]
+pub enum InputSlotError {
+    #[error("input slot `{0:?}` does not exist")]
+    InvalidSlot(SlotLabel),
+    #[error("attempted to retrieve a value of type `{actual}` from input slot `{label:?}`, which has type `{expected}`")]
+    MismatchedSlotType {
+        label: SlotLabel,
+        expected: SlotType,
+        actual: SlotType,
+    },
+}

vendor/bevy_render/src/render_graph/edge.rs

@@ -0,0 +1,57 @@
+use super::InternedRenderLabel;
+
+/// An edge, which connects two [`Nodes`](super::Node) in
+/// a [`RenderGraph`](crate::render_graph::RenderGraph).
+///
+/// They are used to describe the ordering (which node has to run first)
+/// and may be of two kinds: [`NodeEdge`](Self::NodeEdge) and [`SlotEdge`](Self::SlotEdge).
+///
+/// Edges are added via the [`RenderGraph::add_node_edge`] and the
+/// [`RenderGraph::add_slot_edge`] methods.
+///
+/// The former simply states that the `output_node` has to be run before the `input_node`,
+/// while the later connects an output slot of the `output_node`
+/// with an input slot of the `input_node` to pass additional data along.
+/// For more information see [`SlotType`](super::SlotType).
+///
+/// [`RenderGraph::add_node_edge`]: crate::render_graph::RenderGraph::add_node_edge
+/// [`RenderGraph::add_slot_edge`]: crate::render_graph::RenderGraph::add_slot_edge
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub enum Edge {
+    /// An edge describing to ordering of both nodes (`output_node` before `input_node`)
+    /// and connecting the output slot at the `output_index` of the `output_node`
+    /// with the slot at the `input_index` of the `input_node`.
+    SlotEdge {
+        input_node: InternedRenderLabel,
+        input_index: usize,
+        output_node: InternedRenderLabel,
+        output_index: usize,
+    },
+    /// An edge describing to ordering of both nodes (`output_node` before `input_node`).
+    NodeEdge {
+        input_node: InternedRenderLabel,
+        output_node: InternedRenderLabel,
+    },
+}
+
+impl Edge {
+    /// Returns the id of the `input_node`.
+    pub fn get_input_node(&self) -> InternedRenderLabel {
+        match self {
+            Edge::SlotEdge { input_node, .. } | Edge::NodeEdge { input_node, .. } => *input_node,
+        }
+    }
+
+    /// Returns the id of the `output_node`.
+    pub fn get_output_node(&self) -> InternedRenderLabel {
+        match self {
+            Edge::SlotEdge { output_node, .. } | Edge::NodeEdge { output_node, .. } => *output_node,
+        }
+    }
+}
+
+#[derive(PartialEq, Eq)]
+pub enum EdgeExistence {
+    Exists,
+    DoesNotExist,
+}

vendor/bevy_render/src/render_graph/graph.rs

@@ -0,0 +1,920 @@
+use crate::{
+    render_graph::{
+        Edge, Node, NodeRunError, NodeState, RenderGraphContext, RenderGraphError, RenderLabel,
+        SlotInfo, SlotLabel,
+    },
+    renderer::RenderContext,
+};
+use bevy_ecs::{define_label, intern::Interned, prelude::World, resource::Resource};
+use bevy_platform::collections::HashMap;
+use core::fmt::Debug;
+
+use super::{EdgeExistence, InternedRenderLabel, IntoRenderNodeArray};
+
+pub use bevy_render_macros::RenderSubGraph;
+
+define_label!(
+    #[diagnostic::on_unimplemented(
+        note = "consider annotating `{Self}` with `#[derive(RenderSubGraph)]`"
+    )]
+    /// A strongly-typed class of labels used to identify a [`SubGraph`] in a render graph.
+    RenderSubGraph,
+    RENDER_SUB_GRAPH_INTERNER
+);
+
+/// A shorthand for `Interned<dyn RenderSubGraph>`.
+pub type InternedRenderSubGraph = Interned<dyn RenderSubGraph>;
+
+/// The render graph configures the modular and re-usable render logic.
+///
+/// It is a retained and stateless (nodes themselves may have their own internal state) structure,
+/// which can not be modified while it is executed by the graph runner.
+///
+/// The render graph runner is responsible for executing the entire graph each frame.
+/// It will execute each node in the graph in the correct order, based on the edges between the nodes.
+///
+/// It consists of three main components: [`Nodes`](Node), [`Edges`](Edge)
+/// and [`Slots`](super::SlotType).
+///
+/// Nodes are responsible for generating draw calls and operating on input and output slots.
+/// Edges specify the order of execution for nodes and connect input and output slots together.
+/// Slots describe the render resources created or used by the nodes.
+///
+/// Additionally a render graph can contain multiple sub graphs, which are run by the
+/// corresponding nodes. Every render graph can have its own optional input node.
+///
+/// ## Example
+/// Here is a simple render graph example with two nodes connected by a node edge.
+/// ```ignore
+/// # TODO: Remove when #10645 is fixed
+/// # use bevy_app::prelude::*;
+/// # use bevy_ecs::prelude::World;
+/// # use bevy_render::render_graph::{RenderGraph, RenderLabel, Node, RenderGraphContext, NodeRunError};
+/// # use bevy_render::renderer::RenderContext;
+/// #
+/// #[derive(RenderLabel)]
+/// enum Labels {
+///     A,
+///     B,
+/// }
+///
+/// # struct MyNode;
+/// #
+/// # impl Node for MyNode {
+/// #     fn run(&self, graph: &mut RenderGraphContext, render_context: &mut RenderContext, world: &World) -> Result<(), NodeRunError> {
+/// #         unimplemented!()
+/// #     }
+/// # }
+/// #
+/// let mut graph = RenderGraph::default();
+/// graph.add_node(Labels::A, MyNode);
+/// graph.add_node(Labels::B, MyNode);
+/// graph.add_node_edge(Labels::B, Labels::A);
+/// ```
+#[derive(Resource, Default)]
+pub struct RenderGraph {
+    nodes: HashMap<InternedRenderLabel, NodeState>,
+    sub_graphs: HashMap<InternedRenderSubGraph, RenderGraph>,
+}
+
+/// The label for the input node of a graph. Used to connect other nodes to it.
+#[derive(Debug, Hash, PartialEq, Eq, Clone, RenderLabel)]
+pub struct GraphInput;
+
+impl RenderGraph {
+    /// Updates all nodes and sub graphs of the render graph. Should be called before executing it.
+    pub fn update(&mut self, world: &mut World) {
+        for node in self.nodes.values_mut() {
+            node.node.update(world);
+        }
+
+        for sub_graph in self.sub_graphs.values_mut() {
+            sub_graph.update(world);
+        }
+    }
+
+    /// Creates an [`GraphInputNode`] with the specified slots if not already present.
+    pub fn set_input(&mut self, inputs: Vec<SlotInfo>) {
+        assert!(
+            matches!(
+                self.get_node_state(GraphInput),
+                Err(RenderGraphError::InvalidNode(_))
+            ),
+            "Graph already has an input node"
+        );
+
+        self.add_node(GraphInput, GraphInputNode { inputs });
+    }
+
+    /// Returns the [`NodeState`] of the input node of this graph.
+    ///
+    /// # See also
+    ///
+    /// - [`input_node`](Self::input_node) for an unchecked version.
+    #[inline]
+    pub fn get_input_node(&self) -> Option<&NodeState> {
+        self.get_node_state(GraphInput).ok()
+    }
+
+    /// Returns the [`NodeState`] of the input node of this graph.
+    ///
+    /// # Panics
+    ///
+    /// Panics if there is no input node set.
+    ///
+    /// # See also
+    ///
+    /// - [`get_input_node`](Self::get_input_node) for a version which returns an [`Option`] instead.
+    #[inline]
+    pub fn input_node(&self) -> &NodeState {
+        self.get_input_node().unwrap()
+    }
+
+    /// Adds the `node` with the `label` to the graph.
+    /// If the label is already present replaces it instead.
+    pub fn add_node<T>(&mut self, label: impl RenderLabel, node: T)
+    where
+        T: Node,
+    {
+        let label = label.intern();
+        let node_state = NodeState::new(label, node);
+        self.nodes.insert(label, node_state);
+    }
+
+    /// Add `node_edge`s based on the order of the given `edges` array.
+    ///
+    /// Defining an edge that already exists is not considered an error with this api.
+    /// It simply won't create a new edge.
+    pub fn add_node_edges<const N: usize>(&mut self, edges: impl IntoRenderNodeArray<N>) {
+        for window in edges.into_array().windows(2) {
+            let [a, b] = window else {
+                break;
+            };
+            if let Err(err) = self.try_add_node_edge(*a, *b) {
+                match err {
+                    // Already existing edges are very easy to produce with this api
+                    // and shouldn't cause a panic
+                    RenderGraphError::EdgeAlreadyExists(_) => {}
+                    _ => panic!("{err:?}"),
+                }
+            }
+        }
+    }
+
+    /// Removes the `node` with the `label` from the graph.
+    /// If the label does not exist, nothing happens.
+    pub fn remove_node(&mut self, label: impl RenderLabel) -> Result<(), RenderGraphError> {
+        let label = label.intern();
+        if let Some(node_state) = self.nodes.remove(&label) {
+            // Remove all edges from other nodes to this one. Note that as we're removing this
+            // node, we don't need to remove its input edges
+            for input_edge in node_state.edges.input_edges() {
+                match input_edge {
+                    Edge::SlotEdge { output_node, .. }
+                    | Edge::NodeEdge {
+                        input_node: _,
+                        output_node,
+                    } => {
+                        if let Ok(output_node) = self.get_node_state_mut(*output_node) {
+                            output_node.edges.remove_output_edge(input_edge.clone())?;
+                        }
+                    }
+                }
+            }
+            // Remove all edges from this node to other nodes. Note that as we're removing this
+            // node, we don't need to remove its output edges
+            for output_edge in node_state.edges.output_edges() {
+                match output_edge {
+                    Edge::SlotEdge {
+                        output_node: _,
+                        output_index: _,
+                        input_node,
+                        input_index: _,
+                    }
+                    | Edge::NodeEdge {
+                        output_node: _,
+                        input_node,
+                    } => {
+                        if let Ok(input_node) = self.get_node_state_mut(*input_node) {
+                            input_node.edges.remove_input_edge(output_edge.clone())?;
+                        }
+                    }
+                }
+            }
+        }
+
+        Ok(())
+    }
+
+    /// Retrieves the [`NodeState`] referenced by the `label`.
+    pub fn get_node_state(&self, label: impl RenderLabel) -> Result<&NodeState, RenderGraphError> {
+        let label = label.intern();
+        self.nodes
+            .get(&label)
+            .ok_or(RenderGraphError::InvalidNode(label))
+    }
+
+    /// Retrieves the [`NodeState`] referenced by the `label` mutably.
+    pub fn get_node_state_mut(
+        &mut self,
+        label: impl RenderLabel,
+    ) -> Result<&mut NodeState, RenderGraphError> {
+        let label = label.intern();
+        self.nodes
+            .get_mut(&label)
+            .ok_or(RenderGraphError::InvalidNode(label))
+    }
+
+    /// Retrieves the [`Node`] referenced by the `label`.
+    pub fn get_node<T>(&self, label: impl RenderLabel) -> Result<&T, RenderGraphError>
+    where
+        T: Node,
+    {
+        self.get_node_state(label).and_then(|n| n.node())
+    }
+
+    /// Retrieves the [`Node`] referenced by the `label` mutably.
+    pub fn get_node_mut<T>(&mut self, label: impl RenderLabel) -> Result<&mut T, RenderGraphError>
+    where
+        T: Node,
+    {
+        self.get_node_state_mut(label).and_then(|n| n.node_mut())
+    }
+
+    /// Adds the [`Edge::SlotEdge`] to the graph. This guarantees that the `output_node`
+    /// is run before the `input_node` and also connects the `output_slot` to the `input_slot`.
+    ///
+    /// Fails if any invalid [`RenderLabel`]s or [`SlotLabel`]s are given.
+    ///
+    /// # See also
+    ///
+    /// - [`add_slot_edge`](Self::add_slot_edge) for an infallible version.
+    pub fn try_add_slot_edge(
+        &mut self,
+        output_node: impl RenderLabel,
+        output_slot: impl Into<SlotLabel>,
+        input_node: impl RenderLabel,
+        input_slot: impl Into<SlotLabel>,
+    ) -> Result<(), RenderGraphError> {
+        let output_slot = output_slot.into();
+        let input_slot = input_slot.into();
+
+        let output_node = output_node.intern();
+        let input_node = input_node.intern();
+
+        let output_index = self
+            .get_node_state(output_node)?
+            .output_slots
+            .get_slot_index(output_slot.clone())
+            .ok_or(RenderGraphError::InvalidOutputNodeSlot(output_slot))?;
+        let input_index = self
+            .get_node_state(input_node)?
+            .input_slots
+            .get_slot_index(input_slot.clone())
+            .ok_or(RenderGraphError::InvalidInputNodeSlot(input_slot))?;
+
+        let edge = Edge::SlotEdge {
+            output_node,
+            output_index,
+            input_node,
+            input_index,
+        };
+
+        self.validate_edge(&edge, EdgeExistence::DoesNotExist)?;
+
+        {
+            let output_node = self.get_node_state_mut(output_node)?;
+            output_node.edges.add_output_edge(edge.clone())?;
+        }
+        let input_node = self.get_node_state_mut(input_node)?;
+        input_node.edges.add_input_edge(edge)?;
+
+        Ok(())
+    }
+
+    /// Adds the [`Edge::SlotEdge`] to the graph. This guarantees that the `output_node`
+    /// is run before the `input_node` and also connects the `output_slot` to the `input_slot`.
+    ///
+    /// # Panics
+    ///
+    /// Any invalid [`RenderLabel`]s or [`SlotLabel`]s are given.
+    ///
+    /// # See also
+    ///
+    /// - [`try_add_slot_edge`](Self::try_add_slot_edge) for a fallible version.
+    pub fn add_slot_edge(
+        &mut self,
+        output_node: impl RenderLabel,
+        output_slot: impl Into<SlotLabel>,
+        input_node: impl RenderLabel,
+        input_slot: impl Into<SlotLabel>,
+    ) {
+        self.try_add_slot_edge(output_node, output_slot, input_node, input_slot)
+            .unwrap();
+    }
+
+    /// Removes the [`Edge::SlotEdge`] from the graph. If any nodes or slots do not exist then
+    /// nothing happens.
+    pub fn remove_slot_edge(
+        &mut self,
+        output_node: impl RenderLabel,
+        output_slot: impl Into<SlotLabel>,
+        input_node: impl RenderLabel,
+        input_slot: impl Into<SlotLabel>,
+    ) -> Result<(), RenderGraphError> {
+        let output_slot = output_slot.into();
+        let input_slot = input_slot.into();
+
+        let output_node = output_node.intern();
+        let input_node = input_node.intern();
+
+        let output_index = self
+            .get_node_state(output_node)?
+            .output_slots
+            .get_slot_index(output_slot.clone())
+            .ok_or(RenderGraphError::InvalidOutputNodeSlot(output_slot))?;
+        let input_index = self
+            .get_node_state(input_node)?
+            .input_slots
+            .get_slot_index(input_slot.clone())
+            .ok_or(RenderGraphError::InvalidInputNodeSlot(input_slot))?;
+
+        let edge = Edge::SlotEdge {
+            output_node,
+            output_index,
+            input_node,
+            input_index,
+        };
+
+        self.validate_edge(&edge, EdgeExistence::Exists)?;
+
+        {
+            let output_node = self.get_node_state_mut(output_node)?;
+            output_node.edges.remove_output_edge(edge.clone())?;
+        }
+        let input_node = self.get_node_state_mut(input_node)?;
+        input_node.edges.remove_input_edge(edge)?;
+
+        Ok(())
+    }
+
+    /// Adds the [`Edge::NodeEdge`] to the graph. This guarantees that the `output_node`
+    /// is run before the `input_node`.
+    ///
+    /// Fails if any invalid [`RenderLabel`] is given.
+    ///
+    /// # See also
+    ///
+    /// - [`add_node_edge`](Self::add_node_edge) for an infallible version.
+    pub fn try_add_node_edge(
+        &mut self,
+        output_node: impl RenderLabel,
+        input_node: impl RenderLabel,
+    ) -> Result<(), RenderGraphError> {
+        let output_node = output_node.intern();
+        let input_node = input_node.intern();
+
+        let edge = Edge::NodeEdge {
+            output_node,
+            input_node,
+        };
+
+        self.validate_edge(&edge, EdgeExistence::DoesNotExist)?;
+
+        {
+            let output_node = self.get_node_state_mut(output_node)?;
+            output_node.edges.add_output_edge(edge.clone())?;
+        }
+        let input_node = self.get_node_state_mut(input_node)?;
+        input_node.edges.add_input_edge(edge)?;
+
+        Ok(())
+    }
+
+    /// Adds the [`Edge::NodeEdge`] to the graph. This guarantees that the `output_node`
+    /// is run before the `input_node`.
+    ///
+    /// # Panics
+    ///
+    /// Panics if any invalid [`RenderLabel`] is given.
+    ///
+    /// # See also
+    ///
+    /// - [`try_add_node_edge`](Self::try_add_node_edge) for a fallible version.
+    pub fn add_node_edge(&mut self, output_node: impl RenderLabel, input_node: impl RenderLabel) {
+        self.try_add_node_edge(output_node, input_node).unwrap();
+    }
+
+    /// Removes the [`Edge::NodeEdge`] from the graph. If either node does not exist then nothing
+    /// happens.
+    pub fn remove_node_edge(
+        &mut self,
+        output_node: impl RenderLabel,
+        input_node: impl RenderLabel,
+    ) -> Result<(), RenderGraphError> {
+        let output_node = output_node.intern();
+        let input_node = input_node.intern();
+
+        let edge = Edge::NodeEdge {
+            output_node,
+            input_node,
+        };
+
+        self.validate_edge(&edge, EdgeExistence::Exists)?;
+
+        {
+            let output_node = self.get_node_state_mut(output_node)?;
+            output_node.edges.remove_output_edge(edge.clone())?;
+        }
+        let input_node = self.get_node_state_mut(input_node)?;
+        input_node.edges.remove_input_edge(edge)?;
+
+        Ok(())
+    }
+
+    /// Verifies that the edge existence is as expected and
+    /// checks that slot edges are connected correctly.
+    pub fn validate_edge(
+        &mut self,
+        edge: &Edge,
+        should_exist: EdgeExistence,
+    ) -> Result<(), RenderGraphError> {
+        if should_exist == EdgeExistence::Exists && !self.has_edge(edge) {
+            return Err(RenderGraphError::EdgeDoesNotExist(edge.clone()));
+        } else if should_exist == EdgeExistence::DoesNotExist && self.has_edge(edge) {
+            return Err(RenderGraphError::EdgeAlreadyExists(edge.clone()));
+        }
+
+        match *edge {
+            Edge::SlotEdge {
+                output_node,
+                output_index,
+                input_node,
+                input_index,
+            } => {
+                let output_node_state = self.get_node_state(output_node)?;
+                let input_node_state = self.get_node_state(input_node)?;
+
+                let output_slot = output_node_state
+                    .output_slots
+                    .get_slot(output_index)
+                    .ok_or(RenderGraphError::InvalidOutputNodeSlot(SlotLabel::Index(
+                        output_index,
+                    )))?;
+                let input_slot = input_node_state.input_slots.get_slot(input_index).ok_or(
+                    RenderGraphError::InvalidInputNodeSlot(SlotLabel::Index(input_index)),
+                )?;
+
+                if let Some(Edge::SlotEdge {
+                    output_node: current_output_node,
+                    ..
+                }) = input_node_state.edges.input_edges().iter().find(|e| {
+                    if let Edge::SlotEdge {
+                        input_index: current_input_index,
+                        ..
+                    } = e
+                    {
+                        input_index == *current_input_index
+                    } else {
+                        false
+                    }
+                }) {
+                    if should_exist == EdgeExistence::DoesNotExist {
+                        return Err(RenderGraphError::NodeInputSlotAlreadyOccupied {
+                            node: input_node,
+                            input_slot: input_index,
+                            occupied_by_node: *current_output_node,
+                        });
+                    }
+                }
+
+                if output_slot.slot_type != input_slot.slot_type {
+                    return Err(RenderGraphError::MismatchedNodeSlots {
+                        output_node,
+                        output_slot: output_index,
+                        input_node,
+                        input_slot: input_index,
+                    });
+                }
+            }
+            Edge::NodeEdge { .. } => { /* nothing to validate here */ }
+        }
+
+        Ok(())
+    }
+
+    /// Checks whether the `edge` already exists in the graph.
+    pub fn has_edge(&self, edge: &Edge) -> bool {
+        let output_node_state = self.get_node_state(edge.get_output_node());
+        let input_node_state = self.get_node_state(edge.get_input_node());
+        if let Ok(output_node_state) = output_node_state {
+            if output_node_state.edges.output_edges().contains(edge) {
+                if let Ok(input_node_state) = input_node_state {
+                    if input_node_state.edges.input_edges().contains(edge) {
+                        return true;
+                    }
+                }
+            }
+        }
+
+        false
+    }
+
+    /// Returns an iterator over the [`NodeStates`](NodeState).
+    pub fn iter_nodes(&self) -> impl Iterator<Item = &NodeState> {
+        self.nodes.values()
+    }
+
+    /// Returns an iterator over the [`NodeStates`](NodeState), that allows modifying each value.
+    pub fn iter_nodes_mut(&mut self) -> impl Iterator<Item = &mut NodeState> {
+        self.nodes.values_mut()
+    }
+
+    /// Returns an iterator over the sub graphs.
+    pub fn iter_sub_graphs(&self) -> impl Iterator<Item = (InternedRenderSubGraph, &RenderGraph)> {
+        self.sub_graphs.iter().map(|(name, graph)| (*name, graph))
+    }
+
+    /// Returns an iterator over the sub graphs, that allows modifying each value.
+    pub fn iter_sub_graphs_mut(
+        &mut self,
+    ) -> impl Iterator<Item = (InternedRenderSubGraph, &mut RenderGraph)> {
+        self.sub_graphs
+            .iter_mut()
+            .map(|(name, graph)| (*name, graph))
+    }
+
+    /// Returns an iterator over a tuple of the input edges and the corresponding output nodes
+    /// for the node referenced by the label.
+    pub fn iter_node_inputs(
+        &self,
+        label: impl RenderLabel,
+    ) -> Result<impl Iterator<Item = (&Edge, &NodeState)>, RenderGraphError> {
+        let node = self.get_node_state(label)?;
+        Ok(node
+            .edges
+            .input_edges()
+            .iter()
+            .map(|edge| (edge, edge.get_output_node()))
+            .map(move |(edge, output_node)| (edge, self.get_node_state(output_node).unwrap())))
+    }
+
+    /// Returns an iterator over a tuple of the output edges and the corresponding input nodes
+    /// for the node referenced by the label.
+    pub fn iter_node_outputs(
+        &self,
+        label: impl RenderLabel,
+    ) -> Result<impl Iterator<Item = (&Edge, &NodeState)>, RenderGraphError> {
+        let node = self.get_node_state(label)?;
+        Ok(node
+            .edges
+            .output_edges()
+            .iter()
+            .map(|edge| (edge, edge.get_input_node()))
+            .map(move |(edge, input_node)| (edge, self.get_node_state(input_node).unwrap())))
+    }
+
+    /// Adds the `sub_graph` with the `label` to the graph.
+    /// If the label is already present replaces it instead.
+    pub fn add_sub_graph(&mut self, label: impl RenderSubGraph, sub_graph: RenderGraph) {
+        self.sub_graphs.insert(label.intern(), sub_graph);
+    }
+
+    /// Removes the `sub_graph` with the `label` from the graph.
+    /// If the label does not exist then nothing happens.
+    pub fn remove_sub_graph(&mut self, label: impl RenderSubGraph) {
+        self.sub_graphs.remove(&label.intern());
+    }
+
+    /// Retrieves the sub graph corresponding to the `label`.
+    pub fn get_sub_graph(&self, label: impl RenderSubGraph) -> Option<&RenderGraph> {
+        self.sub_graphs.get(&label.intern())
+    }
+
+    /// Retrieves the sub graph corresponding to the `label` mutably.
+    pub fn get_sub_graph_mut(&mut self, label: impl RenderSubGraph) -> Option<&mut RenderGraph> {
+        self.sub_graphs.get_mut(&label.intern())
+    }
+
+    /// Retrieves the sub graph corresponding to the `label`.
+    ///
+    /// # Panics
+    ///
+    /// Panics if any invalid subgraph label is given.
+    ///
+    /// # See also
+    ///
+    /// - [`get_sub_graph`](Self::get_sub_graph) for a fallible version.
+    pub fn sub_graph(&self, label: impl RenderSubGraph) -> &RenderGraph {
+        let label = label.intern();
+        self.sub_graphs
+            .get(&label)
+            .unwrap_or_else(|| panic!("Subgraph {label:?} not found"))
+    }
+
+    /// Retrieves the sub graph corresponding to the `label` mutably.
+    ///
+    /// # Panics
+    ///
+    /// Panics if any invalid subgraph label is given.
+    ///
+    /// # See also
+    ///
+    /// - [`get_sub_graph_mut`](Self::get_sub_graph_mut) for a fallible version.
+    pub fn sub_graph_mut(&mut self, label: impl RenderSubGraph) -> &mut RenderGraph {
+        let label = label.intern();
+        self.sub_graphs
+            .get_mut(&label)
+            .unwrap_or_else(|| panic!("Subgraph {label:?} not found"))
+    }
+}
+
+impl Debug for RenderGraph {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        for node in self.iter_nodes() {
+            writeln!(f, "{:?}", node.label)?;
+            writeln!(f, "  in: {:?}", node.input_slots)?;
+            writeln!(f, "  out: {:?}", node.output_slots)?;
+        }
+
+        Ok(())
+    }
+}
+
+/// A [`Node`] which acts as an entry point for a [`RenderGraph`] with custom inputs.
+/// It has the same input and output slots and simply copies them over when run.
+pub struct GraphInputNode {
+    inputs: Vec<SlotInfo>,
+}
+
+impl Node for GraphInputNode {
+    fn input(&self) -> Vec<SlotInfo> {
+        self.inputs.clone()
+    }
+
+    fn output(&self) -> Vec<SlotInfo> {
+        self.inputs.clone()
+    }
+
+    fn run(
+        &self,
+        graph: &mut RenderGraphContext,
+        _render_context: &mut RenderContext,
+        _world: &World,
+    ) -> Result<(), NodeRunError> {
+        for i in 0..graph.inputs().len() {
+            let input = graph.inputs()[i].clone();
+            graph.set_output(i, input)?;
+        }
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::{
+        render_graph::{
+            node::IntoRenderNodeArray, Edge, InternedRenderLabel, Node, NodeRunError, RenderGraph,
+            RenderGraphContext, RenderGraphError, RenderLabel, SlotInfo, SlotType,
+        },
+        renderer::RenderContext,
+    };
+    use bevy_ecs::world::{FromWorld, World};
+    use bevy_platform::collections::HashSet;
+
+    #[derive(Debug, Hash, PartialEq, Eq, Clone, RenderLabel)]
+    enum TestLabel {
+        A,
+        B,
+        C,
+        D,
+    }
+
+    #[derive(Debug)]
+    struct TestNode {
+        inputs: Vec<SlotInfo>,
+        outputs: Vec<SlotInfo>,
+    }
+
+    impl TestNode {
+        pub fn new(inputs: usize, outputs: usize) -> Self {
+            TestNode {
+                inputs: (0..inputs)
+                    .map(|i| SlotInfo::new(format!("in_{i}"), SlotType::TextureView))
+                    .collect(),
+                outputs: (0..outputs)
+                    .map(|i| SlotInfo::new(format!("out_{i}"), SlotType::TextureView))
+                    .collect(),
+            }
+        }
+    }
+
+    impl Node for TestNode {
+        fn input(&self) -> Vec<SlotInfo> {
+            self.inputs.clone()
+        }
+
+        fn output(&self) -> Vec<SlotInfo> {
+            self.outputs.clone()
+        }
+
+        fn run(
+            &self,
+            _: &mut RenderGraphContext,
+            _: &mut RenderContext,
+            _: &World,
+        ) -> Result<(), NodeRunError> {
+            Ok(())
+        }
+    }
+
+    fn input_nodes(label: impl RenderLabel, graph: &RenderGraph) -> HashSet<InternedRenderLabel> {
+        graph
+            .iter_node_inputs(label)
+            .unwrap()
+            .map(|(_edge, node)| node.label)
+            .collect::<HashSet<InternedRenderLabel>>()
+    }
+
+    fn output_nodes(label: impl RenderLabel, graph: &RenderGraph) -> HashSet<InternedRenderLabel> {
+        graph
+            .iter_node_outputs(label)
+            .unwrap()
+            .map(|(_edge, node)| node.label)
+            .collect::<HashSet<InternedRenderLabel>>()
+    }
+
+    #[test]
+    fn test_graph_edges() {
+        let mut graph = RenderGraph::default();
+        graph.add_node(TestLabel::A, TestNode::new(0, 1));
+        graph.add_node(TestLabel::B, TestNode::new(0, 1));
+        graph.add_node(TestLabel::C, TestNode::new(1, 1));
+        graph.add_node(TestLabel::D, TestNode::new(1, 0));
+
+        graph.add_slot_edge(TestLabel::A, "out_0", TestLabel::C, "in_0");
+        graph.add_node_edge(TestLabel::B, TestLabel::C);
+        graph.add_slot_edge(TestLabel::C, 0, TestLabel::D, 0);
+
+        assert!(
+            input_nodes(TestLabel::A, &graph).is_empty(),
+            "A has no inputs"
+        );
+        assert_eq!(
+            output_nodes(TestLabel::A, &graph),
+            HashSet::from_iter((TestLabel::C,).into_array()),
+            "A outputs to C"
+        );
+
+        assert!(
+            input_nodes(TestLabel::B, &graph).is_empty(),
+            "B has no inputs"
+        );
+        assert_eq!(
+            output_nodes(TestLabel::B, &graph),
+            HashSet::from_iter((TestLabel::C,).into_array()),
+            "B outputs to C"
+        );
+
+        assert_eq!(
+            input_nodes(TestLabel::C, &graph),
+            HashSet::from_iter((TestLabel::A, TestLabel::B).into_array()),
+            "A and B input to C"
+        );
+        assert_eq!(
+            output_nodes(TestLabel::C, &graph),
+            HashSet::from_iter((TestLabel::D,).into_array()),
+            "C outputs to D"
+        );
+
+        assert_eq!(
+            input_nodes(TestLabel::D, &graph),
+            HashSet::from_iter((TestLabel::C,).into_array()),
+            "C inputs to D"
+        );
+        assert!(
+            output_nodes(TestLabel::D, &graph).is_empty(),
+            "D has no outputs"
+        );
+    }
+
+    #[test]
+    fn test_get_node_typed() {
+        struct MyNode {
+            value: usize,
+        }
+
+        impl Node for MyNode {
+            fn run(
+                &self,
+                _: &mut RenderGraphContext,
+                _: &mut RenderContext,
+                _: &World,
+            ) -> Result<(), NodeRunError> {
+                Ok(())
+            }
+        }
+
+        let mut graph = RenderGraph::default();
+
+        graph.add_node(TestLabel::A, MyNode { value: 42 });
+
+        let node: &MyNode = graph.get_node(TestLabel::A).unwrap();
+        assert_eq!(node.value, 42, "node value matches");
+
+        let result: Result<&TestNode, RenderGraphError> = graph.get_node(TestLabel::A);
+        assert_eq!(
+            result.unwrap_err(),
+            RenderGraphError::WrongNodeType,
+            "expect a wrong node type error"
+        );
+    }
+
+    #[test]
+    fn test_slot_already_occupied() {
+        let mut graph = RenderGraph::default();
+
+        graph.add_node(TestLabel::A, TestNode::new(0, 1));
+        graph.add_node(TestLabel::B, TestNode::new(0, 1));
+        graph.add_node(TestLabel::C, TestNode::new(1, 1));
+
+        graph.add_slot_edge(TestLabel::A, 0, TestLabel::C, 0);
+        assert_eq!(
+            graph.try_add_slot_edge(TestLabel::B, 0, TestLabel::C, 0),
+            Err(RenderGraphError::NodeInputSlotAlreadyOccupied {
+                node: TestLabel::C.intern(),
+                input_slot: 0,
+                occupied_by_node: TestLabel::A.intern(),
+            }),
+            "Adding to a slot that is already occupied should return an error"
+        );
+    }
+
+    #[test]
+    fn test_edge_already_exists() {
+        let mut graph = RenderGraph::default();
+
+        graph.add_node(TestLabel::A, TestNode::new(0, 1));
+        graph.add_node(TestLabel::B, TestNode::new(1, 0));
+
+        graph.add_slot_edge(TestLabel::A, 0, TestLabel::B, 0);
+        assert_eq!(
+            graph.try_add_slot_edge(TestLabel::A, 0, TestLabel::B, 0),
+            Err(RenderGraphError::EdgeAlreadyExists(Edge::SlotEdge {
+                output_node: TestLabel::A.intern(),
+                output_index: 0,
+                input_node: TestLabel::B.intern(),
+                input_index: 0,
+            })),
+            "Adding to a duplicate edge should return an error"
+        );
+    }
+
+    #[test]
+    fn test_add_node_edges() {
+        struct SimpleNode;
+        impl Node for SimpleNode {
+            fn run(
+                &self,
+                _graph: &mut RenderGraphContext,
+                _render_context: &mut RenderContext,
+                _world: &World,
+            ) -> Result<(), NodeRunError> {
+                Ok(())
+            }
+        }
+        impl FromWorld for SimpleNode {
+            fn from_world(_world: &mut World) -> Self {
+                Self
+            }
+        }
+
+        let mut graph = RenderGraph::default();
+        graph.add_node(TestLabel::A, SimpleNode);
+        graph.add_node(TestLabel::B, SimpleNode);
+        graph.add_node(TestLabel::C, SimpleNode);
+
+        graph.add_node_edges((TestLabel::A, TestLabel::B, TestLabel::C));
+
+        assert_eq!(
+            output_nodes(TestLabel::A, &graph),
+            HashSet::from_iter((TestLabel::B,).into_array()),
+            "A -> B"
+        );
+        assert_eq!(
+            input_nodes(TestLabel::B, &graph),
+            HashSet::from_iter((TestLabel::A,).into_array()),
+            "A -> B"
+        );
+        assert_eq!(
+            output_nodes(TestLabel::B, &graph),
+            HashSet::from_iter((TestLabel::C,).into_array()),
+            "B -> C"
+        );
+        assert_eq!(
+            input_nodes(TestLabel::C, &graph),
+            HashSet::from_iter((TestLabel::B,).into_array()),
+            "B -> C"
+        );
+    }
+}

vendor/bevy_render/src/render_graph/mod.rs

@@ -0,0 +1,54 @@
+mod app;
+mod context;
+mod edge;
+mod graph;
+mod node;
+mod node_slot;
+
+pub use app::*;
+pub use context::*;
+pub use edge::*;
+pub use graph::*;
+pub use node::*;
+pub use node_slot::*;
+
+use thiserror::Error;
+
+#[derive(Error, Debug, Eq, PartialEq)]
+pub enum RenderGraphError {
+    #[error("node {0:?} does not exist")]
+    InvalidNode(InternedRenderLabel),
+    #[error("output node slot does not exist")]
+    InvalidOutputNodeSlot(SlotLabel),
+    #[error("input node slot does not exist")]
+    InvalidInputNodeSlot(SlotLabel),
+    #[error("node does not match the given type")]
+    WrongNodeType,
+    #[error("attempted to connect output slot {output_slot} from node {output_node:?} to incompatible input slot {input_slot} from node {input_node:?}")]
+    MismatchedNodeSlots {
+        output_node: InternedRenderLabel,
+        output_slot: usize,
+        input_node: InternedRenderLabel,
+        input_slot: usize,
+    },
+    #[error("attempted to add an edge that already exists")]
+    EdgeAlreadyExists(Edge),
+    #[error("attempted to remove an edge that does not exist")]
+    EdgeDoesNotExist(Edge),
+    #[error("node {node:?} has an unconnected input slot {input_slot}")]
+    UnconnectedNodeInputSlot {
+        node: InternedRenderLabel,
+        input_slot: usize,
+    },
+    #[error("node {node:?} has an unconnected output slot {output_slot}")]
+    UnconnectedNodeOutputSlot {
+        node: InternedRenderLabel,
+        output_slot: usize,
+    },
+    #[error("node {node:?} input slot {input_slot} already occupied by {occupied_by_node:?}")]
+    NodeInputSlotAlreadyOccupied {
+        node: InternedRenderLabel,
+        input_slot: usize,
+        occupied_by_node: InternedRenderLabel,
+    },
+}

vendor/bevy_render/src/render_graph/node.rs

@@ -0,0 +1,420 @@
+use crate::{
+    render_graph::{
+        Edge, InputSlotError, OutputSlotError, RenderGraphContext, RenderGraphError,
+        RunSubGraphError, SlotInfo, SlotInfos,
+    },
+    render_phase::DrawError,
+    renderer::RenderContext,
+};
+pub use bevy_ecs::label::DynEq;
+use bevy_ecs::{
+    define_label,
+    intern::Interned,
+    query::{QueryItem, QueryState, ReadOnlyQueryData},
+    world::{FromWorld, World},
+};
+use core::fmt::Debug;
+use downcast_rs::{impl_downcast, Downcast};
+use thiserror::Error;
+use variadics_please::all_tuples_with_size;
+
+pub use bevy_render_macros::RenderLabel;
+
+use super::{InternedRenderSubGraph, RenderSubGraph};
+
+define_label!(
+    #[diagnostic::on_unimplemented(
+        note = "consider annotating `{Self}` with `#[derive(RenderLabel)]`"
+    )]
+    /// A strongly-typed class of labels used to identify a [`Node`] in a render graph.
+    RenderLabel,
+    RENDER_LABEL_INTERNER
+);
+
+/// A shorthand for `Interned<dyn RenderLabel>`.
+pub type InternedRenderLabel = Interned<dyn RenderLabel>;
+
+pub trait IntoRenderNodeArray<const N: usize> {
+    fn into_array(self) -> [InternedRenderLabel; N];
+}
+
+macro_rules! impl_render_label_tuples {
+    ($N: expr, $(#[$meta:meta])* $(($T: ident, $I: ident)),*) => {
+        $(#[$meta])*
+        impl<$($T: RenderLabel),*> IntoRenderNodeArray<$N> for ($($T,)*) {
+            #[inline]
+            fn into_array(self) -> [InternedRenderLabel; $N] {
+                let ($($I,)*) = self;
+                [$($I.intern(), )*]
+            }
+        }
+    }
+}
+
+all_tuples_with_size!(
+    #[doc(fake_variadic)]
+    impl_render_label_tuples,
+    1,
+    32,
+    T,
+    l
+);
+
+/// A render node that can be added to a [`RenderGraph`](super::RenderGraph).
+///
+/// Nodes are the fundamental part of the graph and used to extend its functionality, by
+/// generating draw calls and/or running subgraphs.
+/// They are added via the `render_graph::add_node(my_node)` method.
+///
+/// To determine their position in the graph and ensure that all required dependencies (inputs)
+/// are already executed, [`Edges`](Edge) are used.
+///
+/// A node can produce outputs used as dependencies by other nodes.
+/// Those inputs and outputs are called slots and are the default way of passing render data
+/// inside the graph. For more information see [`SlotType`](super::SlotType).
+pub trait Node: Downcast + Send + Sync + 'static {
+    /// Specifies the required input slots for this node.
+    /// They will then be available during the run method inside the [`RenderGraphContext`].
+    fn input(&self) -> Vec<SlotInfo> {
+        Vec::new()
+    }
+
+    /// Specifies the produced output slots for this node.
+    /// They can then be passed one inside [`RenderGraphContext`] during the run method.
+    fn output(&self) -> Vec<SlotInfo> {
+        Vec::new()
+    }
+
+    /// Updates internal node state using the current render [`World`] prior to the run method.
+    fn update(&mut self, _world: &mut World) {}
+
+    /// Runs the graph node logic, issues draw calls, updates the output slots and
+    /// optionally queues up subgraphs for execution. The graph data, input and output values are
+    /// passed via the [`RenderGraphContext`].
+    fn run<'w>(
+        &self,
+        graph: &mut RenderGraphContext,
+        render_context: &mut RenderContext<'w>,
+        world: &'w World,
+    ) -> Result<(), NodeRunError>;
+}
+
+impl_downcast!(Node);
+
+#[derive(Error, Debug, Eq, PartialEq)]
+pub enum NodeRunError {
+    #[error("encountered an input slot error")]
+    InputSlotError(#[from] InputSlotError),
+    #[error("encountered an output slot error")]
+    OutputSlotError(#[from] OutputSlotError),
+    #[error("encountered an error when running a sub-graph")]
+    RunSubGraphError(#[from] RunSubGraphError),
+    #[error("encountered an error when executing draw command")]
+    DrawError(#[from] DrawError),
+}
+
+/// A collection of input and output [`Edges`](Edge) for a [`Node`].
+#[derive(Debug)]
+pub struct Edges {
+    label: InternedRenderLabel,
+    input_edges: Vec<Edge>,
+    output_edges: Vec<Edge>,
+}
+
+impl Edges {
+    /// Returns all "input edges" (edges going "in") for this node .
+    #[inline]
+    pub fn input_edges(&self) -> &[Edge] {
+        &self.input_edges
+    }
+
+    /// Returns all "output edges" (edges going "out") for this node .
+    #[inline]
+    pub fn output_edges(&self) -> &[Edge] {
+        &self.output_edges
+    }
+
+    /// Returns this node's label.
+    #[inline]
+    pub fn label(&self) -> InternedRenderLabel {
+        self.label
+    }
+
+    /// Adds an edge to the `input_edges` if it does not already exist.
+    pub(crate) fn add_input_edge(&mut self, edge: Edge) -> Result<(), RenderGraphError> {
+        if self.has_input_edge(&edge) {
+            return Err(RenderGraphError::EdgeAlreadyExists(edge));
+        }
+        self.input_edges.push(edge);
+        Ok(())
+    }
+
+    /// Removes an edge from the `input_edges` if it exists.
+    pub(crate) fn remove_input_edge(&mut self, edge: Edge) -> Result<(), RenderGraphError> {
+        if let Some(index) = self.input_edges.iter().position(|e| *e == edge) {
+            self.input_edges.swap_remove(index);
+            Ok(())
+        } else {
+            Err(RenderGraphError::EdgeDoesNotExist(edge))
+        }
+    }
+
+    /// Adds an edge to the `output_edges` if it does not already exist.
+    pub(crate) fn add_output_edge(&mut self, edge: Edge) -> Result<(), RenderGraphError> {
+        if self.has_output_edge(&edge) {
+            return Err(RenderGraphError::EdgeAlreadyExists(edge));
+        }
+        self.output_edges.push(edge);
+        Ok(())
+    }
+
+    /// Removes an edge from the `output_edges` if it exists.
+    pub(crate) fn remove_output_edge(&mut self, edge: Edge) -> Result<(), RenderGraphError> {
+        if let Some(index) = self.output_edges.iter().position(|e| *e == edge) {
+            self.output_edges.swap_remove(index);
+            Ok(())
+        } else {
+            Err(RenderGraphError::EdgeDoesNotExist(edge))
+        }
+    }
+
+    /// Checks whether the input edge already exists.
+    pub fn has_input_edge(&self, edge: &Edge) -> bool {
+        self.input_edges.contains(edge)
+    }
+
+    /// Checks whether the output edge already exists.
+    pub fn has_output_edge(&self, edge: &Edge) -> bool {
+        self.output_edges.contains(edge)
+    }
+
+    /// Searches the `input_edges` for a [`Edge::SlotEdge`],
+    /// which `input_index` matches the `index`;
+    pub fn get_input_slot_edge(&self, index: usize) -> Result<&Edge, RenderGraphError> {
+        self.input_edges
+            .iter()
+            .find(|e| {
+                if let Edge::SlotEdge { input_index, .. } = e {
+                    *input_index == index
+                } else {
+                    false
+                }
+            })
+            .ok_or(RenderGraphError::UnconnectedNodeInputSlot {
+                input_slot: index,
+                node: self.label,
+            })
+    }
+
+    /// Searches the `output_edges` for a [`Edge::SlotEdge`],
+    /// which `output_index` matches the `index`;
+    pub fn get_output_slot_edge(&self, index: usize) -> Result<&Edge, RenderGraphError> {
+        self.output_edges
+            .iter()
+            .find(|e| {
+                if let Edge::SlotEdge { output_index, .. } = e {
+                    *output_index == index
+                } else {
+                    false
+                }
+            })
+            .ok_or(RenderGraphError::UnconnectedNodeOutputSlot {
+                output_slot: index,
+                node: self.label,
+            })
+    }
+}
+
+/// The internal representation of a [`Node`], with all data required
+/// by the [`RenderGraph`](super::RenderGraph).
+///
+/// The `input_slots` and `output_slots` are provided by the `node`.
+pub struct NodeState {
+    pub label: InternedRenderLabel,
+    /// The name of the type that implements [`Node`].
+    pub type_name: &'static str,
+    pub node: Box<dyn Node>,
+    pub input_slots: SlotInfos,
+    pub output_slots: SlotInfos,
+    pub edges: Edges,
+}
+
+impl Debug for NodeState {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        writeln!(f, "{:?} ({})", self.label, self.type_name)
+    }
+}
+
+impl NodeState {
+    /// Creates an [`NodeState`] without edges, but the `input_slots` and `output_slots`
+    /// are provided by the `node`.
+    pub fn new<T>(label: InternedRenderLabel, node: T) -> Self
+    where
+        T: Node,
+    {
+        NodeState {
+            label,
+            input_slots: node.input().into(),
+            output_slots: node.output().into(),
+            node: Box::new(node),
+            type_name: core::any::type_name::<T>(),
+            edges: Edges {
+                label,
+                input_edges: Vec::new(),
+                output_edges: Vec::new(),
+            },
+        }
+    }
+
+    /// Retrieves the [`Node`].
+    pub fn node<T>(&self) -> Result<&T, RenderGraphError>
+    where
+        T: Node,
+    {
+        self.node
+            .downcast_ref::<T>()
+            .ok_or(RenderGraphError::WrongNodeType)
+    }
+
+    /// Retrieves the [`Node`] mutably.
+    pub fn node_mut<T>(&mut self) -> Result<&mut T, RenderGraphError>
+    where
+        T: Node,
+    {
+        self.node
+            .downcast_mut::<T>()
+            .ok_or(RenderGraphError::WrongNodeType)
+    }
+
+    /// Validates that each input slot corresponds to an input edge.
+    pub fn validate_input_slots(&self) -> Result<(), RenderGraphError> {
+        for i in 0..self.input_slots.len() {
+            self.edges.get_input_slot_edge(i)?;
+        }
+
+        Ok(())
+    }
+
+    /// Validates that each output slot corresponds to an output edge.
+    pub fn validate_output_slots(&self) -> Result<(), RenderGraphError> {
+        for i in 0..self.output_slots.len() {
+            self.edges.get_output_slot_edge(i)?;
+        }
+
+        Ok(())
+    }
+}
+
+/// A [`Node`] without any inputs, outputs and subgraphs, which does nothing when run.
+/// Used (as a label) to bundle multiple dependencies into one inside
+/// the [`RenderGraph`](super::RenderGraph).
+#[derive(Default)]
+pub struct EmptyNode;
+
+impl Node for EmptyNode {
+    fn run(
+        &self,
+        _graph: &mut RenderGraphContext,
+        _render_context: &mut RenderContext,
+        _world: &World,
+    ) -> Result<(), NodeRunError> {
+        Ok(())
+    }
+}
+
+/// A [`RenderGraph`](super::RenderGraph) [`Node`] that runs the configured subgraph once.
+/// This makes it easier to insert sub-graph runs into a graph.
+pub struct RunGraphOnViewNode {
+    sub_graph: InternedRenderSubGraph,
+}
+
+impl RunGraphOnViewNode {
+    pub fn new<T: RenderSubGraph>(sub_graph: T) -> Self {
+        Self {
+            sub_graph: sub_graph.intern(),
+        }
+    }
+}
+
+impl Node for RunGraphOnViewNode {
+    fn run(
+        &self,
+        graph: &mut RenderGraphContext,
+        _render_context: &mut RenderContext,
+        _world: &World,
+    ) -> Result<(), NodeRunError> {
+        graph.run_sub_graph(self.sub_graph, vec![], Some(graph.view_entity()))?;
+        Ok(())
+    }
+}
+
+/// This trait should be used instead of the [`Node`] trait when making a render node that runs on a view.
+///
+/// It is intended to be used with [`ViewNodeRunner`]
+pub trait ViewNode {
+    /// The query that will be used on the view entity.
+    /// It is guaranteed to run on the view entity, so there's no need for a filter
+    type ViewQuery: ReadOnlyQueryData;
+
+    /// Updates internal node state using the current render [`World`] prior to the run method.
+    fn update(&mut self, _world: &mut World) {}
+
+    /// Runs the graph node logic, issues draw calls, updates the output slots and
+    /// optionally queues up subgraphs for execution. The graph data, input and output values are
+    /// passed via the [`RenderGraphContext`].
+    fn run<'w>(
+        &self,
+        graph: &mut RenderGraphContext,
+        render_context: &mut RenderContext<'w>,
+        view_query: QueryItem<'w, Self::ViewQuery>,
+        world: &'w World,
+    ) -> Result<(), NodeRunError>;
+}
+
+/// This [`Node`] can be used to run any [`ViewNode`].
+/// It will take care of updating the view query in `update()` and running the query in `run()`.
+///
+/// This [`Node`] exists to help reduce boilerplate when making a render node that runs on a view.
+pub struct ViewNodeRunner<N: ViewNode> {
+    view_query: QueryState<N::ViewQuery>,
+    node: N,
+}
+
+impl<N: ViewNode> ViewNodeRunner<N> {
+    pub fn new(node: N, world: &mut World) -> Self {
+        Self {
+            view_query: world.query_filtered(),
+            node,
+        }
+    }
+}
+
+impl<N: ViewNode + FromWorld> FromWorld for ViewNodeRunner<N> {
+    fn from_world(world: &mut World) -> Self {
+        Self::new(N::from_world(world), world)
+    }
+}
+
+impl<T> Node for ViewNodeRunner<T>
+where
+    T: ViewNode + Send + Sync + 'static,
+{
+    fn update(&mut self, world: &mut World) {
+        self.view_query.update_archetypes(world);
+        self.node.update(world);
+    }
+
+    fn run<'w>(
+        &self,
+        graph: &mut RenderGraphContext,
+        render_context: &mut RenderContext<'w>,
+        world: &'w World,
+    ) -> Result<(), NodeRunError> {
+        let Ok(view) = self.view_query.get_manual(world, graph.view_entity()) else {
+            return Ok(());
+        };
+
+        ViewNode::run(&self.node, graph, render_context, view, world)?;
+        Ok(())
+    }
+}

vendor/bevy_render/src/render_graph/node_slot.rs

@@ -0,0 +1,165 @@
+use alloc::borrow::Cow;
+use bevy_ecs::entity::Entity;
+use core::fmt;
+use derive_more::derive::From;
+
+use crate::render_resource::{Buffer, Sampler, TextureView};
+
+/// A value passed between render [`Nodes`](super::Node).
+/// Corresponds to the [`SlotType`] specified in the [`RenderGraph`](super::RenderGraph).
+///
+/// Slots can have four different types of values:
+/// [`Buffer`], [`TextureView`], [`Sampler`] and [`Entity`].
+///
+/// These values do not contain the actual render data, but only the ids to retrieve them.
+#[derive(Debug, Clone, From)]
+pub enum SlotValue {
+    /// A GPU-accessible [`Buffer`].
+    Buffer(Buffer),
+    /// A [`TextureView`] describes a texture used in a pipeline.
+    TextureView(TextureView),
+    /// A texture [`Sampler`] defines how a pipeline will sample from a [`TextureView`].
+    Sampler(Sampler),
+    /// An entity from the ECS.
+    Entity(Entity),
+}
+
+impl SlotValue {
+    /// Returns the [`SlotType`] of this value.
+    pub fn slot_type(&self) -> SlotType {
+        match self {
+            SlotValue::Buffer(_) => SlotType::Buffer,
+            SlotValue::TextureView(_) => SlotType::TextureView,
+            SlotValue::Sampler(_) => SlotType::Sampler,
+            SlotValue::Entity(_) => SlotType::Entity,
+        }
+    }
+}
+
+/// Describes the render resources created (output) or used (input) by
+/// the render [`Nodes`](super::Node).
+///
+/// This should not be confused with [`SlotValue`], which actually contains the passed data.
+#[derive(Debug, Copy, Clone, Eq, PartialEq)]
+pub enum SlotType {
+    /// A GPU-accessible [`Buffer`].
+    Buffer,
+    /// A [`TextureView`] describes a texture used in a pipeline.
+    TextureView,
+    /// A texture [`Sampler`] defines how a pipeline will sample from a [`TextureView`].
+    Sampler,
+    /// An entity from the ECS.
+    Entity,
+}
+
+impl fmt::Display for SlotType {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let s = match self {
+            SlotType::Buffer => "Buffer",
+            SlotType::TextureView => "TextureView",
+            SlotType::Sampler => "Sampler",
+            SlotType::Entity => "Entity",
+        };
+
+        f.write_str(s)
+    }
+}
+
+/// A [`SlotLabel`] is used to reference a slot by either its name or index
+/// inside the [`RenderGraph`](super::RenderGraph).
+#[derive(Debug, Clone, Eq, PartialEq, From)]
+pub enum SlotLabel {
+    Index(usize),
+    Name(Cow<'static, str>),
+}
+
+impl From<&SlotLabel> for SlotLabel {
+    fn from(value: &SlotLabel) -> Self {
+        value.clone()
+    }
+}
+
+impl From<String> for SlotLabel {
+    fn from(value: String) -> Self {
+        SlotLabel::Name(value.into())
+    }
+}
+
+impl From<&'static str> for SlotLabel {
+    fn from(value: &'static str) -> Self {
+        SlotLabel::Name(value.into())
+    }
+}
+
+/// The internal representation of a slot, which specifies its [`SlotType`] and name.
+#[derive(Clone, Debug)]
+pub struct SlotInfo {
+    pub name: Cow<'static, str>,
+    pub slot_type: SlotType,
+}
+
+impl SlotInfo {
+    pub fn new(name: impl Into<Cow<'static, str>>, slot_type: SlotType) -> Self {
+        SlotInfo {
+            name: name.into(),
+            slot_type,
+        }
+    }
+}
+
+/// A collection of input or output [`SlotInfos`](SlotInfo) for
+/// a [`NodeState`](super::NodeState).
+#[derive(Default, Debug)]
+pub struct SlotInfos {
+    slots: Vec<SlotInfo>,
+}
+
+impl<T: IntoIterator<Item = SlotInfo>> From<T> for SlotInfos {
+    fn from(slots: T) -> Self {
+        SlotInfos {
+            slots: slots.into_iter().collect(),
+        }
+    }
+}
+
+impl SlotInfos {
+    /// Returns the count of slots.
+    #[inline]
+    pub fn len(&self) -> usize {
+        self.slots.len()
+    }
+
+    /// Returns true if there are no slots.
+    #[inline]
+    pub fn is_empty(&self) -> bool {
+        self.slots.is_empty()
+    }
+
+    /// Retrieves the [`SlotInfo`] for the provided label.
+    pub fn get_slot(&self, label: impl Into<SlotLabel>) -> Option<&SlotInfo> {
+        let label = label.into();
+        let index = self.get_slot_index(label)?;
+        self.slots.get(index)
+    }
+
+    /// Retrieves the [`SlotInfo`] for the provided label mutably.
+    pub fn get_slot_mut(&mut self, label: impl Into<SlotLabel>) -> Option<&mut SlotInfo> {
+        let label = label.into();
+        let index = self.get_slot_index(label)?;
+        self.slots.get_mut(index)
+    }
+
+    /// Retrieves the index (inside input or output slots) of the slot for the provided label.
+    pub fn get_slot_index(&self, label: impl Into<SlotLabel>) -> Option<usize> {
+        let label = label.into();
+        match label {
+            SlotLabel::Index(index) => Some(index),
+            SlotLabel::Name(ref name) => self.slots.iter().position(|s| s.name == *name),
+        }
+    }
+
+    /// Returns an iterator over the slot infos.
+    pub fn iter(&self) -> impl Iterator<Item = &SlotInfo> {
+        self.slots.iter()
+    }
+}

vendor/bevy_render/src/render_phase/draw.rs

@@ -0,0 +1,397 @@
+use crate::render_phase::{PhaseItem, TrackedRenderPass};
+use bevy_app::{App, SubApp};
+use bevy_ecs::{
+    entity::Entity,
+    query::{QueryEntityError, QueryState, ROQueryItem, ReadOnlyQueryData},
+    resource::Resource,
+    system::{ReadOnlySystemParam, SystemParam, SystemParamItem, SystemState},
+    world::World,
+};
+use bevy_utils::TypeIdMap;
+use core::{any::TypeId, fmt::Debug, hash::Hash};
+use std::sync::{PoisonError, RwLock, RwLockReadGuard, RwLockWriteGuard};
+use thiserror::Error;
+use variadics_please::all_tuples;
+
+/// A draw function used to draw [`PhaseItem`]s.
+///
+/// The draw function can retrieve and query the required ECS data from the render world.
+///
+/// This trait can either be implemented directly or implicitly composed out of multiple modular
+/// [`RenderCommand`]s. For more details and an example see the [`RenderCommand`] documentation.
+pub trait Draw<P: PhaseItem>: Send + Sync + 'static {
+    /// Prepares the draw function to be used. This is called once and only once before the phase
+    /// begins. There may be zero or more [`draw`](Draw::draw) calls following a call to this function.
+    /// Implementing this is optional.
+    #[expect(
+        unused_variables,
+        reason = "The parameters here are intentionally unused by the default implementation; however, putting underscores here will result in the underscores being copied by rust-analyzer's tab completion."
+    )]
+    fn prepare(&mut self, world: &'_ World) {}
+
+    /// Draws a [`PhaseItem`] by issuing zero or more `draw` calls via the [`TrackedRenderPass`].
+    fn draw<'w>(
+        &mut self,
+        world: &'w World,
+        pass: &mut TrackedRenderPass<'w>,
+        view: Entity,
+        item: &P,
+    ) -> Result<(), DrawError>;
+}
+
+#[derive(Error, Debug, PartialEq, Eq)]
+pub enum DrawError {
+    #[error("Failed to execute render command {0:?}")]
+    RenderCommandFailure(&'static str),
+    #[error("Failed to get execute view query")]
+    InvalidViewQuery,
+    #[error("View entity not found")]
+    ViewEntityNotFound,
+}
+
+// TODO: make this generic?
+/// An identifier for a [`Draw`] function stored in [`DrawFunctions`].
+#[derive(Copy, Clone, Debug, Eq, PartialEq, PartialOrd, Ord, Hash)]
+pub struct DrawFunctionId(u32);
+
+/// Stores all [`Draw`] functions for the [`PhaseItem`] type.
+///
+/// For retrieval, the [`Draw`] functions are mapped to their respective [`TypeId`]s.
+pub struct DrawFunctionsInternal<P: PhaseItem> {
+    pub draw_functions: Vec<Box<dyn Draw<P>>>,
+    pub indices: TypeIdMap<DrawFunctionId>,
+}
+
+impl<P: PhaseItem> DrawFunctionsInternal<P> {
+    /// Prepares all draw function. This is called once and only once before the phase begins.
+    pub fn prepare(&mut self, world: &World) {
+        for function in &mut self.draw_functions {
+            function.prepare(world);
+        }
+    }
+
+    /// Adds the [`Draw`] function and maps it to its own type.
+    pub fn add<T: Draw<P>>(&mut self, draw_function: T) -> DrawFunctionId {
+        self.add_with::<T, T>(draw_function)
+    }
+
+    /// Adds the [`Draw`] function and maps it to the type `T`
+    pub fn add_with<T: 'static, D: Draw<P>>(&mut self, draw_function: D) -> DrawFunctionId {
+        let id = DrawFunctionId(self.draw_functions.len().try_into().unwrap());
+        self.draw_functions.push(Box::new(draw_function));
+        self.indices.insert(TypeId::of::<T>(), id);
+        id
+    }
+
+    /// Retrieves the [`Draw`] function corresponding to the `id` mutably.
+    pub fn get_mut(&mut self, id: DrawFunctionId) -> Option<&mut dyn Draw<P>> {
+        self.draw_functions.get_mut(id.0 as usize).map(|f| &mut **f)
+    }
+
+    /// Retrieves the id of the [`Draw`] function corresponding to their associated type `T`.
+    pub fn get_id<T: 'static>(&self) -> Option<DrawFunctionId> {
+        self.indices.get(&TypeId::of::<T>()).copied()
+    }
+
+    /// Retrieves the id of the [`Draw`] function corresponding to their associated type `T`.
+    ///
+    /// Fallible wrapper for [`Self::get_id()`]
+    ///
+    /// ## Panics
+    /// If the id doesn't exist, this function will panic.
+    pub fn id<T: 'static>(&self) -> DrawFunctionId {
+        self.get_id::<T>().unwrap_or_else(|| {
+            panic!(
+                "Draw function {} not found for {}",
+                core::any::type_name::<T>(),
+                core::any::type_name::<P>()
+            )
+        })
+    }
+}
+
+/// Stores all draw functions for the [`PhaseItem`] type hidden behind a reader-writer lock.
+///
+/// To access them the [`DrawFunctions::read`] and [`DrawFunctions::write`] methods are used.
+#[derive(Resource)]
+pub struct DrawFunctions<P: PhaseItem> {
+    internal: RwLock<DrawFunctionsInternal<P>>,
+}
+
+impl<P: PhaseItem> Default for DrawFunctions<P> {
+    fn default() -> Self {
+        Self {
+            internal: RwLock::new(DrawFunctionsInternal {
+                draw_functions: Vec::new(),
+                indices: Default::default(),
+            }),
+        }
+    }
+}
+
+impl<P: PhaseItem> DrawFunctions<P> {
+    /// Accesses the draw functions in read mode.
+    pub fn read(&self) -> RwLockReadGuard<'_, DrawFunctionsInternal<P>> {
+        self.internal.read().unwrap_or_else(PoisonError::into_inner)
+    }
+
+    /// Accesses the draw functions in write mode.
+    pub fn write(&self) -> RwLockWriteGuard<'_, DrawFunctionsInternal<P>> {
+        self.internal
+            .write()
+            .unwrap_or_else(PoisonError::into_inner)
+    }
+}
+
+/// [`RenderCommand`]s are modular standardized pieces of render logic that can be composed into
+/// [`Draw`] functions.
+///
+/// To turn a stateless render command into a usable draw function it has to be wrapped by a
+/// [`RenderCommandState`].
+/// This is done automatically when registering a render command as a [`Draw`] function via the
+/// [`AddRenderCommand::add_render_command`] method.
+///
+/// Compared to the draw function the required ECS data is fetched automatically
+/// (by the [`RenderCommandState`]) from the render world.
+/// Therefore the three types [`Param`](RenderCommand::Param),
+/// [`ViewQuery`](RenderCommand::ViewQuery) and
+/// [`ItemQuery`](RenderCommand::ItemQuery) are used.
+/// They specify which information is required to execute the render command.
+///
+/// Multiple render commands can be combined together by wrapping them in a tuple.
+///
+/// # Example
+///
+/// The `DrawMaterial` draw function is created from the following render command
+/// tuple. Const generics are used to set specific bind group locations:
+///
+/// ```
+/// # use bevy_render::render_phase::SetItemPipeline;
+/// # struct SetMeshViewBindGroup<const N: usize>;
+/// # struct SetMeshBindGroup<const N: usize>;
+/// # struct SetMaterialBindGroup<M, const N: usize>(std::marker::PhantomData<M>);
+/// # struct DrawMesh;
+/// pub type DrawMaterial<M> = (
+///     SetItemPipeline,
+///     SetMeshViewBindGroup<0>,
+///     SetMeshBindGroup<1>,
+///     SetMaterialBindGroup<M, 2>,
+///     DrawMesh,
+/// );
+/// ```
+pub trait RenderCommand<P: PhaseItem> {
+    /// Specifies the general ECS data (e.g. resources) required by [`RenderCommand::render`].
+    ///
+    /// When fetching resources, note that, due to lifetime limitations of the `Deref` trait,
+    /// [`SRes::into_inner`] must be called on each [`SRes`] reference in the
+    /// [`RenderCommand::render`] method, instead of being automatically dereferenced as is the
+    /// case in normal `systems`.
+    ///
+    /// All parameters have to be read only.
+    ///
+    /// [`SRes`]: bevy_ecs::system::lifetimeless::SRes
+    /// [`SRes::into_inner`]: bevy_ecs::system::lifetimeless::SRes::into_inner
+    type Param: SystemParam + 'static;
+    /// Specifies the ECS data of the view entity required by [`RenderCommand::render`].
+    ///
+    /// The view entity refers to the camera, or shadow-casting light, etc. from which the phase
+    /// item will be rendered from.
+    /// All components have to be accessed read only.
+    type ViewQuery: ReadOnlyQueryData;
+    /// Specifies the ECS data of the item entity required by [`RenderCommand::render`].
+    ///
+    /// The item is the entity that will be rendered for the corresponding view.
+    /// All components have to be accessed read only.
+    ///
+    /// For efficiency reasons, Bevy doesn't always extract entities to the
+    /// render world; for instance, entities that simply consist of meshes are
+    /// often not extracted. If the entity doesn't exist in the render world,
+    /// the supplied query data will be `None`.
+    type ItemQuery: ReadOnlyQueryData;
+
+    /// Renders a [`PhaseItem`] by recording commands (e.g. setting pipelines, binding bind groups,
+    /// issuing draw calls, etc.) via the [`TrackedRenderPass`].
+    fn render<'w>(
+        item: &P,
+        view: ROQueryItem<'w, Self::ViewQuery>,
+        entity: Option<ROQueryItem<'w, Self::ItemQuery>>,
+        param: SystemParamItem<'w, '_, Self::Param>,
+        pass: &mut TrackedRenderPass<'w>,
+    ) -> RenderCommandResult;
+}
+
+/// The result of a [`RenderCommand`].
+#[derive(Debug)]
+pub enum RenderCommandResult {
+    Success,
+    Skip,
+    Failure(&'static str),
+}
+
+macro_rules! render_command_tuple_impl {
+    ($(#[$meta:meta])* $(($name: ident, $view: ident, $entity: ident)),*) => {
+        $(#[$meta])*
+        impl<P: PhaseItem, $($name: RenderCommand<P>),*> RenderCommand<P> for ($($name,)*) {
+            type Param = ($($name::Param,)*);
+            type ViewQuery = ($($name::ViewQuery,)*);
+            type ItemQuery = ($($name::ItemQuery,)*);
+
+            #[expect(
+                clippy::allow_attributes,
+                reason = "We are in a macro; as such, `non_snake_case` may not always lint."
+            )]
+            #[allow(
+                non_snake_case,
+                reason = "Parameter and variable names are provided by the macro invocation, not by us."
+            )]
+            fn render<'w>(
+                _item: &P,
+                ($($view,)*): ROQueryItem<'w, Self::ViewQuery>,
+                maybe_entities: Option<ROQueryItem<'w, Self::ItemQuery>>,
+                ($($name,)*): SystemParamItem<'w, '_, Self::Param>,
+                _pass: &mut TrackedRenderPass<'w>,
+            ) -> RenderCommandResult {
+                match maybe_entities {
+                    None => {
+                        $(
+                            match $name::render(_item, $view, None, $name, _pass) {
+                                RenderCommandResult::Skip => return RenderCommandResult::Skip,
+                                RenderCommandResult::Failure(reason) => return RenderCommandResult::Failure(reason),
+                                _ => {},
+                            }
+                        )*
+                    }
+                    Some(($($entity,)*)) => {
+                        $(
+                            match $name::render(_item, $view, Some($entity), $name, _pass) {
+                                RenderCommandResult::Skip => return RenderCommandResult::Skip,
+                                RenderCommandResult::Failure(reason) => return RenderCommandResult::Failure(reason),
+                                _ => {},
+                            }
+                        )*
+                    }
+                }
+                RenderCommandResult::Success
+            }
+        }
+    };
+}
+
+all_tuples!(
+    #[doc(fake_variadic)]
+    render_command_tuple_impl,
+    0,
+    15,
+    C,
+    V,
+    E
+);
+
+/// Wraps a [`RenderCommand`] into a state so that it can be used as a [`Draw`] function.
+///
+/// The [`RenderCommand::Param`], [`RenderCommand::ViewQuery`] and
+/// [`RenderCommand::ItemQuery`] are fetched from the ECS and passed to the command.
+pub struct RenderCommandState<P: PhaseItem + 'static, C: RenderCommand<P>> {
+    state: SystemState<C::Param>,
+    view: QueryState<C::ViewQuery>,
+    entity: QueryState<C::ItemQuery>,
+}
+
+impl<P: PhaseItem, C: RenderCommand<P>> RenderCommandState<P, C> {
+    /// Creates a new [`RenderCommandState`] for the [`RenderCommand`].
+    pub fn new(world: &mut World) -> Self {
+        Self {
+            state: SystemState::new(world),
+            view: world.query(),
+            entity: world.query(),
+        }
+    }
+}
+
+impl<P: PhaseItem, C: RenderCommand<P> + Send + Sync + 'static> Draw<P> for RenderCommandState<P, C>
+where
+    C::Param: ReadOnlySystemParam,
+{
+    /// Prepares the render command to be used. This is called once and only once before the phase
+    /// begins. There may be zero or more [`draw`](RenderCommandState::draw) calls following a call to this function.
+    fn prepare(&mut self, world: &'_ World) {
+        self.state.update_archetypes(world);
+        self.view.update_archetypes(world);
+        self.entity.update_archetypes(world);
+    }
+
+    /// Fetches the ECS parameters for the wrapped [`RenderCommand`] and then renders it.
+    fn draw<'w>(
+        &mut self,
+        world: &'w World,
+        pass: &mut TrackedRenderPass<'w>,
+        view: Entity,
+        item: &P,
+    ) -> Result<(), DrawError> {
+        let param = self.state.get_manual(world);
+        let view = match self.view.get_manual(world, view) {
+            Ok(view) => view,
+            Err(err) => match err {
+                QueryEntityError::EntityDoesNotExist(_) => {
+                    return Err(DrawError::ViewEntityNotFound)
+                }
+                QueryEntityError::QueryDoesNotMatch(_, _)
+                | QueryEntityError::AliasedMutability(_) => {
+                    return Err(DrawError::InvalidViewQuery)
+                }
+            },
+        };
+
+        let entity = self.entity.get_manual(world, item.entity()).ok();
+        match C::render(item, view, entity, param, pass) {
+            RenderCommandResult::Success | RenderCommandResult::Skip => Ok(()),
+            RenderCommandResult::Failure(reason) => Err(DrawError::RenderCommandFailure(reason)),
+        }
+    }
+}
+
+/// Registers a [`RenderCommand`] as a [`Draw`] function.
+/// They are stored inside the [`DrawFunctions`] resource of the app.
+pub trait AddRenderCommand {
+    /// Adds the [`RenderCommand`] for the specified render phase to the app.
+    fn add_render_command<P: PhaseItem, C: RenderCommand<P> + Send + Sync + 'static>(
+        &mut self,
+    ) -> &mut Self
+    where
+        C::Param: ReadOnlySystemParam;
+}
+
+impl AddRenderCommand for SubApp {
+    fn add_render_command<P: PhaseItem, C: RenderCommand<P> + Send + Sync + 'static>(
+        &mut self,
+    ) -> &mut Self
+    where
+        C::Param: ReadOnlySystemParam,
+    {
+        let draw_function = RenderCommandState::<P, C>::new(self.world_mut());
+        let draw_functions = self
+            .world()
+            .get_resource::<DrawFunctions<P>>()
+            .unwrap_or_else(|| {
+                panic!(
+                    "DrawFunctions<{}> must be added to the world as a resource \
+                     before adding render commands to it",
+                    core::any::type_name::<P>(),
+                );
+            });
+        draw_functions.write().add_with::<C, _>(draw_function);
+        self
+    }
+}
+
+impl AddRenderCommand for App {
+    fn add_render_command<P: PhaseItem, C: RenderCommand<P> + Send + Sync + 'static>(
+        &mut self,
+    ) -> &mut Self
+    where
+        C::Param: ReadOnlySystemParam,
+    {
+        SubApp::add_render_command::<P, C>(self.main_mut());
+        self
+    }
+}

vendor/bevy_render/src/render_phase/draw_state.rs

@@ -0,0 +1,682 @@
+use crate::{
+    camera::Viewport,
+    diagnostic::internal::{Pass, PassKind, WritePipelineStatistics, WriteTimestamp},
+    render_resource::{
+        BindGroup, BindGroupId, Buffer, BufferId, BufferSlice, RenderPipeline, RenderPipelineId,
+        ShaderStages,
+    },
+    renderer::RenderDevice,
+};
+use bevy_color::LinearRgba;
+use bevy_utils::default;
+use core::ops::Range;
+use wgpu::{IndexFormat, QuerySet, RenderPass};
+
+#[cfg(feature = "detailed_trace")]
+use tracing::trace;
+
+/// Tracks the state of a [`TrackedRenderPass`].
+///
+/// This is used to skip redundant operations on the [`TrackedRenderPass`] (e.g. setting an already
+/// set pipeline, binding an already bound bind group). These operations can otherwise be fairly
+/// costly due to IO to the GPU, so deduplicating these calls results in a speedup.
+#[derive(Debug, Default)]
+struct DrawState {
+    pipeline: Option<RenderPipelineId>,
+    bind_groups: Vec<(Option<BindGroupId>, Vec<u32>)>,
+    /// List of vertex buffers by [`BufferId`], offset, and size. See [`DrawState::buffer_slice_key`]
+    vertex_buffers: Vec<Option<(BufferId, u64, u64)>>,
+    index_buffer: Option<(BufferId, u64, IndexFormat)>,
+
+    /// Stores whether this state is populated or empty for quick state invalidation
+    stores_state: bool,
+}
+
+impl DrawState {
+    /// Marks the `pipeline` as bound.
+    fn set_pipeline(&mut self, pipeline: RenderPipelineId) {
+        // TODO: do these need to be cleared?
+        // self.bind_groups.clear();
+        // self.vertex_buffers.clear();
+        // self.index_buffer = None;
+        self.pipeline = Some(pipeline);
+        self.stores_state = true;
+    }
+
+    /// Checks, whether the `pipeline` is already bound.
+    fn is_pipeline_set(&self, pipeline: RenderPipelineId) -> bool {
+        self.pipeline == Some(pipeline)
+    }
+
+    /// Marks the `bind_group` as bound to the `index`.
+    fn set_bind_group(&mut self, index: usize, bind_group: BindGroupId, dynamic_indices: &[u32]) {
+        let group = &mut self.bind_groups[index];
+        group.0 = Some(bind_group);
+        group.1.clear();
+        group.1.extend(dynamic_indices);
+        self.stores_state = true;
+    }
+
+    /// Checks, whether the `bind_group` is already bound to the `index`.
+    fn is_bind_group_set(
+        &self,
+        index: usize,
+        bind_group: BindGroupId,
+        dynamic_indices: &[u32],
+    ) -> bool {
+        if let Some(current_bind_group) = self.bind_groups.get(index) {
+            current_bind_group.0 == Some(bind_group) && dynamic_indices == current_bind_group.1
+        } else {
+            false
+        }
+    }
+
+    /// Marks the vertex `buffer` as bound to the `index`.
+    fn set_vertex_buffer(&mut self, index: usize, buffer_slice: BufferSlice) {
+        self.vertex_buffers[index] = Some(self.buffer_slice_key(&buffer_slice));
+        self.stores_state = true;
+    }
+
+    /// Checks, whether the vertex `buffer` is already bound to the `index`.
+    fn is_vertex_buffer_set(&self, index: usize, buffer_slice: &BufferSlice) -> bool {
+        if let Some(current) = self.vertex_buffers.get(index) {
+            *current == Some(self.buffer_slice_key(buffer_slice))
+        } else {
+            false
+        }
+    }
+
+    /// Returns the value used for checking whether `BufferSlice`s are equivalent.
+    fn buffer_slice_key(&self, buffer_slice: &BufferSlice) -> (BufferId, u64, u64) {
+        (
+            buffer_slice.id(),
+            buffer_slice.offset(),
+            buffer_slice.size(),
+        )
+    }
+
+    /// Marks the index `buffer` as bound.
+    fn set_index_buffer(&mut self, buffer: BufferId, offset: u64, index_format: IndexFormat) {
+        self.index_buffer = Some((buffer, offset, index_format));
+        self.stores_state = true;
+    }
+
+    /// Checks, whether the index `buffer` is already bound.
+    fn is_index_buffer_set(
+        &self,
+        buffer: BufferId,
+        offset: u64,
+        index_format: IndexFormat,
+    ) -> bool {
+        self.index_buffer == Some((buffer, offset, index_format))
+    }
+
+    /// Resets tracking state
+    pub fn reset_tracking(&mut self) {
+        if !self.stores_state {
+            return;
+        }
+        self.pipeline = None;
+        self.bind_groups.iter_mut().for_each(|val| {
+            val.0 = None;
+            val.1.clear();
+        });
+        self.vertex_buffers.iter_mut().for_each(|val| {
+            *val = None;
+        });
+        self.index_buffer = None;
+        self.stores_state = false;
+    }
+}
+
+/// A [`RenderPass`], which tracks the current pipeline state to skip redundant operations.
+///
+/// It is used to set the current [`RenderPipeline`], [`BindGroup`]s and [`Buffer`]s.
+/// After all requirements are specified, draw calls can be issued.
+pub struct TrackedRenderPass<'a> {
+    pass: RenderPass<'a>,
+    state: DrawState,
+}
+
+impl<'a> TrackedRenderPass<'a> {
+    /// Tracks the supplied render pass.
+    pub fn new(device: &RenderDevice, pass: RenderPass<'a>) -> Self {
+        let limits = device.limits();
+        let max_bind_groups = limits.max_bind_groups as usize;
+        let max_vertex_buffers = limits.max_vertex_buffers as usize;
+        Self {
+            state: DrawState {
+                bind_groups: vec![(None, Vec::new()); max_bind_groups],
+                vertex_buffers: vec![None; max_vertex_buffers],
+                ..default()
+            },
+            pass,
+        }
+    }
+
+    /// Returns the wgpu [`RenderPass`].
+    ///
+    /// Function invalidates internal tracking state,
+    /// some redundant pipeline operations may not be skipped.
+    pub fn wgpu_pass(&mut self) -> &mut RenderPass<'a> {
+        self.state.reset_tracking();
+        &mut self.pass
+    }
+
+    /// Sets the active [`RenderPipeline`].
+    ///
+    /// Subsequent draw calls will exhibit the behavior defined by the `pipeline`.
+    pub fn set_render_pipeline(&mut self, pipeline: &'a RenderPipeline) {
+        #[cfg(feature = "detailed_trace")]
+        trace!("set pipeline: {:?}", pipeline);
+        if self.state.is_pipeline_set(pipeline.id()) {
+            return;
+        }
+        self.pass.set_pipeline(pipeline);
+        self.state.set_pipeline(pipeline.id());
+    }
+
+    /// Sets the active bind group for a given bind group index. The bind group layout
+    /// in the active pipeline when any `draw()` function is called must match the layout of
+    /// this bind group.
+    ///
+    /// If the bind group have dynamic offsets, provide them in binding order.
+    /// These offsets have to be aligned to [`WgpuLimits::min_uniform_buffer_offset_alignment`](crate::settings::WgpuLimits::min_uniform_buffer_offset_alignment)
+    /// or [`WgpuLimits::min_storage_buffer_offset_alignment`](crate::settings::WgpuLimits::min_storage_buffer_offset_alignment) appropriately.
+    pub fn set_bind_group(
+        &mut self,
+        index: usize,
+        bind_group: &'a BindGroup,
+        dynamic_uniform_indices: &[u32],
+    ) {
+        if self
+            .state
+            .is_bind_group_set(index, bind_group.id(), dynamic_uniform_indices)
+        {
+            #[cfg(feature = "detailed_trace")]
+            trace!(
+                "set bind_group {} (already set): {:?} ({:?})",
+                index,
+                bind_group,
+                dynamic_uniform_indices
+            );
+            return;
+        }
+        #[cfg(feature = "detailed_trace")]
+        trace!(
+            "set bind_group {}: {:?} ({:?})",
+            index,
+            bind_group,
+            dynamic_uniform_indices
+        );
+
+        self.pass
+            .set_bind_group(index as u32, bind_group, dynamic_uniform_indices);
+        self.state
+            .set_bind_group(index, bind_group.id(), dynamic_uniform_indices);
+    }
+
+    /// Assign a vertex buffer to a slot.
+    ///
+    /// Subsequent calls to [`draw`] and [`draw_indexed`] on this
+    /// [`TrackedRenderPass`] will use `buffer` as one of the source vertex buffers.
+    ///
+    /// The `slot_index` refers to the index of the matching descriptor in
+    /// [`VertexState::buffers`](crate::render_resource::VertexState::buffers).
+    ///
+    /// [`draw`]: TrackedRenderPass::draw
+    /// [`draw_indexed`]: TrackedRenderPass::draw_indexed
+    pub fn set_vertex_buffer(&mut self, slot_index: usize, buffer_slice: BufferSlice<'a>) {
+        if self.state.is_vertex_buffer_set(slot_index, &buffer_slice) {
+            #[cfg(feature = "detailed_trace")]
+            trace!(
+                "set vertex buffer {} (already set): {:?} (offset = {}, size = {})",
+                slot_index,
+                buffer_slice.id(),
+                buffer_slice.offset(),
+                buffer_slice.size(),
+            );
+            return;
+        }
+        #[cfg(feature = "detailed_trace")]
+        trace!(
+            "set vertex buffer {}: {:?} (offset = {}, size = {})",
+            slot_index,
+            buffer_slice.id(),
+            buffer_slice.offset(),
+            buffer_slice.size(),
+        );
+
+        self.pass
+            .set_vertex_buffer(slot_index as u32, *buffer_slice);
+        self.state.set_vertex_buffer(slot_index, buffer_slice);
+    }
+
+    /// Sets the active index buffer.
+    ///
+    /// Subsequent calls to [`TrackedRenderPass::draw_indexed`] will use the buffer referenced by
+    /// `buffer_slice` as the source index buffer.
+    pub fn set_index_buffer(
+        &mut self,
+        buffer_slice: BufferSlice<'a>,
+        offset: u64,
+        index_format: IndexFormat,
+    ) {
+        if self
+            .state
+            .is_index_buffer_set(buffer_slice.id(), offset, index_format)
+        {
+            #[cfg(feature = "detailed_trace")]
+            trace!(
+                "set index buffer (already set): {:?} ({})",
+                buffer_slice.id(),
+                offset
+            );
+            return;
+        }
+        #[cfg(feature = "detailed_trace")]
+        trace!("set index buffer: {:?} ({})", buffer_slice.id(), offset);
+        self.pass.set_index_buffer(*buffer_slice, index_format);
+        self.state
+            .set_index_buffer(buffer_slice.id(), offset, index_format);
+    }
+
+    /// Draws primitives from the active vertex buffer(s).
+    ///
+    /// The active vertex buffer(s) can be set with [`TrackedRenderPass::set_vertex_buffer`].
+    pub fn draw(&mut self, vertices: Range<u32>, instances: Range<u32>) {
+        #[cfg(feature = "detailed_trace")]
+        trace!("draw: {:?} {:?}", vertices, instances);
+        self.pass.draw(vertices, instances);
+    }
+
+    /// Draws indexed primitives using the active index buffer and the active vertex buffer(s).
+    ///
+    /// The active index buffer can be set with [`TrackedRenderPass::set_index_buffer`], while the
+    /// active vertex buffer(s) can be set with [`TrackedRenderPass::set_vertex_buffer`].
+    pub fn draw_indexed(&mut self, indices: Range<u32>, base_vertex: i32, instances: Range<u32>) {
+        #[cfg(feature = "detailed_trace")]
+        trace!(
+            "draw indexed: {:?} {} {:?}",
+            indices,
+            base_vertex,
+            instances
+        );
+        self.pass.draw_indexed(indices, base_vertex, instances);
+    }
+
+    /// Draws primitives from the active vertex buffer(s) based on the contents of the
+    /// `indirect_buffer`.
+    ///
+    /// The active vertex buffers can be set with [`TrackedRenderPass::set_vertex_buffer`].
+    ///
+    /// The structure expected in `indirect_buffer` is the following:
+    ///
+    /// ```
+    /// #[repr(C)]
+    /// struct DrawIndirect {
+    ///     vertex_count: u32, // The number of vertices to draw.
+    ///     instance_count: u32, // The number of instances to draw.
+    ///     first_vertex: u32, // The Index of the first vertex to draw.
+    ///     first_instance: u32, // The instance ID of the first instance to draw.
+    ///     // has to be 0, unless [`Features::INDIRECT_FIRST_INSTANCE`] is enabled.
+    /// }
+    /// ```
+    pub fn draw_indirect(&mut self, indirect_buffer: &'a Buffer, indirect_offset: u64) {
+        #[cfg(feature = "detailed_trace")]
+        trace!("draw indirect: {:?} {}", indirect_buffer, indirect_offset);
+        self.pass.draw_indirect(indirect_buffer, indirect_offset);
+    }
+
+    /// Draws indexed primitives using the active index buffer and the active vertex buffers,
+    /// based on the contents of the `indirect_buffer`.
+    ///
+    /// The active index buffer can be set with [`TrackedRenderPass::set_index_buffer`], while the
+    /// active vertex buffers can be set with [`TrackedRenderPass::set_vertex_buffer`].
+    ///
+    /// The structure expected in `indirect_buffer` is the following:
+    ///
+    /// ```
+    /// #[repr(C)]
+    /// struct DrawIndexedIndirect {
+    ///     vertex_count: u32, // The number of vertices to draw.
+    ///     instance_count: u32, // The number of instances to draw.
+    ///     first_index: u32, // The base index within the index buffer.
+    ///     vertex_offset: i32, // The value added to the vertex index before indexing into the vertex buffer.
+    ///     first_instance: u32, // The instance ID of the first instance to draw.
+    ///     // has to be 0, unless [`Features::INDIRECT_FIRST_INSTANCE`] is enabled.
+    /// }
+    /// ```
+    pub fn draw_indexed_indirect(&mut self, indirect_buffer: &'a Buffer, indirect_offset: u64) {
+        #[cfg(feature = "detailed_trace")]
+        trace!(
+            "draw indexed indirect: {:?} {}",
+            indirect_buffer,
+            indirect_offset
+        );
+        self.pass
+            .draw_indexed_indirect(indirect_buffer, indirect_offset);
+    }
+
+    /// Dispatches multiple draw calls from the active vertex buffer(s) based on the contents of the
+    /// `indirect_buffer`.`count` draw calls are issued.
+    ///
+    /// The active vertex buffers can be set with [`TrackedRenderPass::set_vertex_buffer`].
+    ///
+    /// `indirect_buffer` should contain `count` tightly packed elements of the following structure:
+    ///
+    /// ```
+    /// #[repr(C)]
+    /// struct DrawIndirect {
+    ///     vertex_count: u32, // The number of vertices to draw.
+    ///     instance_count: u32, // The number of instances to draw.
+    ///     first_vertex: u32, // The Index of the first vertex to draw.
+    ///     first_instance: u32, // The instance ID of the first instance to draw.
+    ///     // has to be 0, unless [`Features::INDIRECT_FIRST_INSTANCE`] is enabled.
+    /// }
+    /// ```
+    pub fn multi_draw_indirect(
+        &mut self,
+        indirect_buffer: &'a Buffer,
+        indirect_offset: u64,
+        count: u32,
+    ) {
+        #[cfg(feature = "detailed_trace")]
+        trace!(
+            "multi draw indirect: {:?} {}, {}x",
+            indirect_buffer,
+            indirect_offset,
+            count
+        );
+        self.pass
+            .multi_draw_indirect(indirect_buffer, indirect_offset, count);
+    }
+
+    /// Dispatches multiple draw calls from the active vertex buffer(s) based on the contents of
+    /// the `indirect_buffer`.
+    /// The count buffer is read to determine how many draws to issue.
+    ///
+    /// The indirect buffer must be long enough to account for `max_count` draws, however only
+    /// `count` elements will be read, where `count` is the value read from `count_buffer` capped
+    /// at `max_count`.
+    ///
+    /// The active vertex buffers can be set with [`TrackedRenderPass::set_vertex_buffer`].
+    ///
+    /// `indirect_buffer` should contain `count` tightly packed elements of the following structure:
+    ///
+    /// ```
+    /// #[repr(C)]
+    /// struct DrawIndirect {
+    ///     vertex_count: u32, // The number of vertices to draw.
+    ///     instance_count: u32, // The number of instances to draw.
+    ///     first_vertex: u32, // The Index of the first vertex to draw.
+    ///     first_instance: u32, // The instance ID of the first instance to draw.
+    ///     // has to be 0, unless [`Features::INDIRECT_FIRST_INSTANCE`] is enabled.
+    /// }
+    /// ```
+    pub fn multi_draw_indirect_count(
+        &mut self,
+        indirect_buffer: &'a Buffer,
+        indirect_offset: u64,
+        count_buffer: &'a Buffer,
+        count_offset: u64,
+        max_count: u32,
+    ) {
+        #[cfg(feature = "detailed_trace")]
+        trace!(
+            "multi draw indirect count: {:?} {}, ({:?} {})x, max {}x",
+            indirect_buffer,
+            indirect_offset,
+            count_buffer,
+            count_offset,
+            max_count
+        );
+        self.pass.multi_draw_indirect_count(
+            indirect_buffer,
+            indirect_offset,
+            count_buffer,
+            count_offset,
+            max_count,
+        );
+    }
+
+    /// Dispatches multiple draw calls from the active index buffer and the active vertex buffers,
+    /// based on the contents of the `indirect_buffer`. `count` draw calls are issued.
+    ///
+    /// The active index buffer can be set with [`TrackedRenderPass::set_index_buffer`], while the
+    /// active vertex buffers can be set with [`TrackedRenderPass::set_vertex_buffer`].
+    ///
+    /// `indirect_buffer` should contain `count` tightly packed elements of the following structure:
+    ///
+    /// ```
+    /// #[repr(C)]
+    /// struct DrawIndexedIndirect {
+    ///     vertex_count: u32, // The number of vertices to draw.
+    ///     instance_count: u32, // The number of instances to draw.
+    ///     first_index: u32, // The base index within the index buffer.
+    ///     vertex_offset: i32, // The value added to the vertex index before indexing into the vertex buffer.
+    ///     first_instance: u32, // The instance ID of the first instance to draw.
+    ///     // has to be 0, unless [`Features::INDIRECT_FIRST_INSTANCE`] is enabled.
+    /// }
+    /// ```
+    pub fn multi_draw_indexed_indirect(
+        &mut self,
+        indirect_buffer: &'a Buffer,
+        indirect_offset: u64,
+        count: u32,
+    ) {
+        #[cfg(feature = "detailed_trace")]
+        trace!(
+            "multi draw indexed indirect: {:?} {}, {}x",
+            indirect_buffer,
+            indirect_offset,
+            count
+        );
+        self.pass
+            .multi_draw_indexed_indirect(indirect_buffer, indirect_offset, count);
+    }
+
+    /// Dispatches multiple draw calls from the active index buffer and the active vertex buffers,
+    /// based on the contents of the `indirect_buffer`.
+    /// The count buffer is read to determine how many draws to issue.
+    ///
+    /// The indirect buffer must be long enough to account for `max_count` draws, however only
+    /// `count` elements will be read, where `count` is the value read from `count_buffer` capped
+    /// at `max_count`.
+    ///
+    /// The active index buffer can be set with [`TrackedRenderPass::set_index_buffer`], while the
+    /// active vertex buffers can be set with [`TrackedRenderPass::set_vertex_buffer`].
+    ///
+    /// `indirect_buffer` should contain `count` tightly packed elements of the following structure:
+    ///
+    /// ```
+    /// #[repr(C)]
+    /// struct DrawIndexedIndirect {
+    ///     vertex_count: u32, // The number of vertices to draw.
+    ///     instance_count: u32, // The number of instances to draw.
+    ///     first_index: u32, // The base index within the index buffer.
+    ///     vertex_offset: i32, // The value added to the vertex index before indexing into the vertex buffer.
+    ///     first_instance: u32, // The instance ID of the first instance to draw.
+    ///     // has to be 0, unless [`Features::INDIRECT_FIRST_INSTANCE`] is enabled.
+    /// }
+    /// ```
+    pub fn multi_draw_indexed_indirect_count(
+        &mut self,
+        indirect_buffer: &'a Buffer,
+        indirect_offset: u64,
+        count_buffer: &'a Buffer,
+        count_offset: u64,
+        max_count: u32,
+    ) {
+        #[cfg(feature = "detailed_trace")]
+        trace!(
+            "multi draw indexed indirect count: {:?} {}, ({:?} {})x, max {}x",
+            indirect_buffer,
+            indirect_offset,
+            count_buffer,
+            count_offset,
+            max_count
+        );
+        self.pass.multi_draw_indexed_indirect_count(
+            indirect_buffer,
+            indirect_offset,
+            count_buffer,
+            count_offset,
+            max_count,
+        );
+    }
+
+    /// Sets the stencil reference.
+    ///
+    /// Subsequent stencil tests will test against this value.
+    pub fn set_stencil_reference(&mut self, reference: u32) {
+        #[cfg(feature = "detailed_trace")]
+        trace!("set stencil reference: {}", reference);
+        self.pass.set_stencil_reference(reference);
+    }
+
+    /// Sets the scissor region.
+    ///
+    /// Subsequent draw calls will discard any fragments that fall outside this region.
+    pub fn set_scissor_rect(&mut self, x: u32, y: u32, width: u32, height: u32) {
+        #[cfg(feature = "detailed_trace")]
+        trace!("set_scissor_rect: {} {} {} {}", x, y, width, height);
+        self.pass.set_scissor_rect(x, y, width, height);
+    }
+
+    /// Set push constant data.
+    ///
+    /// `Features::PUSH_CONSTANTS` must be enabled on the device in order to call these functions.
+    pub fn set_push_constants(&mut self, stages: ShaderStages, offset: u32, data: &[u8]) {
+        #[cfg(feature = "detailed_trace")]
+        trace!(
+            "set push constants: {:?} offset: {} data.len: {}",
+            stages,
+            offset,
+            data.len()
+        );
+        self.pass.set_push_constants(stages, offset, data);
+    }
+
+    /// Set the rendering viewport.
+    ///
+    /// Subsequent draw calls will be projected into that viewport.
+    pub fn set_viewport(
+        &mut self,
+        x: f32,
+        y: f32,
+        width: f32,
+        height: f32,
+        min_depth: f32,
+        max_depth: f32,
+    ) {
+        #[cfg(feature = "detailed_trace")]
+        trace!(
+            "set viewport: {} {} {} {} {} {}",
+            x,
+            y,
+            width,
+            height,
+            min_depth,
+            max_depth
+        );
+        self.pass
+            .set_viewport(x, y, width, height, min_depth, max_depth);
+    }
+
+    /// Set the rendering viewport to the given camera [`Viewport`].
+    ///
+    /// Subsequent draw calls will be projected into that viewport.
+    pub fn set_camera_viewport(&mut self, viewport: &Viewport) {
+        self.set_viewport(
+            viewport.physical_position.x as f32,
+            viewport.physical_position.y as f32,
+            viewport.physical_size.x as f32,
+            viewport.physical_size.y as f32,
+            viewport.depth.start,
+            viewport.depth.end,
+        );
+    }
+
+    /// Insert a single debug marker.
+    ///
+    /// This is a GPU debugging feature. This has no effect on the rendering itself.
+    pub fn insert_debug_marker(&mut self, label: &str) {
+        #[cfg(feature = "detailed_trace")]
+        trace!("insert debug marker: {}", label);
+        self.pass.insert_debug_marker(label);
+    }
+
+    /// Start a new debug group.
+    ///
+    /// Push a new debug group over the internal stack. Subsequent render commands and debug
+    /// markers are grouped into this new group, until [`pop_debug_group`] is called.
+    ///
+    /// ```
+    /// # fn example(mut pass: bevy_render::render_phase::TrackedRenderPass<'static>) {
+    /// pass.push_debug_group("Render the car");
+    /// // [setup pipeline etc...]
+    /// pass.draw(0..64, 0..1);
+    /// pass.pop_debug_group();
+    /// # }
+    /// ```
+    ///
+    /// Note that [`push_debug_group`] and [`pop_debug_group`] must always be called in pairs.
+    ///
+    /// This is a GPU debugging feature. This has no effect on the rendering itself.
+    ///
+    /// [`push_debug_group`]: TrackedRenderPass::push_debug_group
+    /// [`pop_debug_group`]: TrackedRenderPass::pop_debug_group
+    pub fn push_debug_group(&mut self, label: &str) {
+        #[cfg(feature = "detailed_trace")]
+        trace!("push_debug_group marker: {}", label);
+        self.pass.push_debug_group(label);
+    }
+
+    /// End the current debug group.
+    ///
+    /// Subsequent render commands and debug markers are not grouped anymore in
+    /// this group, but in the previous one (if any) or the default top-level one
+    /// if the debug group was the last one on the stack.
+    ///
+    /// Note that [`push_debug_group`] and [`pop_debug_group`] must always be called in pairs.
+    ///
+    /// This is a GPU debugging feature. This has no effect on the rendering itself.
+    ///
+    /// [`push_debug_group`]: TrackedRenderPass::push_debug_group
+    /// [`pop_debug_group`]: TrackedRenderPass::pop_debug_group
+    pub fn pop_debug_group(&mut self) {
+        #[cfg(feature = "detailed_trace")]
+        trace!("pop_debug_group");
+        self.pass.pop_debug_group();
+    }
+
+    /// Sets the blend color as used by some of the blending modes.
+    ///
+    /// Subsequent blending tests will test against this value.
+    pub fn set_blend_constant(&mut self, color: LinearRgba) {
+        #[cfg(feature = "detailed_trace")]
+        trace!("set blend constant: {:?}", color);
+        self.pass.set_blend_constant(wgpu::Color::from(color));
+    }
+}
+
+impl WriteTimestamp for TrackedRenderPass<'_> {
+    fn write_timestamp(&mut self, query_set: &QuerySet, index: u32) {
+        self.pass.write_timestamp(query_set, index);
+    }
+}
+
+impl WritePipelineStatistics for TrackedRenderPass<'_> {
+    fn begin_pipeline_statistics_query(&mut self, query_set: &QuerySet, index: u32) {
+        self.pass.begin_pipeline_statistics_query(query_set, index);
+    }
+
+    fn end_pipeline_statistics_query(&mut self) {
+        self.pass.end_pipeline_statistics_query();
+    }
+}
+
+impl Pass for TrackedRenderPass<'_> {
+    const KIND: PassKind = PassKind::Render;
+}

vendor/bevy_render/src/render_phase/rangefinder.rs

@@ -0,0 +1,50 @@
+use bevy_math::{Mat4, Vec3, Vec4};
+
+/// A distance calculator for the draw order of [`PhaseItem`](crate::render_phase::PhaseItem)s.
+pub struct ViewRangefinder3d {
+    view_from_world_row_2: Vec4,
+}
+
+impl ViewRangefinder3d {
+    /// Creates a 3D rangefinder for a view matrix.
+    pub fn from_world_from_view(world_from_view: &Mat4) -> ViewRangefinder3d {
+        let view_from_world = world_from_view.inverse();
+
+        ViewRangefinder3d {
+            view_from_world_row_2: view_from_world.row(2),
+        }
+    }
+
+    /// Calculates the distance, or view-space `Z` value, for the given `translation`.
+    #[inline]
+    pub fn distance_translation(&self, translation: &Vec3) -> f32 {
+        // NOTE: row 2 of the inverse view matrix dotted with the translation from the model matrix
+        // gives the z component of translation of the mesh in view-space
+        self.view_from_world_row_2.dot(translation.extend(1.0))
+    }
+
+    /// Calculates the distance, or view-space `Z` value, for the given `transform`.
+    #[inline]
+    pub fn distance(&self, transform: &Mat4) -> f32 {
+        // NOTE: row 2 of the inverse view matrix dotted with column 3 of the model matrix
+        // gives the z component of translation of the mesh in view-space
+        self.view_from_world_row_2.dot(transform.col(3))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::ViewRangefinder3d;
+    use bevy_math::{Mat4, Vec3};
+
+    #[test]
+    fn distance() {
+        let view_matrix = Mat4::from_translation(Vec3::new(0.0, 0.0, -1.0));
+        let rangefinder = ViewRangefinder3d::from_world_from_view(&view_matrix);
+        assert_eq!(rangefinder.distance(&Mat4::IDENTITY), 1.0);
+        assert_eq!(
+            rangefinder.distance(&Mat4::from_translation(Vec3::new(0.0, 0.0, 1.0))),
+            2.0
+        );
+    }
+}

vendor/bevy_render/src/render_resource/batched_uniform_buffer.rs

@@ -0,0 +1,157 @@
+use super::{GpuArrayBufferIndex, GpuArrayBufferable};
+use crate::{
+    render_resource::DynamicUniformBuffer,
+    renderer::{RenderDevice, RenderQueue},
+};
+use core::{marker::PhantomData, num::NonZero};
+use encase::{
+    private::{ArrayMetadata, BufferMut, Metadata, RuntimeSizedArray, WriteInto, Writer},
+    ShaderType,
+};
+use nonmax::NonMaxU32;
+use wgpu::{BindingResource, Limits};
+
+// 1MB else we will make really large arrays on macOS which reports very large
+// `max_uniform_buffer_binding_size`. On macOS this ends up being the minimum
+// size of the uniform buffer as well as the size of each chunk of data at a
+// dynamic offset.
+#[cfg(any(
+    not(feature = "webgl"),
+    not(target_arch = "wasm32"),
+    feature = "webgpu"
+))]
+const MAX_REASONABLE_UNIFORM_BUFFER_BINDING_SIZE: u32 = 1 << 20;
+
+// WebGL2 quirk: using uniform buffers larger than 4KB will cause extremely
+// long shader compilation times, so the limit needs to be lower on WebGL2.
+// This is due to older shader compilers/GPUs that don't support dynamically
+// indexing uniform buffers, and instead emulate it with large switch statements
+// over buffer indices that take a long time to compile.
+#[cfg(all(feature = "webgl", target_arch = "wasm32", not(feature = "webgpu")))]
+const MAX_REASONABLE_UNIFORM_BUFFER_BINDING_SIZE: u32 = 1 << 12;
+
+/// Similar to [`DynamicUniformBuffer`], except every N elements (depending on size)
+/// are grouped into a batch as an `array<T, N>` in WGSL.
+///
+/// This reduces the number of rebindings required due to having to pass dynamic
+/// offsets to bind group commands, and if indices into the array can be passed
+/// in via other means, it enables batching of draw commands.
+pub struct BatchedUniformBuffer<T: GpuArrayBufferable> {
+    // Batches of fixed-size arrays of T are written to this buffer so that
+    // each batch in a fixed-size array can be bound at a dynamic offset.
+    uniforms: DynamicUniformBuffer<MaxCapacityArray<Vec<T>>>,
+    // A batch of T are gathered into this `MaxCapacityArray` until it is full,
+    // then it is written into the `DynamicUniformBuffer`, cleared, and new T
+    // are gathered here, and so on for each batch.
+    temp: MaxCapacityArray<Vec<T>>,
+    current_offset: u32,
+    dynamic_offset_alignment: u32,
+}
+
+impl<T: GpuArrayBufferable> BatchedUniformBuffer<T> {
+    pub fn batch_size(limits: &Limits) -> usize {
+        (limits
+            .max_uniform_buffer_binding_size
+            .min(MAX_REASONABLE_UNIFORM_BUFFER_BINDING_SIZE) as u64
+            / T::min_size().get()) as usize
+    }
+
+    pub fn new(limits: &Limits) -> Self {
+        let capacity = Self::batch_size(limits);
+        let alignment = limits.min_uniform_buffer_offset_alignment;
+
+        Self {
+            uniforms: DynamicUniformBuffer::new_with_alignment(alignment as u64),
+            temp: MaxCapacityArray(Vec::with_capacity(capacity), capacity),
+            current_offset: 0,
+            dynamic_offset_alignment: alignment,
+        }
+    }
+
+    #[inline]
+    pub fn size(&self) -> NonZero<u64> {
+        self.temp.size()
+    }
+
+    pub fn clear(&mut self) {
+        self.uniforms.clear();
+        self.current_offset = 0;
+        self.temp.0.clear();
+    }
+
+    pub fn push(&mut self, component: T) -> GpuArrayBufferIndex<T> {
+        let result = GpuArrayBufferIndex {
+            index: self.temp.0.len() as u32,
+            dynamic_offset: NonMaxU32::new(self.current_offset),
+            element_type: PhantomData,
+        };
+        self.temp.0.push(component);
+        if self.temp.0.len() == self.temp.1 {
+            self.flush();
+        }
+        result
+    }
+
+    pub fn flush(&mut self) {
+        self.uniforms.push(&self.temp);
+
+        self.current_offset +=
+            align_to_next(self.temp.size().get(), self.dynamic_offset_alignment as u64) as u32;
+
+        self.temp.0.clear();
+    }
+
+    pub fn write_buffer(&mut self, device: &RenderDevice, queue: &RenderQueue) {
+        if !self.temp.0.is_empty() {
+            self.flush();
+        }
+        self.uniforms.write_buffer(device, queue);
+    }
+
+    #[inline]
+    pub fn binding(&self) -> Option<BindingResource> {
+        let mut binding = self.uniforms.binding();
+        if let Some(BindingResource::Buffer(binding)) = &mut binding {
+            // MaxCapacityArray is runtime-sized so can't use T::min_size()
+            binding.size = Some(self.size());
+        }
+        binding
+    }
+}
+
+#[inline]
+fn align_to_next(value: u64, alignment: u64) -> u64 {
+    debug_assert!(alignment.is_power_of_two());
+    ((value - 1) | (alignment - 1)) + 1
+}
+
+// ----------------------------------------------------------------------------
+// MaxCapacityArray was implemented by Teodor Tanasoaia for encase. It was
+// copied here as it was not yet included in an encase release and it is
+// unclear if it is the correct long-term solution for encase.
+
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord)]
+struct MaxCapacityArray<T>(T, usize);
+
+impl<T> ShaderType for MaxCapacityArray<T>
+where
+    T: ShaderType<ExtraMetadata = ArrayMetadata>,
+{
+    type ExtraMetadata = ArrayMetadata;
+
+    const METADATA: Metadata<Self::ExtraMetadata> = T::METADATA;
+
+    fn size(&self) -> NonZero<u64> {
+        Self::METADATA.stride().mul(self.1.max(1) as u64).0
+    }
+}
+
+impl<T> WriteInto for MaxCapacityArray<T>
+where
+    T: WriteInto + RuntimeSizedArray,
+{
+    fn write_into<B: BufferMut>(&self, writer: &mut Writer<B>) {
+        debug_assert!(self.0.len() <= self.1);
+        self.0.write_into(writer);
+    }
+}

vendor/bevy_render/src/render_resource/bind_group.rs

@@ -0,0 +1,720 @@
+use crate::renderer::WgpuWrapper;
+use crate::{
+    define_atomic_id,
+    render_asset::RenderAssets,
+    render_resource::{BindGroupLayout, Buffer, Sampler, TextureView},
+    renderer::RenderDevice,
+    texture::GpuImage,
+};
+use bevy_derive::{Deref, DerefMut};
+use bevy_ecs::system::{SystemParam, SystemParamItem};
+pub use bevy_render_macros::AsBindGroup;
+use core::ops::Deref;
+use encase::ShaderType;
+use thiserror::Error;
+use wgpu::{
+    BindGroupEntry, BindGroupLayoutEntry, BindingResource, SamplerBindingType, TextureViewDimension,
+};
+
+use super::{BindlessDescriptor, BindlessSlabResourceLimit};
+
+define_atomic_id!(BindGroupId);
+
+/// Bind groups are responsible for binding render resources (e.g. buffers, textures, samplers)
+/// to a [`TrackedRenderPass`](crate::render_phase::TrackedRenderPass).
+/// This makes them accessible in the pipeline (shaders) as uniforms.
+///
+/// This is a lightweight thread-safe wrapper around wgpu's own [`BindGroup`](wgpu::BindGroup),
+/// which can be cloned as needed to workaround lifetime management issues. It may be converted
+/// from and dereferences to wgpu's [`BindGroup`](wgpu::BindGroup).
+///
+/// Can be created via [`RenderDevice::create_bind_group`](RenderDevice::create_bind_group).
+#[derive(Clone, Debug)]
+pub struct BindGroup {
+    id: BindGroupId,
+    value: WgpuWrapper<wgpu::BindGroup>,
+}
+
+impl BindGroup {
+    /// Returns the [`BindGroupId`] representing the unique ID of the bind group.
+    #[inline]
+    pub fn id(&self) -> BindGroupId {
+        self.id
+    }
+}
+
+impl PartialEq for BindGroup {
+    fn eq(&self, other: &Self) -> bool {
+        self.id == other.id
+    }
+}
+
+impl Eq for BindGroup {}
+
+impl core::hash::Hash for BindGroup {
+    fn hash<H: core::hash::Hasher>(&self, state: &mut H) {
+        self.id.0.hash(state);
+    }
+}
+
+impl From<wgpu::BindGroup> for BindGroup {
+    fn from(value: wgpu::BindGroup) -> Self {
+        BindGroup {
+            id: BindGroupId::new(),
+            value: WgpuWrapper::new(value),
+        }
+    }
+}
+
+impl<'a> From<&'a BindGroup> for Option<&'a wgpu::BindGroup> {
+    fn from(value: &'a BindGroup) -> Self {
+        Some(value.deref())
+    }
+}
+
+impl<'a> From<&'a mut BindGroup> for Option<&'a wgpu::BindGroup> {
+    fn from(value: &'a mut BindGroup) -> Self {
+        Some(&*value)
+    }
+}
+
+impl Deref for BindGroup {
+    type Target = wgpu::BindGroup;
+
+    #[inline]
+    fn deref(&self) -> &Self::Target {
+        &self.value
+    }
+}
+
+/// Converts a value to a [`BindGroup`] with a given [`BindGroupLayout`], which can then be used in Bevy shaders.
+/// This trait can be derived (and generally should be). Read on for details and examples.
+///
+/// This is an opinionated trait that is intended to make it easy to generically
+/// convert a type into a [`BindGroup`]. It provides access to specific render resources,
+/// such as [`RenderAssets<GpuImage>`] and [`crate::texture::FallbackImage`]. If a type has a [`Handle<Image>`](bevy_asset::Handle),
+/// these can be used to retrieve the corresponding [`Texture`](crate::render_resource::Texture) resource.
+///
+/// [`AsBindGroup::as_bind_group`] is intended to be called once, then the result cached somewhere. It is generally
+/// ok to do "expensive" work here, such as creating a [`Buffer`] for a uniform.
+///
+/// If for some reason a [`BindGroup`] cannot be created yet (for example, the [`Texture`](crate::render_resource::Texture)
+/// for an [`Image`](bevy_image::Image) hasn't loaded yet), just return [`AsBindGroupError::RetryNextUpdate`], which signals that the caller
+/// should retry again later.
+///
+/// # Deriving
+///
+/// This trait can be derived. Field attributes like `uniform` and `texture` are used to define which fields should be bindings,
+/// what their binding type is, and what index they should be bound at:
+///
+/// ```
+/// # use bevy_render::render_resource::*;
+/// # use bevy_image::Image;
+/// # use bevy_color::LinearRgba;
+/// # use bevy_asset::Handle;
+/// # use bevy_render::storage::ShaderStorageBuffer;
+///
+/// #[derive(AsBindGroup)]
+/// struct CoolMaterial {
+///     #[uniform(0)]
+///     color: LinearRgba,
+///     #[texture(1)]
+///     #[sampler(2)]
+///     color_texture: Handle<Image>,
+///     #[storage(3, read_only)]
+///     storage_buffer: Handle<ShaderStorageBuffer>,
+///     #[storage(4, read_only, buffer)]
+///     raw_buffer: Buffer,
+///     #[storage_texture(5)]
+///     storage_texture: Handle<Image>,
+/// }
+/// ```
+///
+/// In WGSL shaders, the binding would look like this:
+///
+/// ```wgsl
+/// @group(2) @binding(0) var<uniform> color: vec4<f32>;
+/// @group(2) @binding(1) var color_texture: texture_2d<f32>;
+/// @group(2) @binding(2) var color_sampler: sampler;
+/// @group(2) @binding(3) var<storage> storage_buffer: array<f32>;
+/// @group(2) @binding(4) var<storage> raw_buffer: array<f32>;
+/// @group(2) @binding(5) var storage_texture: texture_storage_2d<rgba8unorm, read_write>;
+/// ```
+/// Note that the "group" index is determined by the usage context. It is not defined in [`AsBindGroup`]. For example, in Bevy material bind groups
+/// are generally bound to group 2.
+///
+/// The following field-level attributes are supported:
+///
+/// ## `uniform(BINDING_INDEX)`
+///
+///  * The field will be converted to a shader-compatible type using the [`ShaderType`] trait, written to a [`Buffer`], and bound as a uniform.
+///    [`ShaderType`] is implemented for most math types already, such as [`f32`], [`Vec4`](bevy_math::Vec4), and
+///    [`LinearRgba`](bevy_color::LinearRgba). It can also be derived for custom structs.
+///
+/// ## `texture(BINDING_INDEX, arguments)`
+///
+///  * This field's [`Handle<Image>`](bevy_asset::Handle) will be used to look up the matching [`Texture`](crate::render_resource::Texture)
+///    GPU resource, which will be bound as a texture in shaders. The field will be assumed to implement [`Into<Option<Handle<Image>>>`]. In practice,
+///    most fields should be a [`Handle<Image>`](bevy_asset::Handle) or [`Option<Handle<Image>>`]. If the value of an [`Option<Handle<Image>>`] is
+///    [`None`], the [`crate::texture::FallbackImage`] resource will be used instead. This attribute can be used in conjunction with a `sampler` binding attribute
+///    (with a different binding index) if a binding of the sampler for the [`Image`](bevy_image::Image) is also required.
+///
+/// | Arguments             | Values                                                                  | Default              |
+/// |-----------------------|-------------------------------------------------------------------------|----------------------|
+/// | `dimension` = "..."   | `"1d"`, `"2d"`, `"2d_array"`, `"3d"`, `"cube"`, `"cube_array"`          | `"2d"`               |
+/// | `sample_type` = "..." | `"float"`, `"depth"`, `"s_int"` or `"u_int"`                            | `"float"`            |
+/// | `filterable` = ...    | `true`, `false`                                                         | `true`               |
+/// | `multisampled` = ...  | `true`, `false`                                                         | `false`              |
+/// | `visibility(...)`     | `all`, `none`, or a list-combination of `vertex`, `fragment`, `compute` | `vertex`, `fragment` |
+///
+/// ## `storage_texture(BINDING_INDEX, arguments)`
+///
+/// * This field's [`Handle<Image>`](bevy_asset::Handle) will be used to look up the matching [`Texture`](crate::render_resource::Texture)
+///   GPU resource, which will be bound as a storage texture in shaders. The field will be assumed to implement [`Into<Option<Handle<Image>>>`]. In practice,
+///   most fields should be a [`Handle<Image>`](bevy_asset::Handle) or [`Option<Handle<Image>>`]. If the value of an [`Option<Handle<Image>>`] is
+///   [`None`], the [`crate::texture::FallbackImage`] resource will be used instead.
+///
+/// | Arguments              | Values                                                                                     | Default       |
+/// |------------------------|--------------------------------------------------------------------------------------------|---------------|
+/// | `dimension` = "..."    | `"1d"`, `"2d"`, `"2d_array"`, `"3d"`, `"cube"`, `"cube_array"`                             | `"2d"`        |
+/// | `image_format` = ...   | any member of [`TextureFormat`](crate::render_resource::TextureFormat)                     | `Rgba8Unorm`  |
+/// | `access` = ...         | any member of [`StorageTextureAccess`](crate::render_resource::StorageTextureAccess)       | `ReadWrite`   |
+/// | `visibility(...)`      | `all`, `none`, or a list-combination of `vertex`, `fragment`, `compute`                    | `compute`     |
+///
+/// ## `sampler(BINDING_INDEX, arguments)`
+///
+/// * This field's [`Handle<Image>`](bevy_asset::Handle) will be used to look up the matching [`Sampler`] GPU
+///   resource, which will be bound as a sampler in shaders. The field will be assumed to implement [`Into<Option<Handle<Image>>>`]. In practice,
+///   most fields should be a [`Handle<Image>`](bevy_asset::Handle) or [`Option<Handle<Image>>`]. If the value of an [`Option<Handle<Image>>`] is
+///   [`None`], the [`crate::texture::FallbackImage`] resource will be used instead. This attribute can be used in conjunction with a `texture` binding attribute
+///   (with a different binding index) if a binding of the texture for the [`Image`](bevy_image::Image) is also required.
+///
+/// | Arguments              | Values                                                                  | Default                |
+/// |------------------------|-------------------------------------------------------------------------|------------------------|
+/// | `sampler_type` = "..." | `"filtering"`, `"non_filtering"`, `"comparison"`.                       |  `"filtering"`         |
+/// | `visibility(...)`      | `all`, `none`, or a list-combination of `vertex`, `fragment`, `compute` |   `vertex`, `fragment` |
+///
+/// ## `storage(BINDING_INDEX, arguments)`
+///
+/// * The field's [`Handle<Storage>`](bevy_asset::Handle) will be used to look
+///   up the matching [`Buffer`] GPU resource, which will be bound as a storage
+///   buffer in shaders. If the `storage` attribute is used, the field is expected
+///   a raw buffer, and the buffer will be bound as a storage buffer in shaders.
+///   In bindless mode, `binding_array()` argument that specifies the binding
+///   number of the resulting storage buffer binding array must be present.
+///
+/// | Arguments              | Values                                                                  | Default                |
+/// |------------------------|-------------------------------------------------------------------------|------------------------|
+/// | `visibility(...)`      | `all`, `none`, or a list-combination of `vertex`, `fragment`, `compute` | `vertex`, `fragment`   |
+/// | `read_only`            | if present then value is true, otherwise false                          | `false`                |
+/// | `buffer`               | if present then the field will be assumed to be a raw wgpu buffer       |                        |
+/// | `binding_array(...)`   | the binding number of the binding array, for bindless mode              | bindless mode disabled |
+///
+/// Note that fields without field-level binding attributes will be ignored.
+/// ```
+/// # use bevy_render::{render_resource::AsBindGroup};
+/// # use bevy_color::LinearRgba;
+/// # use bevy_asset::Handle;
+/// #[derive(AsBindGroup)]
+/// struct CoolMaterial {
+///     #[uniform(0)]
+///     color: LinearRgba,
+///     this_field_is_ignored: String,
+/// }
+/// ```
+///
+///  As mentioned above, [`Option<Handle<Image>>`] is also supported:
+/// ```
+/// # use bevy_asset::Handle;
+/// # use bevy_color::LinearRgba;
+/// # use bevy_image::Image;
+/// # use bevy_render::render_resource::AsBindGroup;
+/// #[derive(AsBindGroup)]
+/// struct CoolMaterial {
+///     #[uniform(0)]
+///     color: LinearRgba,
+///     #[texture(1)]
+///     #[sampler(2)]
+///     color_texture: Option<Handle<Image>>,
+/// }
+/// ```
+/// This is useful if you want a texture to be optional. When the value is [`None`], the [`crate::texture::FallbackImage`] will be used for the binding instead, which defaults
+/// to "pure white".
+///
+/// Field uniforms with the same index will be combined into a single binding:
+/// ```
+/// # use bevy_render::{render_resource::AsBindGroup};
+/// # use bevy_color::LinearRgba;
+/// #[derive(AsBindGroup)]
+/// struct CoolMaterial {
+///     #[uniform(0)]
+///     color: LinearRgba,
+///     #[uniform(0)]
+///     roughness: f32,
+/// }
+/// ```
+///
+/// In WGSL shaders, the binding would look like this:
+/// ```wgsl
+/// struct CoolMaterial {
+///     color: vec4<f32>,
+///     roughness: f32,
+/// };
+///
+/// @group(2) @binding(0) var<uniform> material: CoolMaterial;
+/// ```
+///
+/// Some less common scenarios will require "struct-level" attributes. These are the currently supported struct-level attributes:
+/// ## `uniform(BINDING_INDEX, ConvertedShaderType)`
+///
+/// * This also creates a [`Buffer`] using [`ShaderType`] and binds it as a
+///   uniform, much like the field-level `uniform` attribute. The difference is
+///   that the entire [`AsBindGroup`] value is converted to `ConvertedShaderType`,
+///   which must implement [`ShaderType`], instead of a specific field
+///   implementing [`ShaderType`]. This is useful if more complicated conversion
+///   logic is required, or when using bindless mode (see below). The conversion
+///   is done using the [`AsBindGroupShaderType<ConvertedShaderType>`] trait,
+///   which is automatically implemented if `&Self` implements
+///   [`Into<ConvertedShaderType>`]. Outside of bindless mode, only use
+///   [`AsBindGroupShaderType`] if access to resources like
+///   [`RenderAssets<GpuImage>`] is required.
+///
+/// * In bindless mode (see `bindless(COUNT)`), this attribute becomes
+///   `uniform(BINDLESS_INDEX, ConvertedShaderType,
+///   binding_array(BINDING_INDEX))`. The resulting uniform buffers will be
+///   available in the shader as a binding array at the given `BINDING_INDEX`. The
+///   `BINDLESS_INDEX` specifies the offset of the buffer in the bindless index
+///   table.
+///
+///   For example, suppose that the material slot is stored in a variable named
+///   `slot`, the bindless index table is named `material_indices`, and that the
+///   first field (index 0) of the bindless index table type is named
+///   `material`. Then specifying `#[uniform(0, StandardMaterialUniform,
+///   binding_array(10)]` will create a binding array buffer declared in the
+///   shader as `var<storage> material_array:
+///   binding_array<StandardMaterialUniform>` and accessible as
+///   `material_array[material_indices[slot].material]`.
+///
+/// ## `data(BINDING_INDEX, ConvertedShaderType, binding_array(BINDING_INDEX))`
+///
+/// * This is very similar to `uniform(BINDING_INDEX, ConvertedShaderType,
+///   binding_array(BINDING_INDEX)` and in fact is identical if bindless mode
+///   isn't being used. The difference is that, in bindless mode, the `data`
+///   attribute produces a single buffer containing an array, not an array of
+///   buffers. For example, suppose you had the following declaration:
+///
+/// ```ignore
+/// #[uniform(0, StandardMaterialUniform, binding_array(10))]
+/// struct StandardMaterial { ... }
+/// ```
+///
+/// In bindless mode, this will produce a binding matching the following WGSL
+/// declaration:
+///
+/// ```wgsl
+/// @group(2) @binding(10) var<storage> material_array: binding_array<StandardMaterial>;
+/// ```
+///
+/// On the other hand, if you write this declaration:
+///
+/// ```ignore
+/// #[data(0, StandardMaterialUniform, binding_array(10))]
+/// struct StandardMaterial { ... }
+/// ```
+///
+/// Then Bevy produces a binding that matches this WGSL declaration instead:
+///
+/// ```wgsl
+/// @group(2) @binding(10) var<storage> material_array: array<StandardMaterial>;
+/// ```
+///
+/// * Just as with the structure-level `uniform` attribute, Bevy converts the
+///   entire [`AsBindGroup`] to `ConvertedShaderType`, using the
+///   [`AsBindGroupShaderType<ConvertedShaderType>`] trait.
+///
+/// * In non-bindless mode, the structure-level `data` attribute is the same as
+///   the structure-level `uniform` attribute and produces a single uniform buffer
+///   in the shader. The above example would result in a binding that looks like
+///   this in WGSL in non-bindless mode:
+///
+/// ```wgsl
+/// @group(2) @binding(0) var<uniform> material: StandardMaterial;
+/// ```
+///
+/// * For efficiency reasons, `data` is generally preferred over `uniform`
+///   unless you need to place your data in individual buffers.
+///
+/// ## `bind_group_data(DataType)`
+///
+/// * The [`AsBindGroup`] type will be converted to some `DataType` using [`Into<DataType>`] and stored
+///   as [`AsBindGroup::Data`] as part of the [`AsBindGroup::as_bind_group`] call. This is useful if data needs to be stored alongside
+///   the generated bind group, such as a unique identifier for a material's bind group. The most common use case for this attribute
+///   is "shader pipeline specialization". See [`SpecializedRenderPipeline`](crate::render_resource::SpecializedRenderPipeline).
+///
+/// ## `bindless`
+///
+/// * This switch enables *bindless resources*, which changes the way Bevy
+///   supplies resources (textures, and samplers) to the shader.  When bindless
+///   resources are enabled, and the current platform supports them, Bevy will
+///   allocate textures, and samplers into *binding arrays*, separated based on
+///   type and will supply your shader with indices into those arrays.
+/// * Bindless textures and samplers are placed into the appropriate global
+///   array defined in `bevy_render::bindless` (`bindless.wgsl`).
+/// * Bevy doesn't currently support bindless buffers, except for those created
+///   with the `uniform(BINDLESS_INDEX, ConvertedShaderType,
+///   binding_array(BINDING_INDEX))` attribute. If you need to include a buffer in
+///   your object, and you can't create the data in that buffer with the `uniform`
+///   attribute, consider a non-bindless object instead.
+/// * If bindless mode is enabled, the `BINDLESS` definition will be
+///   available. Because not all platforms support bindless resources, you
+///   should check for the presence of this definition via `#ifdef` and fall
+///   back to standard bindings if it isn't present.
+/// * By default, in bindless mode, binding 0 becomes the *bindless index
+///   table*, which is an array of structures, each of which contains as many
+///   fields of type `u32` as the highest binding number in the structure
+///   annotated with `#[derive(AsBindGroup)]`. Again by default, the *i*th field
+///   of the bindless index table contains the index of the resource with binding
+///   *i* within the appropriate binding array.
+/// * In the case of materials, the index of the applicable table within the
+///   bindless index table list corresponding to the mesh currently being drawn
+///   can be retrieved with
+///   `mesh[in.instance_index].material_and_lightmap_bind_group_slot & 0xffffu`.
+/// * You can limit the size of the bindless slabs to N resources with the
+///   `limit(N)` declaration. For example, `#[bindless(limit(16))]` ensures that
+///   each slab will have no more than 16 total resources in it. If you don't
+///   specify a limit, Bevy automatically picks a reasonable one for the current
+///   platform.
+/// * The `index_table(range(M..N), binding(B))` declaration allows you to
+///   customize the layout of the bindless index table. This is useful for
+///   materials that are composed of multiple bind groups, such as
+///   `ExtendedMaterial`. In such cases, there will be multiple bindless index
+///   tables, so they can't both be assigned to binding 0 or their bindings will
+///   conflict.
+///   - The `binding(B)` attribute of the `index_table` attribute allows you to
+///     customize the binding (`@binding(B)`, in the shader) at which the index
+///     table will be bound.
+///   - The `range(M, N)` attribute of the `index_table` attribute allows you to
+///     change the mapping from the field index in the bindless index table to the
+///     bindless index. Instead of the field at index $i$ being mapped to the
+///     bindless index $i$, with the `range(M, N)` attribute the field at index
+///     $i$ in the bindless index table is mapped to the bindless index $i$ + M.
+///     The size of the index table will be set to N - M. Note that this may
+///     result in the table being too small to contain all the bindless bindings.
+/// * The purpose of bindless mode is to improve performance by reducing
+///   state changes. By grouping resources together into binding arrays, Bevy
+///   doesn't have to modify GPU state as often, decreasing API and driver
+///   overhead.
+/// * See the `shaders/shader_material_bindless` example for an example of how
+///   to use bindless mode. See the `shaders/extended_material_bindless` example
+///   for a more exotic example of bindless mode that demonstrates the
+///   `index_table` attribute.
+/// * The following diagram illustrates how bindless mode works using a subset
+///   of `StandardMaterial`:
+///
+/// ```text
+///      Shader Bindings                          Sampler Binding Array
+///     +----+-----------------------------+     +-----------+-----------+-----+
+/// +---|  0 | material_indices            |  +->| sampler 0 | sampler 1 | ... |
+/// |   +----+-----------------------------+  |  +-----------+-----------+-----+
+/// |   |  1 | bindless_samplers_filtering +--+        ^
+/// |   +----+-----------------------------+           +-------------------------------+
+/// |   | .. |            ...              |                                           |
+/// |   +----+-----------------------------+      Texture Binding Array                |
+/// |   |  5 | bindless_textures_2d        +--+  +-----------+-----------+-----+       |
+/// |   +----+-----------------------------+  +->| texture 0 | texture 1 | ... |       |
+/// |   | .. |            ...              |     +-----------+-----------+-----+       |
+/// |   +----+-----------------------------+           ^                               |
+/// |   + 10 | material_array              +--+        +---------------------------+   |
+/// |   +----+-----------------------------+  |                                    |   |
+/// |                                         |   Buffer Binding Array             |   |
+/// |                                         |  +----------+----------+-----+     |   |
+/// |                                         +->| buffer 0 | buffer 1 | ... |     |   |
+/// |    Material Bindless Indices               +----------+----------+-----+     |   |
+/// |   +----+-----------------------------+          ^                            |   |
+/// +-->|  0 | material                    +----------+                            |   |
+///     +----+-----------------------------+                                       |   |
+///     |  1 | base_color_texture          +---------------------------------------+   |
+///     +----+-----------------------------+                                           |
+///     |  2 | base_color_sampler          +-------------------------------------------+
+///     +----+-----------------------------+
+///     | .. |            ...              |
+///     +----+-----------------------------+
+/// ```
+///
+/// The previous `CoolMaterial` example illustrating "combining multiple field-level uniform attributes with the same binding index" can
+/// also be equivalently represented with a single struct-level uniform attribute:
+/// ```
+/// # use bevy_render::{render_resource::{AsBindGroup, ShaderType}};
+/// # use bevy_color::LinearRgba;
+/// #[derive(AsBindGroup)]
+/// #[uniform(0, CoolMaterialUniform)]
+/// struct CoolMaterial {
+///     color: LinearRgba,
+///     roughness: f32,
+/// }
+///
+/// #[derive(ShaderType)]
+/// struct CoolMaterialUniform {
+///     color: LinearRgba,
+///     roughness: f32,
+/// }
+///
+/// impl From<&CoolMaterial> for CoolMaterialUniform {
+///     fn from(material: &CoolMaterial) -> CoolMaterialUniform {
+///         CoolMaterialUniform {
+///             color: material.color,
+///             roughness: material.roughness,
+///         }
+///     }
+/// }
+/// ```
+///
+/// Setting `bind_group_data` looks like this:
+/// ```
+/// # use bevy_render::{render_resource::AsBindGroup};
+/// # use bevy_color::LinearRgba;
+/// #[derive(AsBindGroup)]
+/// #[bind_group_data(CoolMaterialKey)]
+/// struct CoolMaterial {
+///     #[uniform(0)]
+///     color: LinearRgba,
+///     is_shaded: bool,
+/// }
+///
+/// #[derive(Copy, Clone, Hash, Eq, PartialEq)]
+/// struct CoolMaterialKey {
+///     is_shaded: bool,
+/// }
+///
+/// impl From<&CoolMaterial> for CoolMaterialKey {
+///     fn from(material: &CoolMaterial) -> CoolMaterialKey {
+///         CoolMaterialKey {
+///             is_shaded: material.is_shaded,
+///         }
+///     }
+/// }
+/// ```
+pub trait AsBindGroup {
+    /// Data that will be stored alongside the "prepared" bind group.
+    type Data: Send + Sync;
+
+    type Param: SystemParam + 'static;
+
+    /// The number of slots per bind group, if bindless mode is enabled.
+    ///
+    /// If this bind group doesn't use bindless, then this will be `None`.
+    ///
+    /// Note that the *actual* slot count may be different from this value, due
+    /// to platform limitations. For example, if bindless resources aren't
+    /// supported on this platform, the actual slot count will be 1.
+    fn bindless_slot_count() -> Option<BindlessSlabResourceLimit> {
+        None
+    }
+
+    /// True if the hardware *actually* supports bindless textures for this
+    /// type, taking the device and driver capabilities into account.
+    ///
+    /// If this type doesn't use bindless textures, then the return value from
+    /// this function is meaningless.
+    fn bindless_supported(_: &RenderDevice) -> bool {
+        true
+    }
+
+    /// label
+    fn label() -> Option<&'static str> {
+        None
+    }
+
+    /// Creates a bind group for `self` matching the layout defined in [`AsBindGroup::bind_group_layout`].
+    fn as_bind_group(
+        &self,
+        layout: &BindGroupLayout,
+        render_device: &RenderDevice,
+        param: &mut SystemParamItem<'_, '_, Self::Param>,
+    ) -> Result<PreparedBindGroup<Self::Data>, AsBindGroupError> {
+        let UnpreparedBindGroup { bindings, data } =
+            Self::unprepared_bind_group(self, layout, render_device, param, false)?;
+
+        let entries = bindings
+            .iter()
+            .map(|(index, binding)| BindGroupEntry {
+                binding: *index,
+                resource: binding.get_binding(),
+            })
+            .collect::<Vec<_>>();
+
+        let bind_group = render_device.create_bind_group(Self::label(), layout, &entries);
+
+        Ok(PreparedBindGroup {
+            bindings,
+            bind_group,
+            data,
+        })
+    }
+
+    /// Returns a vec of (binding index, `OwnedBindingResource`).
+    ///
+    /// In cases where `OwnedBindingResource` is not available (as for bindless
+    /// texture arrays currently), an implementor may return
+    /// `AsBindGroupError::CreateBindGroupDirectly` from this function and
+    /// instead define `as_bind_group` directly. This may prevent certain
+    /// features, such as bindless mode, from working correctly.
+    ///
+    /// Set `force_no_bindless` to true to require that bindless textures *not*
+    /// be used. `ExtendedMaterial` uses this in order to ensure that the base
+    /// material doesn't use bindless mode if the extension doesn't.
+    fn unprepared_bind_group(
+        &self,
+        layout: &BindGroupLayout,
+        render_device: &RenderDevice,
+        param: &mut SystemParamItem<'_, '_, Self::Param>,
+        force_no_bindless: bool,
+    ) -> Result<UnpreparedBindGroup<Self::Data>, AsBindGroupError>;
+
+    /// Creates the bind group layout matching all bind groups returned by
+    /// [`AsBindGroup::as_bind_group`]
+    fn bind_group_layout(render_device: &RenderDevice) -> BindGroupLayout
+    where
+        Self: Sized,
+    {
+        render_device.create_bind_group_layout(
+            Self::label(),
+            &Self::bind_group_layout_entries(render_device, false),
+        )
+    }
+
+    /// Returns a vec of bind group layout entries.
+    ///
+    /// Set `force_no_bindless` to true to require that bindless textures *not*
+    /// be used. `ExtendedMaterial` uses this in order to ensure that the base
+    /// material doesn't use bindless mode if the extension doesn't.
+    fn bind_group_layout_entries(
+        render_device: &RenderDevice,
+        force_no_bindless: bool,
+    ) -> Vec<BindGroupLayoutEntry>
+    where
+        Self: Sized;
+
+    fn bindless_descriptor() -> Option<BindlessDescriptor> {
+        None
+    }
+}
+
+/// An error that occurs during [`AsBindGroup::as_bind_group`] calls.
+#[derive(Debug, Error)]
+pub enum AsBindGroupError {
+    /// The bind group could not be generated. Try again next frame.
+    #[error("The bind group could not be generated")]
+    RetryNextUpdate,
+    #[error("Create the bind group via `as_bind_group()` instead")]
+    CreateBindGroupDirectly,
+    #[error("At binding index {0}, the provided image sampler `{1}` does not match the required sampler type(s) `{2}`.")]
+    InvalidSamplerType(u32, String, String),
+}
+
+/// A prepared bind group returned as a result of [`AsBindGroup::as_bind_group`].
+pub struct PreparedBindGroup<T> {
+    pub bindings: BindingResources,
+    pub bind_group: BindGroup,
+    pub data: T,
+}
+
+/// a map containing `OwnedBindingResource`s, keyed by the target binding index
+pub struct UnpreparedBindGroup<T> {
+    pub bindings: BindingResources,
+    pub data: T,
+}
+
+/// A pair of binding index and binding resource, used as part of
+/// [`PreparedBindGroup`] and [`UnpreparedBindGroup`].
+#[derive(Deref, DerefMut)]
+pub struct BindingResources(pub Vec<(u32, OwnedBindingResource)>);
+
+/// An owned binding resource of any type (ex: a [`Buffer`], [`TextureView`], etc).
+/// This is used by types like [`PreparedBindGroup`] to hold a single list of all
+/// render resources used by bindings.
+#[derive(Debug)]
+pub enum OwnedBindingResource {
+    Buffer(Buffer),
+    TextureView(TextureViewDimension, TextureView),
+    Sampler(SamplerBindingType, Sampler),
+    Data(OwnedData),
+}
+
+/// Data that will be copied into a GPU buffer.
+///
+/// This corresponds to the `#[data]` attribute in `AsBindGroup`.
+#[derive(Debug, Deref, DerefMut)]
+pub struct OwnedData(pub Vec<u8>);
+
+impl OwnedBindingResource {
+    /// Creates a [`BindingResource`] reference to this
+    /// [`OwnedBindingResource`].
+    ///
+    /// Note that this operation panics if passed a
+    /// [`OwnedBindingResource::Data`], because [`OwnedData`] doesn't itself
+    /// correspond to any binding and instead requires the
+    /// `MaterialBindGroupAllocator` to pack it into a buffer.
+    pub fn get_binding(&self) -> BindingResource {
+        match self {
+            OwnedBindingResource::Buffer(buffer) => buffer.as_entire_binding(),
+            OwnedBindingResource::TextureView(_, view) => BindingResource::TextureView(view),
+            OwnedBindingResource::Sampler(_, sampler) => BindingResource::Sampler(sampler),
+            OwnedBindingResource::Data(_) => panic!("`OwnedData` has no binding resource"),
+        }
+    }
+}
+
+/// Converts a value to a [`ShaderType`] for use in a bind group.
+///
+/// This is automatically implemented for references that implement [`Into`].
+/// Generally normal [`Into`] / [`From`] impls should be preferred, but
+/// sometimes additional runtime metadata is required.
+/// This exists largely to make some [`AsBindGroup`] use cases easier.
+pub trait AsBindGroupShaderType<T: ShaderType> {
+    /// Return the `T` [`ShaderType`] for `self`. When used in [`AsBindGroup`]
+    /// derives, it is safe to assume that all images in `self` exist.
+    fn as_bind_group_shader_type(&self, images: &RenderAssets<GpuImage>) -> T;
+}
+
+impl<T, U: ShaderType> AsBindGroupShaderType<U> for T
+where
+    for<'a> &'a T: Into<U>,
+{
+    #[inline]
+    fn as_bind_group_shader_type(&self, _images: &RenderAssets<GpuImage>) -> U {
+        self.into()
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    use bevy_asset::Handle;
+    use bevy_image::Image;
+
+    #[test]
+    fn texture_visibility() {
+        #[derive(AsBindGroup)]
+        pub struct TextureVisibilityTest {
+            #[texture(0, visibility(all))]
+            pub all: Handle<Image>,
+            #[texture(1, visibility(none))]
+            pub none: Handle<Image>,
+            #[texture(2, visibility(fragment))]
+            pub fragment: Handle<Image>,
+            #[texture(3, visibility(vertex))]
+            pub vertex: Handle<Image>,
+            #[texture(4, visibility(compute))]
+            pub compute: Handle<Image>,
+            #[texture(5, visibility(vertex, fragment))]
+            pub vertex_fragment: Handle<Image>,
+            #[texture(6, visibility(vertex, compute))]
+            pub vertex_compute: Handle<Image>,
+            #[texture(7, visibility(fragment, compute))]
+            pub fragment_compute: Handle<Image>,
+            #[texture(8, visibility(vertex, fragment, compute))]
+            pub vertex_fragment_compute: Handle<Image>,
+        }
+    }
+}

vendor/bevy_render/src/render_resource/bind_group_entries.rs

@@ -0,0 +1,289 @@
+use variadics_please::all_tuples_with_size;
+use wgpu::{BindGroupEntry, BindingResource};
+
+use super::{Sampler, TextureView};
+
+/// Helper for constructing bindgroups.
+///
+/// Allows constructing the descriptor's entries as:
+/// ```ignore (render_device cannot be easily accessed)
+/// render_device.create_bind_group(
+///     "my_bind_group",
+///     &my_layout,
+///     &BindGroupEntries::with_indices((
+///         (2, &my_sampler),
+///         (3, my_uniform),
+///     )),
+/// );
+/// ```
+///
+/// instead of
+///
+/// ```ignore (render_device cannot be easily accessed)
+/// render_device.create_bind_group(
+///     "my_bind_group",
+///     &my_layout,
+///     &[
+///         BindGroupEntry {
+///             binding: 2,
+///             resource: BindingResource::Sampler(&my_sampler),
+///         },
+///         BindGroupEntry {
+///             binding: 3,
+///             resource: my_uniform,
+///         },
+///     ],
+/// );
+/// ```
+///
+/// or
+///
+/// ```ignore (render_device cannot be easily accessed)
+/// render_device.create_bind_group(
+///     "my_bind_group",
+///     &my_layout,
+///     &BindGroupEntries::sequential((
+///         &my_sampler,
+///         my_uniform,
+///     )),
+/// );
+/// ```
+///
+/// instead of
+///
+/// ```ignore (render_device cannot be easily accessed)
+/// render_device.create_bind_group(
+///     "my_bind_group",
+///     &my_layout,
+///     &[
+///         BindGroupEntry {
+///             binding: 0,
+///             resource: BindingResource::Sampler(&my_sampler),
+///         },
+///         BindGroupEntry {
+///             binding: 1,
+///             resource: my_uniform,
+///         },
+///     ],
+/// );
+/// ```
+///
+/// or
+///
+/// ```ignore (render_device cannot be easily accessed)
+/// render_device.create_bind_group(
+///     "my_bind_group",
+///     &my_layout,
+///     &BindGroupEntries::single(my_uniform),
+/// );
+/// ```
+///
+/// instead of
+///
+/// ```ignore (render_device cannot be easily accessed)
+/// render_device.create_bind_group(
+///     "my_bind_group",
+///     &my_layout,
+///     &[
+///         BindGroupEntry {
+///             binding: 0,
+///             resource: my_uniform,
+///         },
+///     ],
+/// );
+/// ```
+pub struct BindGroupEntries<'b, const N: usize = 1> {
+    entries: [BindGroupEntry<'b>; N],
+}
+
+impl<'b, const N: usize> BindGroupEntries<'b, N> {
+    #[inline]
+    pub fn sequential(resources: impl IntoBindingArray<'b, N>) -> Self {
+        let mut i = 0;
+        Self {
+            entries: resources.into_array().map(|resource| {
+                let binding = i;
+                i += 1;
+                BindGroupEntry { binding, resource }
+            }),
+        }
+    }
+
+    #[inline]
+    pub fn with_indices(indexed_resources: impl IntoIndexedBindingArray<'b, N>) -> Self {
+        Self {
+            entries: indexed_resources
+                .into_array()
+                .map(|(binding, resource)| BindGroupEntry { binding, resource }),
+        }
+    }
+}
+
+impl<'b> BindGroupEntries<'b, 1> {
+    pub fn single(resource: impl IntoBinding<'b>) -> [BindGroupEntry<'b>; 1] {
+        [BindGroupEntry {
+            binding: 0,
+            resource: resource.into_binding(),
+        }]
+    }
+}
+
+impl<'b, const N: usize> core::ops::Deref for BindGroupEntries<'b, N> {
+    type Target = [BindGroupEntry<'b>];
+
+    fn deref(&self) -> &[BindGroupEntry<'b>] {
+        &self.entries
+    }
+}
+
+pub trait IntoBinding<'a> {
+    fn into_binding(self) -> BindingResource<'a>;
+}
+
+impl<'a> IntoBinding<'a> for &'a TextureView {
+    #[inline]
+    fn into_binding(self) -> BindingResource<'a> {
+        BindingResource::TextureView(self)
+    }
+}
+
+impl<'a> IntoBinding<'a> for &'a [&'a wgpu::TextureView] {
+    #[inline]
+    fn into_binding(self) -> BindingResource<'a> {
+        BindingResource::TextureViewArray(self)
+    }
+}
+
+impl<'a> IntoBinding<'a> for &'a Sampler {
+    #[inline]
+    fn into_binding(self) -> BindingResource<'a> {
+        BindingResource::Sampler(self)
+    }
+}
+
+impl<'a> IntoBinding<'a> for BindingResource<'a> {
+    #[inline]
+    fn into_binding(self) -> BindingResource<'a> {
+        self
+    }
+}
+
+impl<'a> IntoBinding<'a> for wgpu::BufferBinding<'a> {
+    #[inline]
+    fn into_binding(self) -> BindingResource<'a> {
+        BindingResource::Buffer(self)
+    }
+}
+
+pub trait IntoBindingArray<'b, const N: usize> {
+    fn into_array(self) -> [BindingResource<'b>; N];
+}
+
+macro_rules! impl_to_binding_slice {
+    ($N: expr, $(#[$meta:meta])* $(($T: ident, $I: ident)),*) => {
+        $(#[$meta])*
+        impl<'b, $($T: IntoBinding<'b>),*> IntoBindingArray<'b, $N> for ($($T,)*) {
+            #[inline]
+            fn into_array(self) -> [BindingResource<'b>; $N] {
+                let ($($I,)*) = self;
+                [$($I.into_binding(), )*]
+            }
+        }
+    }
+}
+
+all_tuples_with_size!(
+    #[doc(fake_variadic)]
+    impl_to_binding_slice,
+    1,
+    32,
+    T,
+    s
+);
+
+pub trait IntoIndexedBindingArray<'b, const N: usize> {
+    fn into_array(self) -> [(u32, BindingResource<'b>); N];
+}
+
+macro_rules! impl_to_indexed_binding_slice {
+    ($N: expr, $(($T: ident, $S: ident, $I: ident)),*) => {
+        impl<'b, $($T: IntoBinding<'b>),*> IntoIndexedBindingArray<'b, $N> for ($((u32, $T),)*) {
+            #[inline]
+            fn into_array(self) -> [(u32, BindingResource<'b>); $N] {
+                let ($(($S, $I),)*) = self;
+                [$(($S, $I.into_binding())), *]
+            }
+        }
+    }
+}
+
+all_tuples_with_size!(impl_to_indexed_binding_slice, 1, 32, T, n, s);
+
+pub struct DynamicBindGroupEntries<'b> {
+    entries: Vec<BindGroupEntry<'b>>,
+}
+
+impl<'b> DynamicBindGroupEntries<'b> {
+    pub fn sequential<const N: usize>(entries: impl IntoBindingArray<'b, N>) -> Self {
+        Self {
+            entries: entries
+                .into_array()
+                .into_iter()
+                .enumerate()
+                .map(|(ix, resource)| BindGroupEntry {
+                    binding: ix as u32,
+                    resource,
+                })
+                .collect(),
+        }
+    }
+
+    pub fn extend_sequential<const N: usize>(
+        mut self,
+        entries: impl IntoBindingArray<'b, N>,
+    ) -> Self {
+        let start = self.entries.last().unwrap().binding + 1;
+        self.entries.extend(
+            entries
+                .into_array()
+                .into_iter()
+                .enumerate()
+                .map(|(ix, resource)| BindGroupEntry {
+                    binding: start + ix as u32,
+                    resource,
+                }),
+        );
+        self
+    }
+
+    pub fn new_with_indices<const N: usize>(entries: impl IntoIndexedBindingArray<'b, N>) -> Self {
+        Self {
+            entries: entries
+                .into_array()
+                .into_iter()
+                .map(|(binding, resource)| BindGroupEntry { binding, resource })
+                .collect(),
+        }
+    }
+
+    pub fn extend_with_indices<const N: usize>(
+        mut self,
+        entries: impl IntoIndexedBindingArray<'b, N>,
+    ) -> Self {
+        self.entries.extend(
+            entries
+                .into_array()
+                .into_iter()
+                .map(|(binding, resource)| BindGroupEntry { binding, resource }),
+        );
+        self
+    }
+}
+
+impl<'b> core::ops::Deref for DynamicBindGroupEntries<'b> {
+    type Target = [BindGroupEntry<'b>];
+
+    fn deref(&self) -> &[BindGroupEntry<'b>] {
+        &self.entries
+    }
+}

vendor/bevy_render/src/render_resource/bind_group_layout.rs

@@ -0,0 +1,64 @@
+use crate::define_atomic_id;
+use crate::renderer::WgpuWrapper;
+use core::ops::Deref;
+
+define_atomic_id!(BindGroupLayoutId);
+
+/// Bind group layouts define the interface of resources (e.g. buffers, textures, samplers)
+/// for a shader. The actual resource binding is done via a [`BindGroup`](super::BindGroup).
+///
+/// This is a lightweight thread-safe wrapper around wgpu's own [`BindGroupLayout`](wgpu::BindGroupLayout),
+/// which can be cloned as needed to workaround lifetime management issues. It may be converted
+/// from and dereferences to wgpu's [`BindGroupLayout`](wgpu::BindGroupLayout).
+///
+/// Can be created via [`RenderDevice::create_bind_group_layout`](crate::RenderDevice::create_bind_group_layout).
+#[derive(Clone, Debug)]
+pub struct BindGroupLayout {
+    id: BindGroupLayoutId,
+    value: WgpuWrapper<wgpu::BindGroupLayout>,
+}
+
+impl PartialEq for BindGroupLayout {
+    fn eq(&self, other: &Self) -> bool {
+        self.id == other.id
+    }
+}
+
+impl Eq for BindGroupLayout {}
+
+impl core::hash::Hash for BindGroupLayout {
+    fn hash<H: core::hash::Hasher>(&self, state: &mut H) {
+        self.id.0.hash(state);
+    }
+}
+
+impl BindGroupLayout {
+    /// Returns the [`BindGroupLayoutId`] representing the unique ID of the bind group layout.
+    #[inline]
+    pub fn id(&self) -> BindGroupLayoutId {
+        self.id
+    }
+
+    #[inline]
+    pub fn value(&self) -> &wgpu::BindGroupLayout {
+        &self.value
+    }
+}
+
+impl From<wgpu::BindGroupLayout> for BindGroupLayout {
+    fn from(value: wgpu::BindGroupLayout) -> Self {
+        BindGroupLayout {
+            id: BindGroupLayoutId::new(),
+            value: WgpuWrapper::new(value),
+        }
+    }
+}
+
+impl Deref for BindGroupLayout {
+    type Target = wgpu::BindGroupLayout;
+
+    #[inline]
+    fn deref(&self) -> &Self::Target {
+        &self.value
+    }
+}

vendor/bevy_render/src/render_resource/bind_group_layout_entries.rs

@@ -0,0 +1,571 @@
+use core::num::NonZero;
+use variadics_please::all_tuples_with_size;
+use wgpu::{BindGroupLayoutEntry, BindingType, ShaderStages};
+
+/// Helper for constructing bind group layouts.
+///
+/// Allows constructing the layout's entries as:
+/// ```ignore (render_device cannot be easily accessed)
+/// let layout = render_device.create_bind_group_layout(
+///     "my_bind_group_layout",
+///     &BindGroupLayoutEntries::with_indices(
+///         // The layout entries will only be visible in the fragment stage
+///         ShaderStages::FRAGMENT,
+///         (
+///             // Screen texture
+///             (2, texture_2d(TextureSampleType::Float { filterable: true })),
+///             // Sampler
+///             (3, sampler(SamplerBindingType::Filtering)),
+///         ),
+///     ),
+/// );
+/// ```
+///
+/// instead of
+///
+/// ```ignore (render_device cannot be easily accessed)
+/// let layout = render_device.create_bind_group_layout(
+///     "my_bind_group_layout",
+///     &[
+///         // Screen texture
+///         BindGroupLayoutEntry {
+///             binding: 2,
+///             visibility: ShaderStages::FRAGMENT,
+///             ty: BindingType::Texture {
+///                 sample_type: TextureSampleType::Float { filterable: true },
+///                 view_dimension: TextureViewDimension::D2,
+///                 multisampled: false,
+///             },
+///             count: None,
+///         },
+///         // Sampler
+///         BindGroupLayoutEntry {
+///             binding: 3,
+///             visibility: ShaderStages::FRAGMENT,
+///             ty: BindingType::Sampler(SamplerBindingType::Filtering),
+///             count: None,
+///         },
+///     ],
+/// );
+/// ```
+///
+/// or
+///
+/// ```ignore (render_device cannot be easily accessed)
+/// render_device.create_bind_group_layout(
+///     "my_bind_group_layout",
+///     &BindGroupLayoutEntries::sequential(
+///         ShaderStages::FRAGMENT,
+///         (
+///             // Screen texture
+///             texture_2d(TextureSampleType::Float { filterable: true }),
+///             // Sampler
+///             sampler(SamplerBindingType::Filtering),
+///         ),
+///     ),
+/// );
+/// ```
+///
+/// instead of
+///
+/// ```ignore (render_device cannot be easily accessed)
+/// let layout = render_device.create_bind_group_layout(
+///     "my_bind_group_layout",
+///     &[
+///         // Screen texture
+///         BindGroupLayoutEntry {
+///             binding: 0,
+///             visibility: ShaderStages::FRAGMENT,
+///             ty: BindingType::Texture {
+///                 sample_type: TextureSampleType::Float { filterable: true },
+///                 view_dimension: TextureViewDimension::D2,
+///                 multisampled: false,
+///             },
+///             count: None,
+///         },
+///         // Sampler
+///         BindGroupLayoutEntry {
+///             binding: 1,
+///             visibility: ShaderStages::FRAGMENT,
+///             ty: BindingType::Sampler(SamplerBindingType::Filtering),
+///             count: None,
+///         },
+///     ],
+/// );
+/// ```
+///
+/// or
+///
+/// ```ignore (render_device cannot be easily accessed)
+/// render_device.create_bind_group_layout(
+///     "my_bind_group_layout",
+///     &BindGroupLayoutEntries::single(
+///         ShaderStages::FRAGMENT,
+///         texture_2d(TextureSampleType::Float { filterable: true }),
+///     ),
+/// );
+/// ```
+///
+/// instead of
+///
+/// ```ignore (render_device cannot be easily accessed)
+/// let layout = render_device.create_bind_group_layout(
+///     "my_bind_group_layout",
+///     &[
+///         BindGroupLayoutEntry {
+///             binding: 0,
+///             visibility: ShaderStages::FRAGMENT,
+///             ty: BindingType::Texture {
+///                 sample_type: TextureSampleType::Float { filterable: true },
+///                 view_dimension: TextureViewDimension::D2,
+///                 multisampled: false,
+///             },
+///             count: None,
+///         },
+///     ],
+/// );
+/// ```
+
+#[derive(Clone, Copy)]
+pub struct BindGroupLayoutEntryBuilder {
+    ty: BindingType,
+    visibility: Option<ShaderStages>,
+    count: Option<NonZero<u32>>,
+}
+
+impl BindGroupLayoutEntryBuilder {
+    pub fn visibility(mut self, visibility: ShaderStages) -> Self {
+        self.visibility = Some(visibility);
+        self
+    }
+
+    pub fn count(mut self, count: NonZero<u32>) -> Self {
+        self.count = Some(count);
+        self
+    }
+
+    pub fn build(&self, binding: u32, default_visibility: ShaderStages) -> BindGroupLayoutEntry {
+        BindGroupLayoutEntry {
+            binding,
+            ty: self.ty,
+            visibility: self.visibility.unwrap_or(default_visibility),
+            count: self.count,
+        }
+    }
+}
+
+pub struct BindGroupLayoutEntries<const N: usize> {
+    entries: [BindGroupLayoutEntry; N],
+}
+
+impl<const N: usize> BindGroupLayoutEntries<N> {
+    #[inline]
+    pub fn sequential(
+        default_visibility: ShaderStages,
+        entries_ext: impl IntoBindGroupLayoutEntryBuilderArray<N>,
+    ) -> Self {
+        let mut i = 0;
+        Self {
+            entries: entries_ext.into_array().map(|entry| {
+                let binding = i;
+                i += 1;
+                entry.build(binding, default_visibility)
+            }),
+        }
+    }
+
+    #[inline]
+    pub fn with_indices(
+        default_visibility: ShaderStages,
+        indexed_entries: impl IntoIndexedBindGroupLayoutEntryBuilderArray<N>,
+    ) -> Self {
+        Self {
+            entries: indexed_entries
+                .into_array()
+                .map(|(binding, entry)| entry.build(binding, default_visibility)),
+        }
+    }
+}
+
+impl BindGroupLayoutEntries<1> {
+    pub fn single(
+        visibility: ShaderStages,
+        resource: impl IntoBindGroupLayoutEntryBuilder,
+    ) -> [BindGroupLayoutEntry; 1] {
+        [resource
+            .into_bind_group_layout_entry_builder()
+            .build(0, visibility)]
+    }
+}
+
+impl<const N: usize> core::ops::Deref for BindGroupLayoutEntries<N> {
+    type Target = [BindGroupLayoutEntry];
+    fn deref(&self) -> &[BindGroupLayoutEntry] {
+        &self.entries
+    }
+}
+
+pub trait IntoBindGroupLayoutEntryBuilder {
+    fn into_bind_group_layout_entry_builder(self) -> BindGroupLayoutEntryBuilder;
+}
+
+impl IntoBindGroupLayoutEntryBuilder for BindingType {
+    fn into_bind_group_layout_entry_builder(self) -> BindGroupLayoutEntryBuilder {
+        BindGroupLayoutEntryBuilder {
+            ty: self,
+            visibility: None,
+            count: None,
+        }
+    }
+}
+
+impl IntoBindGroupLayoutEntryBuilder for BindGroupLayoutEntry {
+    fn into_bind_group_layout_entry_builder(self) -> BindGroupLayoutEntryBuilder {
+        if self.binding != u32::MAX {
+            tracing::warn!("The BindGroupLayoutEntries api ignores the binding index when converting a raw wgpu::BindGroupLayoutEntry. You can ignore this warning by setting it to u32::MAX.");
+        }
+        BindGroupLayoutEntryBuilder {
+            ty: self.ty,
+            visibility: Some(self.visibility),
+            count: self.count,
+        }
+    }
+}
+
+impl IntoBindGroupLayoutEntryBuilder for BindGroupLayoutEntryBuilder {
+    fn into_bind_group_layout_entry_builder(self) -> BindGroupLayoutEntryBuilder {
+        self
+    }
+}
+
+pub trait IntoBindGroupLayoutEntryBuilderArray<const N: usize> {
+    fn into_array(self) -> [BindGroupLayoutEntryBuilder; N];
+}
+macro_rules! impl_to_binding_type_slice {
+    ($N: expr, $(#[$meta:meta])* $(($T: ident, $I: ident)),*) => {
+        $(#[$meta])*
+        impl<$($T: IntoBindGroupLayoutEntryBuilder),*> IntoBindGroupLayoutEntryBuilderArray<$N> for ($($T,)*) {
+            #[inline]
+            fn into_array(self) -> [BindGroupLayoutEntryBuilder; $N] {
+                let ($($I,)*) = self;
+                [$($I.into_bind_group_layout_entry_builder(), )*]
+            }
+        }
+    }
+}
+all_tuples_with_size!(
+    #[doc(fake_variadic)]
+    impl_to_binding_type_slice,
+    1,
+    32,
+    T,
+    s
+);
+
+pub trait IntoIndexedBindGroupLayoutEntryBuilderArray<const N: usize> {
+    fn into_array(self) -> [(u32, BindGroupLayoutEntryBuilder); N];
+}
+macro_rules! impl_to_indexed_binding_type_slice {
+    ($N: expr, $(($T: ident, $S: ident, $I: ident)),*) => {
+        impl<$($T: IntoBindGroupLayoutEntryBuilder),*> IntoIndexedBindGroupLayoutEntryBuilderArray<$N> for ($((u32, $T),)*) {
+            #[inline]
+            fn into_array(self) -> [(u32, BindGroupLayoutEntryBuilder); $N] {
+                let ($(($S, $I),)*) = self;
+                [$(($S, $I.into_bind_group_layout_entry_builder())), *]
+            }
+        }
+    }
+}
+all_tuples_with_size!(impl_to_indexed_binding_type_slice, 1, 32, T, n, s);
+
+impl<const N: usize> IntoBindGroupLayoutEntryBuilderArray<N> for [BindGroupLayoutEntry; N] {
+    fn into_array(self) -> [BindGroupLayoutEntryBuilder; N] {
+        self.map(IntoBindGroupLayoutEntryBuilder::into_bind_group_layout_entry_builder)
+    }
+}
+
+pub struct DynamicBindGroupLayoutEntries {
+    default_visibility: ShaderStages,
+    entries: Vec<BindGroupLayoutEntry>,
+}
+
+impl DynamicBindGroupLayoutEntries {
+    pub fn sequential<const N: usize>(
+        default_visibility: ShaderStages,
+        entries: impl IntoBindGroupLayoutEntryBuilderArray<N>,
+    ) -> Self {
+        Self {
+            default_visibility,
+            entries: entries
+                .into_array()
+                .into_iter()
+                .enumerate()
+                .map(|(ix, resource)| resource.build(ix as u32, default_visibility))
+                .collect(),
+        }
+    }
+
+    pub fn extend_sequential<const N: usize>(
+        mut self,
+        entries: impl IntoBindGroupLayoutEntryBuilderArray<N>,
+    ) -> Self {
+        let start = self.entries.last().unwrap().binding + 1;
+        self.entries.extend(
+            entries
+                .into_array()
+                .into_iter()
+                .enumerate()
+                .map(|(ix, resource)| resource.build(start + ix as u32, self.default_visibility)),
+        );
+        self
+    }
+
+    pub fn new_with_indices<const N: usize>(
+        default_visibility: ShaderStages,
+        entries: impl IntoIndexedBindGroupLayoutEntryBuilderArray<N>,
+    ) -> Self {
+        Self {
+            default_visibility,
+            entries: entries
+                .into_array()
+                .into_iter()
+                .map(|(binding, resource)| resource.build(binding, default_visibility))
+                .collect(),
+        }
+    }
+
+    pub fn extend_with_indices<const N: usize>(
+        mut self,
+        entries: impl IntoIndexedBindGroupLayoutEntryBuilderArray<N>,
+    ) -> Self {
+        self.entries.extend(
+            entries
+                .into_array()
+                .into_iter()
+                .map(|(binding, resource)| resource.build(binding, self.default_visibility)),
+        );
+        self
+    }
+}
+
+impl core::ops::Deref for DynamicBindGroupLayoutEntries {
+    type Target = [BindGroupLayoutEntry];
+
+    fn deref(&self) -> &[BindGroupLayoutEntry] {
+        &self.entries
+    }
+}
+
+pub mod binding_types {
+    use crate::render_resource::{
+        BufferBindingType, SamplerBindingType, TextureSampleType, TextureViewDimension,
+    };
+    use core::num::NonZero;
+    use encase::ShaderType;
+    use wgpu::{StorageTextureAccess, TextureFormat};
+
+    use super::*;
+
+    pub fn storage_buffer<T: ShaderType>(has_dynamic_offset: bool) -> BindGroupLayoutEntryBuilder {
+        storage_buffer_sized(has_dynamic_offset, Some(T::min_size()))
+    }
+
+    pub fn storage_buffer_sized(
+        has_dynamic_offset: bool,
+        min_binding_size: Option<NonZero<u64>>,
+    ) -> BindGroupLayoutEntryBuilder {
+        BindingType::Buffer {
+            ty: BufferBindingType::Storage { read_only: false },
+            has_dynamic_offset,
+            min_binding_size,
+        }
+        .into_bind_group_layout_entry_builder()
+    }
+
+    pub fn storage_buffer_read_only<T: ShaderType>(
+        has_dynamic_offset: bool,
+    ) -> BindGroupLayoutEntryBuilder {
+        storage_buffer_read_only_sized(has_dynamic_offset, Some(T::min_size()))
+    }
+
+    pub fn storage_buffer_read_only_sized(
+        has_dynamic_offset: bool,
+        min_binding_size: Option<NonZero<u64>>,
+    ) -> BindGroupLayoutEntryBuilder {
+        BindingType::Buffer {
+            ty: BufferBindingType::Storage { read_only: true },
+            has_dynamic_offset,
+            min_binding_size,
+        }
+        .into_bind_group_layout_entry_builder()
+    }
+
+    pub fn uniform_buffer<T: ShaderType>(has_dynamic_offset: bool) -> BindGroupLayoutEntryBuilder {
+        uniform_buffer_sized(has_dynamic_offset, Some(T::min_size()))
+    }
+
+    pub fn uniform_buffer_sized(
+        has_dynamic_offset: bool,
+        min_binding_size: Option<NonZero<u64>>,
+    ) -> BindGroupLayoutEntryBuilder {
+        BindingType::Buffer {
+            ty: BufferBindingType::Uniform,
+            has_dynamic_offset,
+            min_binding_size,
+        }
+        .into_bind_group_layout_entry_builder()
+    }
+
+    pub fn texture_1d(sample_type: TextureSampleType) -> BindGroupLayoutEntryBuilder {
+        BindingType::Texture {
+            sample_type,
+            view_dimension: TextureViewDimension::D1,
+            multisampled: false,
+        }
+        .into_bind_group_layout_entry_builder()
+    }
+
+    pub fn texture_2d(sample_type: TextureSampleType) -> BindGroupLayoutEntryBuilder {
+        BindingType::Texture {
+            sample_type,
+            view_dimension: TextureViewDimension::D2,
+            multisampled: false,
+        }
+        .into_bind_group_layout_entry_builder()
+    }
+
+    pub fn texture_2d_multisampled(sample_type: TextureSampleType) -> BindGroupLayoutEntryBuilder {
+        BindingType::Texture {
+            sample_type,
+            view_dimension: TextureViewDimension::D2,
+            multisampled: true,
+        }
+        .into_bind_group_layout_entry_builder()
+    }
+
+    pub fn texture_2d_array(sample_type: TextureSampleType) -> BindGroupLayoutEntryBuilder {
+        BindingType::Texture {
+            sample_type,
+            view_dimension: TextureViewDimension::D2Array,
+            multisampled: false,
+        }
+        .into_bind_group_layout_entry_builder()
+    }
+
+    pub fn texture_2d_array_multisampled(
+        sample_type: TextureSampleType,
+    ) -> BindGroupLayoutEntryBuilder {
+        BindingType::Texture {
+            sample_type,
+            view_dimension: TextureViewDimension::D2Array,
+            multisampled: true,
+        }
+        .into_bind_group_layout_entry_builder()
+    }
+
+    pub fn texture_depth_2d() -> BindGroupLayoutEntryBuilder {
+        texture_2d(TextureSampleType::Depth).into_bind_group_layout_entry_builder()
+    }
+
+    pub fn texture_depth_2d_multisampled() -> BindGroupLayoutEntryBuilder {
+        texture_2d_multisampled(TextureSampleType::Depth).into_bind_group_layout_entry_builder()
+    }
+
+    pub fn texture_cube(sample_type: TextureSampleType) -> BindGroupLayoutEntryBuilder {
+        BindingType::Texture {
+            sample_type,
+            view_dimension: TextureViewDimension::Cube,
+            multisampled: false,
+        }
+        .into_bind_group_layout_entry_builder()
+    }
+
+    pub fn texture_cube_multisampled(
+        sample_type: TextureSampleType,
+    ) -> BindGroupLayoutEntryBuilder {
+        BindingType::Texture {
+            sample_type,
+            view_dimension: TextureViewDimension::Cube,
+            multisampled: true,
+        }
+        .into_bind_group_layout_entry_builder()
+    }
+
+    pub fn texture_cube_array(sample_type: TextureSampleType) -> BindGroupLayoutEntryBuilder {
+        BindingType::Texture {
+            sample_type,
+            view_dimension: TextureViewDimension::CubeArray,
+            multisampled: false,
+        }
+        .into_bind_group_layout_entry_builder()
+    }
+
+    pub fn texture_cube_array_multisampled(
+        sample_type: TextureSampleType,
+    ) -> BindGroupLayoutEntryBuilder {
+        BindingType::Texture {
+            sample_type,
+            view_dimension: TextureViewDimension::CubeArray,
+            multisampled: true,
+        }
+        .into_bind_group_layout_entry_builder()
+    }
+
+    pub fn texture_3d(sample_type: TextureSampleType) -> BindGroupLayoutEntryBuilder {
+        BindingType::Texture {
+            sample_type,
+            view_dimension: TextureViewDimension::D3,
+            multisampled: false,
+        }
+        .into_bind_group_layout_entry_builder()
+    }
+
+    pub fn texture_3d_multisampled(sample_type: TextureSampleType) -> BindGroupLayoutEntryBuilder {
+        BindingType::Texture {
+            sample_type,
+            view_dimension: TextureViewDimension::D3,
+            multisampled: true,
+        }
+        .into_bind_group_layout_entry_builder()
+    }
+
+    pub fn sampler(sampler_binding_type: SamplerBindingType) -> BindGroupLayoutEntryBuilder {
+        BindingType::Sampler(sampler_binding_type).into_bind_group_layout_entry_builder()
+    }
+
+    pub fn texture_storage_2d(
+        format: TextureFormat,
+        access: StorageTextureAccess,
+    ) -> BindGroupLayoutEntryBuilder {
+        BindingType::StorageTexture {
+            access,
+            format,
+            view_dimension: TextureViewDimension::D2,
+        }
+        .into_bind_group_layout_entry_builder()
+    }
+
+    pub fn texture_storage_2d_array(
+        format: TextureFormat,
+        access: StorageTextureAccess,
+    ) -> BindGroupLayoutEntryBuilder {
+        BindingType::StorageTexture {
+            access,
+            format,
+            view_dimension: TextureViewDimension::D2Array,
+        }
+        .into_bind_group_layout_entry_builder()
+    }
+
+    pub fn texture_storage_3d(
+        format: TextureFormat,
+        access: StorageTextureAccess,
+    ) -> BindGroupLayoutEntryBuilder {
+        BindingType::StorageTexture {
+            access,
+            format,
+            view_dimension: TextureViewDimension::D3,
+        }
+        .into_bind_group_layout_entry_builder()
+    }
+}

vendor/bevy_render/src/render_resource/bindless.rs

@@ -0,0 +1,344 @@
+//! Types and functions relating to bindless resources.
+
+use alloc::borrow::Cow;
+use core::{
+    num::{NonZeroU32, NonZeroU64},
+    ops::Range,
+};
+
+use bevy_derive::{Deref, DerefMut};
+use wgpu::{
+    BindGroupLayoutEntry, SamplerBindingType, ShaderStages, TextureSampleType, TextureViewDimension,
+};
+
+use crate::render_resource::binding_types::storage_buffer_read_only_sized;
+
+use super::binding_types::{
+    sampler, texture_1d, texture_2d, texture_2d_array, texture_3d, texture_cube, texture_cube_array,
+};
+
+/// The default value for the number of resources that can be stored in a slab
+/// on this platform.
+///
+/// See the documentation for [`BindlessSlabResourceLimit`] for more
+/// information.
+#[cfg(any(target_os = "macos", target_os = "ios"))]
+pub const AUTO_BINDLESS_SLAB_RESOURCE_LIMIT: u32 = 64;
+/// The default value for the number of resources that can be stored in a slab
+/// on this platform.
+///
+/// See the documentation for [`BindlessSlabResourceLimit`] for more
+/// information.
+#[cfg(not(any(target_os = "macos", target_os = "ios")))]
+pub const AUTO_BINDLESS_SLAB_RESOURCE_LIMIT: u32 = 2048;
+
+/// The binding numbers for the built-in binding arrays of each bindless
+/// resource type.
+///
+/// In the case of materials, the material allocator manages these binding
+/// arrays.
+///
+/// `bindless.wgsl` contains declarations of these arrays for use in your
+/// shaders. If you change these, make sure to update that file as well.
+pub static BINDING_NUMBERS: [(BindlessResourceType, BindingNumber); 9] = [
+    (BindlessResourceType::SamplerFiltering, BindingNumber(1)),
+    (BindlessResourceType::SamplerNonFiltering, BindingNumber(2)),
+    (BindlessResourceType::SamplerComparison, BindingNumber(3)),
+    (BindlessResourceType::Texture1d, BindingNumber(4)),
+    (BindlessResourceType::Texture2d, BindingNumber(5)),
+    (BindlessResourceType::Texture2dArray, BindingNumber(6)),
+    (BindlessResourceType::Texture3d, BindingNumber(7)),
+    (BindlessResourceType::TextureCube, BindingNumber(8)),
+    (BindlessResourceType::TextureCubeArray, BindingNumber(9)),
+];
+
+/// The maximum number of resources that can be stored in a slab.
+///
+/// This limit primarily exists in order to work around `wgpu` performance
+/// problems involving large numbers of bindless resources. Also, some
+/// platforms, such as Metal, currently enforce limits on the number of
+/// resources in use.
+///
+/// This corresponds to `LIMIT` in the `#[bindless(LIMIT)]` attribute when
+/// deriving [`crate::render_resource::AsBindGroup`].
+#[derive(Clone, Copy, Default, PartialEq, Debug)]
+pub enum BindlessSlabResourceLimit {
+    /// Allows the renderer to choose a reasonable value for the resource limit
+    /// based on the platform.
+    ///
+    /// This value has been tuned, so you should default to this value unless
+    /// you have special platform-specific considerations that prevent you from
+    /// using it.
+    #[default]
+    Auto,
+
+    /// A custom value for the resource limit.
+    ///
+    /// Bevy will allocate no more than this number of resources in a slab,
+    /// unless exceeding this value is necessary in order to allocate at all
+    /// (i.e. unless the number of bindless resources in your bind group exceeds
+    /// this value), in which case Bevy can exceed it.
+    Custom(u32),
+}
+
+/// Information about the bindless resources in this object.
+///
+/// The material bind group allocator uses this descriptor in order to create
+/// and maintain bind groups. The fields within this bindless descriptor are
+/// [`Cow`]s in order to support both the common case in which the fields are
+/// simply `static` constants and the more unusual case in which the fields are
+/// dynamically generated efficiently. An example of the latter case is
+/// `ExtendedMaterial`, which needs to assemble a bindless descriptor from those
+/// of the base material and the material extension at runtime.
+///
+/// This structure will only be present if this object is bindless.
+pub struct BindlessDescriptor {
+    /// The bindless resource types that this object uses, in order of bindless
+    /// index.
+    ///
+    /// The resource assigned to binding index 0 will be at index 0, the
+    /// resource assigned to binding index will be at index 1 in this array, and
+    /// so on. Unused binding indices are set to [`BindlessResourceType::None`].
+    pub resources: Cow<'static, [BindlessResourceType]>,
+    /// The [`BindlessBufferDescriptor`] for each bindless buffer that this
+    /// object uses.
+    ///
+    /// The order of this array is irrelevant.
+    pub buffers: Cow<'static, [BindlessBufferDescriptor]>,
+    /// The [`BindlessIndexTableDescriptor`]s describing each bindless index
+    /// table.
+    ///
+    /// This list must be sorted by the first bindless index.
+    pub index_tables: Cow<'static, [BindlessIndexTableDescriptor]>,
+}
+
+/// The type of potentially-bindless resource.
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)]
+pub enum BindlessResourceType {
+    /// No bindless resource.
+    ///
+    /// This is used as a placeholder to fill holes in the
+    /// [`BindlessDescriptor::resources`] list.
+    None,
+    /// A storage buffer.
+    Buffer,
+    /// A filtering sampler.
+    SamplerFiltering,
+    /// A non-filtering sampler (nearest neighbor).
+    SamplerNonFiltering,
+    /// A comparison sampler (typically used for shadow maps).
+    SamplerComparison,
+    /// A 1D texture.
+    Texture1d,
+    /// A 2D texture.
+    Texture2d,
+    /// A 2D texture array.
+    ///
+    /// Note that this differs from a binding array. 2D texture arrays must all
+    /// have the same size and format.
+    Texture2dArray,
+    /// A 3D texture.
+    Texture3d,
+    /// A cubemap texture.
+    TextureCube,
+    /// A cubemap texture array.
+    ///
+    /// Note that this differs from a binding array. Cubemap texture arrays must
+    /// all have the same size and format.
+    TextureCubeArray,
+    /// Multiple instances of plain old data concatenated into a single buffer.
+    ///
+    /// This corresponds to the `#[data]` declaration in
+    /// [`crate::render_resource::AsBindGroup`].
+    ///
+    /// Note that this resource doesn't itself map to a GPU-level binding
+    /// resource and instead depends on the `MaterialBindGroupAllocator` to
+    /// create a binding resource for it.
+    DataBuffer,
+}
+
+/// Describes a bindless buffer.
+///
+/// Unlike samplers and textures, each buffer in a bind group gets its own
+/// unique bind group entry. That is, there isn't any `bindless_buffers` binding
+/// array to go along with `bindless_textures_2d`,
+/// `bindless_samplers_filtering`, etc. Therefore, this descriptor contains two
+/// indices: the *binding number* and the *bindless index*. The binding number
+/// is the `@binding` number used in the shader, while the bindless index is the
+/// index of the buffer in the bindless index table (which is itself
+/// conventionally bound to binding number 0).
+///
+/// When declaring the buffer in a derived implementation
+/// [`crate::render_resource::AsBindGroup`] with syntax like
+/// `#[uniform(BINDLESS_INDEX, StandardMaterialUniform,
+/// bindless(BINDING_NUMBER)]`, the bindless index is `BINDLESS_INDEX`, and the
+/// binding number is `BINDING_NUMBER`. Note the order.
+#[derive(Clone, Copy, Debug)]
+pub struct BindlessBufferDescriptor {
+    /// The actual binding number of the buffer.
+    ///
+    /// This is declared with `@binding` in WGSL. When deriving
+    /// [`crate::render_resource::AsBindGroup`], this is the `BINDING_NUMBER` in
+    /// `#[uniform(BINDLESS_INDEX, StandardMaterialUniform,
+    /// bindless(BINDING_NUMBER)]`.
+    pub binding_number: BindingNumber,
+    /// The index of the buffer in the bindless index table.
+    ///
+    /// In the shader, this is the index into the table bound to binding 0. When
+    /// deriving [`crate::render_resource::AsBindGroup`], this is the
+    /// `BINDLESS_INDEX` in `#[uniform(BINDLESS_INDEX, StandardMaterialUniform,
+    /// bindless(BINDING_NUMBER)]`.
+    pub bindless_index: BindlessIndex,
+    /// The size of the buffer in bytes, if known.
+    pub size: Option<usize>,
+}
+
+/// Describes the layout of the bindless index table, which maps bindless
+/// indices to indices within the binding arrays.
+#[derive(Clone)]
+pub struct BindlessIndexTableDescriptor {
+    /// The range of bindless indices that this descriptor covers.
+    pub indices: Range<BindlessIndex>,
+    /// The binding at which the index table itself will be bound.
+    ///
+    /// By default, this is binding 0, but it can be changed with the
+    /// `#[bindless(index_table(binding(B)))]` attribute.
+    pub binding_number: BindingNumber,
+}
+
+/// The index of the actual binding in the bind group.
+///
+/// This is the value specified in WGSL as `@binding`.
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, Deref, DerefMut)]
+pub struct BindingNumber(pub u32);
+
+/// The index in the bindless index table.
+///
+/// This table is conventionally bound to binding number 0.
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Hash, Debug, Deref, DerefMut)]
+pub struct BindlessIndex(pub u32);
+
+/// Creates the bind group layout entries common to all shaders that use
+/// bindless bind groups.
+///
+/// `bindless_resource_count` specifies the total number of bindless resources.
+/// `bindless_slab_resource_limit` specifies the resolved
+/// [`BindlessSlabResourceLimit`] value.
+pub fn create_bindless_bind_group_layout_entries(
+    bindless_index_table_length: u32,
+    bindless_slab_resource_limit: u32,
+    bindless_index_table_binding_number: BindingNumber,
+) -> Vec<BindGroupLayoutEntry> {
+    let bindless_slab_resource_limit =
+        NonZeroU32::new(bindless_slab_resource_limit).expect("Bindless slot count must be nonzero");
+
+    // The maximum size of a binding array is the
+    // `bindless_slab_resource_limit`, which would occur if all of the bindless
+    // resources were of the same type. So we create our binding arrays with
+    // that size.
+
+    vec![
+        // Start with the bindless index table, bound to binding number 0.
+        storage_buffer_read_only_sized(
+            false,
+            NonZeroU64::new(bindless_index_table_length as u64 * size_of::<u32>() as u64),
+        )
+        .build(*bindless_index_table_binding_number, ShaderStages::all()),
+        // Continue with the common bindless resource arrays.
+        sampler(SamplerBindingType::Filtering)
+            .count(bindless_slab_resource_limit)
+            .build(1, ShaderStages::all()),
+        sampler(SamplerBindingType::NonFiltering)
+            .count(bindless_slab_resource_limit)
+            .build(2, ShaderStages::all()),
+        sampler(SamplerBindingType::Comparison)
+            .count(bindless_slab_resource_limit)
+            .build(3, ShaderStages::all()),
+        texture_1d(TextureSampleType::Float { filterable: true })
+            .count(bindless_slab_resource_limit)
+            .build(4, ShaderStages::all()),
+        texture_2d(TextureSampleType::Float { filterable: true })
+            .count(bindless_slab_resource_limit)
+            .build(5, ShaderStages::all()),
+        texture_2d_array(TextureSampleType::Float { filterable: true })
+            .count(bindless_slab_resource_limit)
+            .build(6, ShaderStages::all()),
+        texture_3d(TextureSampleType::Float { filterable: true })
+            .count(bindless_slab_resource_limit)
+            .build(7, ShaderStages::all()),
+        texture_cube(TextureSampleType::Float { filterable: true })
+            .count(bindless_slab_resource_limit)
+            .build(8, ShaderStages::all()),
+        texture_cube_array(TextureSampleType::Float { filterable: true })
+            .count(bindless_slab_resource_limit)
+            .build(9, ShaderStages::all()),
+    ]
+}
+
+impl BindlessSlabResourceLimit {
+    /// Determines the actual bindless slab resource limit on this platform.
+    pub fn resolve(&self) -> u32 {
+        match *self {
+            BindlessSlabResourceLimit::Auto => AUTO_BINDLESS_SLAB_RESOURCE_LIMIT,
+            BindlessSlabResourceLimit::Custom(limit) => limit,
+        }
+    }
+}
+
+impl BindlessResourceType {
+    /// Returns the binding number for the common array of this resource type.
+    ///
+    /// For example, if you pass `BindlessResourceType::Texture2d`, this will
+    /// return 5, in order to match the `@group(2) @binding(5) var
+    /// bindless_textures_2d: binding_array<texture_2d<f32>>` declaration in
+    /// `bindless.wgsl`.
+    ///
+    /// Not all resource types have fixed binding numbers. If you call
+    /// [`Self::binding_number`] on such a resource type, it returns `None`.
+    ///
+    /// Note that this returns a static reference to the binding number, not the
+    /// binding number itself. This is to conform to an idiosyncratic API in
+    /// `wgpu` whereby binding numbers for binding arrays are taken by `&u32`
+    /// *reference*, not by `u32` value.
+    pub fn binding_number(&self) -> Option<&'static BindingNumber> {
+        match BINDING_NUMBERS.binary_search_by_key(self, |(key, _)| *key) {
+            Ok(binding_number) => Some(&BINDING_NUMBERS[binding_number].1),
+            Err(_) => None,
+        }
+    }
+}
+
+impl From<TextureViewDimension> for BindlessResourceType {
+    fn from(texture_view_dimension: TextureViewDimension) -> Self {
+        match texture_view_dimension {
+            TextureViewDimension::D1 => BindlessResourceType::Texture1d,
+            TextureViewDimension::D2 => BindlessResourceType::Texture2d,
+            TextureViewDimension::D2Array => BindlessResourceType::Texture2dArray,
+            TextureViewDimension::Cube => BindlessResourceType::TextureCube,
+            TextureViewDimension::CubeArray => BindlessResourceType::TextureCubeArray,
+            TextureViewDimension::D3 => BindlessResourceType::Texture3d,
+        }
+    }
+}
+
+impl From<SamplerBindingType> for BindlessResourceType {
+    fn from(sampler_binding_type: SamplerBindingType) -> Self {
+        match sampler_binding_type {
+            SamplerBindingType::Filtering => BindlessResourceType::SamplerFiltering,
+            SamplerBindingType::NonFiltering => BindlessResourceType::SamplerNonFiltering,
+            SamplerBindingType::Comparison => BindlessResourceType::SamplerComparison,
+        }
+    }
+}
+
+impl From<u32> for BindlessIndex {
+    fn from(value: u32) -> Self {
+        Self(value)
+    }
+}
+
+impl From<u32> for BindingNumber {
+    fn from(value: u32) -> Self {
+        Self(value)
+    }
+}

vendor/bevy_render/src/render_resource/buffer.rs

@@ -0,0 +1,95 @@
+use crate::define_atomic_id;
+use crate::renderer::WgpuWrapper;
+use core::ops::{Bound, Deref, RangeBounds};
+
+define_atomic_id!(BufferId);
+
+#[derive(Clone, Debug)]
+pub struct Buffer {
+    id: BufferId,
+    value: WgpuWrapper<wgpu::Buffer>,
+}
+
+impl Buffer {
+    #[inline]
+    pub fn id(&self) -> BufferId {
+        self.id
+    }
+
+    pub fn slice(&self, bounds: impl RangeBounds<wgpu::BufferAddress>) -> BufferSlice {
+        // need to compute and store this manually because wgpu doesn't export offset and size on wgpu::BufferSlice
+        let offset = match bounds.start_bound() {
+            Bound::Included(&bound) => bound,
+            Bound::Excluded(&bound) => bound + 1,
+            Bound::Unbounded => 0,
+        };
+        let size = match bounds.end_bound() {
+            Bound::Included(&bound) => bound + 1,
+            Bound::Excluded(&bound) => bound,
+            Bound::Unbounded => self.value.size(),
+        } - offset;
+        BufferSlice {
+            id: self.id,
+            offset,
+            size,
+            value: self.value.slice(bounds),
+        }
+    }
+
+    #[inline]
+    pub fn unmap(&self) {
+        self.value.unmap();
+    }
+}
+
+impl From<wgpu::Buffer> for Buffer {
+    fn from(value: wgpu::Buffer) -> Self {
+        Buffer {
+            id: BufferId::new(),
+            value: WgpuWrapper::new(value),
+        }
+    }
+}
+
+impl Deref for Buffer {
+    type Target = wgpu::Buffer;
+
+    #[inline]
+    fn deref(&self) -> &Self::Target {
+        &self.value
+    }
+}
+
+#[derive(Clone, Debug)]
+pub struct BufferSlice<'a> {
+    id: BufferId,
+    offset: wgpu::BufferAddress,
+    value: wgpu::BufferSlice<'a>,
+    size: wgpu::BufferAddress,
+}
+
+impl<'a> BufferSlice<'a> {
+    #[inline]
+    pub fn id(&self) -> BufferId {
+        self.id
+    }
+
+    #[inline]
+    pub fn offset(&self) -> wgpu::BufferAddress {
+        self.offset
+    }
+
+    #[inline]
+    pub fn size(&self) -> wgpu::BufferAddress {
+        self.size
+    }
+}
+
+impl<'a> Deref for BufferSlice<'a> {
+    type Target = wgpu::BufferSlice<'a>;
+
+    #[inline]
+    fn deref(&self) -> &Self::Target {
+        &self.value
+    }
+}

vendor/bevy_render/src/render_resource/buffer_vec.rs

@@ -0,0 +1,513 @@
+use core::{iter, marker::PhantomData};
+
+use crate::{
+    render_resource::Buffer,
+    renderer::{RenderDevice, RenderQueue},
+};
+use bytemuck::{must_cast_slice, NoUninit};
+use encase::{
+    internal::{WriteInto, Writer},
+    ShaderType,
+};
+use wgpu::{BindingResource, BufferAddress, BufferUsages};
+
+use super::GpuArrayBufferable;
+
+/// A structure for storing raw bytes that have already been properly formatted
+/// for use by the GPU.
+///
+/// "Properly formatted" means that item data already meets the alignment and padding
+/// requirements for how it will be used on the GPU. The item type must implement [`NoUninit`]
+/// for its data representation to be directly copyable.
+///
+/// Index, vertex, and instance-rate vertex buffers have no alignment nor padding requirements and
+/// so this helper type is a good choice for them.
+///
+/// The contained data is stored in system RAM. Calling [`reserve`](RawBufferVec::reserve)
+/// allocates VRAM from the [`RenderDevice`].
+/// [`write_buffer`](RawBufferVec::write_buffer) queues copying of the data
+/// from system RAM to VRAM.
+///
+/// Other options for storing GPU-accessible data are:
+/// * [`BufferVec`]
+/// * [`DynamicStorageBuffer`](crate::render_resource::DynamicStorageBuffer)
+/// * [`DynamicUniformBuffer`](crate::render_resource::DynamicUniformBuffer)
+/// * [`GpuArrayBuffer`](crate::render_resource::GpuArrayBuffer)
+/// * [`StorageBuffer`](crate::render_resource::StorageBuffer)
+/// * [`Texture`](crate::render_resource::Texture)
+/// * [`UniformBuffer`](crate::render_resource::UniformBuffer)
+pub struct RawBufferVec<T: NoUninit> {
+    values: Vec<T>,
+    buffer: Option<Buffer>,
+    capacity: usize,
+    item_size: usize,
+    buffer_usage: BufferUsages,
+    label: Option<String>,
+    changed: bool,
+}
+
+impl<T: NoUninit> RawBufferVec<T> {
+    /// Creates a new [`RawBufferVec`] with the given [`BufferUsages`].
+    pub const fn new(buffer_usage: BufferUsages) -> Self {
+        Self {
+            values: Vec::new(),
+            buffer: None,
+            capacity: 0,
+            item_size: size_of::<T>(),
+            buffer_usage,
+            label: None,
+            changed: false,
+        }
+    }
+
+    /// Returns a handle to the buffer, if the data has been uploaded.
+    #[inline]
+    pub fn buffer(&self) -> Option<&Buffer> {
+        self.buffer.as_ref()
+    }
+
+    /// Returns the binding for the buffer if the data has been uploaded.
+    #[inline]
+    pub fn binding(&self) -> Option<BindingResource> {
+        Some(BindingResource::Buffer(
+            self.buffer()?.as_entire_buffer_binding(),
+        ))
+    }
+
+    /// Returns the amount of space that the GPU will use before reallocating.
+    #[inline]
+    pub fn capacity(&self) -> usize {
+        self.capacity
+    }
+
+    /// Returns the number of items that have been pushed to this buffer.
+    #[inline]
+    pub fn len(&self) -> usize {
+        self.values.len()
+    }
+
+    /// Returns true if the buffer is empty.
+    #[inline]
+    pub fn is_empty(&self) -> bool {
+        self.values.is_empty()
+    }
+
+    /// Adds a new value and returns its index.
+    pub fn push(&mut self, value: T) -> usize {
+        let index = self.values.len();
+        self.values.push(value);
+        index
+    }
+
+    pub fn append(&mut self, other: &mut RawBufferVec<T>) {
+        self.values.append(&mut other.values);
+    }
+
+    /// Returns the value at the given index.
+    pub fn get(&self, index: u32) -> Option<&T> {
+        self.values.get(index as usize)
+    }
+
+    /// Sets the value at the given index.
+    ///
+    /// The index must be less than [`RawBufferVec::len`].
+    pub fn set(&mut self, index: u32, value: T) {
+        self.values[index as usize] = value;
+    }
+
+    /// Preallocates space for `count` elements in the internal CPU-side buffer.
+    ///
+    /// Unlike [`RawBufferVec::reserve`], this doesn't have any effect on the GPU buffer.
+    pub fn reserve_internal(&mut self, count: usize) {
+        self.values.reserve(count);
+    }
+
+    /// Changes the debugging label of the buffer.
+    ///
+    /// The next time the buffer is updated (via [`reserve`](Self::reserve)), Bevy will inform
+    /// the driver of the new label.
+    pub fn set_label(&mut self, label: Option<&str>) {
+        let label = label.map(str::to_string);
+
+        if label != self.label {
+            self.changed = true;
+        }
+
+        self.label = label;
+    }
+
+    /// Returns the label
+    pub fn get_label(&self) -> Option<&str> {
+        self.label.as_deref()
+    }
+
+    /// Creates a [`Buffer`] on the [`RenderDevice`] with size
+    /// at least `size_of::<T>() * capacity`, unless a such a buffer already exists.
+    ///
+    /// If a [`Buffer`] exists, but is too small, references to it will be discarded,
+    /// and a new [`Buffer`] will be created. Any previously created [`Buffer`]s
+    /// that are no longer referenced will be deleted by the [`RenderDevice`]
+    /// once it is done using them (typically 1-2 frames).
+    ///
+    /// In addition to any [`BufferUsages`] provided when
+    /// the `RawBufferVec` was created, the buffer on the [`RenderDevice`]
+    /// is marked as [`BufferUsages::COPY_DST`](BufferUsages).
+    pub fn reserve(&mut self, capacity: usize, device: &RenderDevice) {
+        let size = self.item_size * capacity;
+        if capacity > self.capacity || (self.changed && size > 0) {
+            self.capacity = capacity;
+            self.buffer = Some(device.create_buffer(&wgpu::BufferDescriptor {
+                label: self.label.as_deref(),
+                size: size as BufferAddress,
+                usage: BufferUsages::COPY_DST | self.buffer_usage,
+                mapped_at_creation: false,
+            }));
+            self.changed = false;
+        }
+    }
+
+    /// Queues writing of data from system RAM to VRAM using the [`RenderDevice`]
+    /// and the provided [`RenderQueue`].
+    ///
+    /// Before queuing the write, a [`reserve`](RawBufferVec::reserve) operation
+    /// is executed.
+    pub fn write_buffer(&mut self, device: &RenderDevice, queue: &RenderQueue) {
+        if self.values.is_empty() {
+            return;
+        }
+        self.reserve(self.values.len(), device);
+        if let Some(buffer) = &self.buffer {
+            let range = 0..self.item_size * self.values.len();
+            let bytes: &[u8] = must_cast_slice(&self.values);
+            queue.write_buffer(buffer, 0, &bytes[range]);
+        }
+    }
+
+    /// Reduces the length of the buffer.
+    pub fn truncate(&mut self, len: usize) {
+        self.values.truncate(len);
+    }
+
+    /// Removes all elements from the buffer.
+    pub fn clear(&mut self) {
+        self.values.clear();
+    }
+
+    /// Removes and returns the last element in the buffer.
+    pub fn pop(&mut self) -> Option<T> {
+        self.values.pop()
+    }
+
+    pub fn values(&self) -> &Vec<T> {
+        &self.values
+    }
+
+    pub fn values_mut(&mut self) -> &mut Vec<T> {
+        &mut self.values
+    }
+}
+
+impl<T> RawBufferVec<T>
+where
+    T: NoUninit + Default,
+{
+    pub fn grow_set(&mut self, index: u32, value: T) {
+        while index as usize + 1 > self.len() {
+            self.values.push(T::default());
+        }
+        self.values[index as usize] = value;
+    }
+}
+
+impl<T: NoUninit> Extend<T> for RawBufferVec<T> {
+    #[inline]
+    fn extend<I: IntoIterator<Item = T>>(&mut self, iter: I) {
+        self.values.extend(iter);
+    }
+}
+
+/// Like [`RawBufferVec`], but doesn't require that the data type `T` be
+/// [`NoUninit`].
+///
+/// This is a high-performance data structure that you should use whenever
+/// possible if your data is more complex than is suitable for [`RawBufferVec`].
+/// The [`ShaderType`] trait from the `encase` library is used to ensure that
+/// the data is correctly aligned for use by the GPU.
+///
+/// For performance reasons, unlike [`RawBufferVec`], this type doesn't allow
+/// CPU access to the data after it's been added via [`BufferVec::push`]. If you
+/// need CPU access to the data, consider another type, such as
+/// [`StorageBuffer`][super::StorageBuffer].
+///
+/// Other options for storing GPU-accessible data are:
+/// * [`DynamicStorageBuffer`](crate::render_resource::DynamicStorageBuffer)
+/// * [`DynamicUniformBuffer`](crate::render_resource::DynamicUniformBuffer)
+/// * [`GpuArrayBuffer`](crate::render_resource::GpuArrayBuffer)
+/// * [`RawBufferVec`]
+/// * [`StorageBuffer`](crate::render_resource::StorageBuffer)
+/// * [`Texture`](crate::render_resource::Texture)
+/// * [`UniformBuffer`](crate::render_resource::UniformBuffer)
+pub struct BufferVec<T>
+where
+    T: ShaderType + WriteInto,
+{
+    data: Vec<u8>,
+    buffer: Option<Buffer>,
+    capacity: usize,
+    buffer_usage: BufferUsages,
+    label: Option<String>,
+    label_changed: bool,
+    phantom: PhantomData<T>,
+}
+
+impl<T> BufferVec<T>
+where
+    T: ShaderType + WriteInto,
+{
+    /// Creates a new [`BufferVec`] with the given [`BufferUsages`].
+    pub const fn new(buffer_usage: BufferUsages) -> Self {
+        Self {
+            data: vec![],
+            buffer: None,
+            capacity: 0,
+            buffer_usage,
+            label: None,
+            label_changed: false,
+            phantom: PhantomData,
+        }
+    }
+
+    /// Returns a handle to the buffer, if the data has been uploaded.
+    #[inline]
+    pub fn buffer(&self) -> Option<&Buffer> {
+        self.buffer.as_ref()
+    }
+
+    /// Returns the binding for the buffer if the data has been uploaded.
+    #[inline]
+    pub fn binding(&self) -> Option<BindingResource> {
+        Some(BindingResource::Buffer(
+            self.buffer()?.as_entire_buffer_binding(),
+        ))
+    }
+
+    /// Returns the amount of space that the GPU will use before reallocating.
+    #[inline]
+    pub fn capacity(&self) -> usize {
+        self.capacity
+    }
+
+    /// Returns the number of items that have been pushed to this buffer.
+    #[inline]
+    pub fn len(&self) -> usize {
+        self.data.len() / u64::from(T::min_size()) as usize
+    }
+
+    /// Returns true if the buffer is empty.
+    #[inline]
+    pub fn is_empty(&self) -> bool {
+        self.data.is_empty()
+    }
+
+    /// Adds a new value and returns its index.
+    pub fn push(&mut self, value: T) -> usize {
+        let element_size = u64::from(T::min_size()) as usize;
+        let offset = self.data.len();
+
+        // TODO: Consider using unsafe code to push uninitialized, to prevent
+        // the zeroing. It shows up in profiles.
+        self.data.extend(iter::repeat_n(0, element_size));
+
+        // Take a slice of the new data for `write_into` to use. This is
+        // important: it hoists the bounds check up here so that the compiler
+        // can eliminate all the bounds checks that `write_into` will emit.
+        let mut dest = &mut self.data[offset..(offset + element_size)];
+        value.write_into(&mut Writer::new(&value, &mut dest, 0).unwrap());
+
+        offset / u64::from(T::min_size()) as usize
+    }
+
+    /// Changes the debugging label of the buffer.
+    ///
+    /// The next time the buffer is updated (via [`Self::reserve`]), Bevy will inform
+    /// the driver of the new label.
+    pub fn set_label(&mut self, label: Option<&str>) {
+        let label = label.map(str::to_string);
+
+        if label != self.label {
+            self.label_changed = true;
+        }
+
+        self.label = label;
+    }
+
+    /// Returns the label
+    pub fn get_label(&self) -> Option<&str> {
+        self.label.as_deref()
+    }
+
+    /// Creates a [`Buffer`] on the [`RenderDevice`] with size
+    /// at least `size_of::<T>() * capacity`, unless such a buffer already exists.
+    ///
+    /// If a [`Buffer`] exists, but is too small, references to it will be discarded,
+    /// and a new [`Buffer`] will be created. Any previously created [`Buffer`]s
+    /// that are no longer referenced will be deleted by the [`RenderDevice`]
+    /// once it is done using them (typically 1-2 frames).
+    ///
+    /// In addition to any [`BufferUsages`] provided when
+    /// the `BufferVec` was created, the buffer on the [`RenderDevice`]
+    /// is marked as [`BufferUsages::COPY_DST`](BufferUsages).
+    pub fn reserve(&mut self, capacity: usize, device: &RenderDevice) {
+        if capacity <= self.capacity && !self.label_changed {
+            return;
+        }
+
+        self.capacity = capacity;
+        let size = u64::from(T::min_size()) as usize * capacity;
+        self.buffer = Some(device.create_buffer(&wgpu::BufferDescriptor {
+            label: self.label.as_deref(),
+            size: size as BufferAddress,
+            usage: BufferUsages::COPY_DST | self.buffer_usage,
+            mapped_at_creation: false,
+        }));
+        self.label_changed = false;
+    }
+
+    /// Queues writing of data from system RAM to VRAM using the [`RenderDevice`]
+    /// and the provided [`RenderQueue`].
+    ///
+    /// Before queuing the write, a [`reserve`](BufferVec::reserve) operation is
+    /// executed.
+    pub fn write_buffer(&mut self, device: &RenderDevice, queue: &RenderQueue) {
+        if self.data.is_empty() {
+            return;
+        }
+
+        self.reserve(self.data.len() / u64::from(T::min_size()) as usize, device);
+
+        let Some(buffer) = &self.buffer else { return };
+        queue.write_buffer(buffer, 0, &self.data);
+    }
+
+    /// Reduces the length of the buffer.
+    pub fn truncate(&mut self, len: usize) {
+        self.data.truncate(u64::from(T::min_size()) as usize * len);
+    }
+
+    /// Removes all elements from the buffer.
+    pub fn clear(&mut self) {
+        self.data.clear();
+    }
+}
+
+/// Like a [`BufferVec`], but only reserves space on the GPU for elements
+/// instead of initializing them CPU-side.
+///
+/// This type is useful when you're accumulating "output slots" for a GPU
+/// compute shader to write into.
+///
+/// The type `T` need not be [`NoUninit`], unlike [`RawBufferVec`]; it only has to
+/// be [`GpuArrayBufferable`].
+pub struct UninitBufferVec<T>
+where
+    T: GpuArrayBufferable,
+{
+    buffer: Option<Buffer>,
+    len: usize,
+    capacity: usize,
+    item_size: usize,
+    buffer_usage: BufferUsages,
+    label: Option<String>,
+    label_changed: bool,
+    phantom: PhantomData<T>,
+}
+
+impl<T> UninitBufferVec<T>
+where
+    T: GpuArrayBufferable,
+{
+    /// Creates a new [`UninitBufferVec`] with the given [`BufferUsages`].
+    pub const fn new(buffer_usage: BufferUsages) -> Self {
+        Self {
+            len: 0,
+            buffer: None,
+            capacity: 0,
+            item_size: size_of::<T>(),
+            buffer_usage,
+            label: None,
+            label_changed: false,
+            phantom: PhantomData,
+        }
+    }
+
+    /// Returns the buffer, if allocated.
+    #[inline]
+    pub fn buffer(&self) -> Option<&Buffer> {
+        self.buffer.as_ref()
+    }
+
+    /// Returns the binding for the buffer if the data has been uploaded.
+    #[inline]
+    pub fn binding(&self) -> Option<BindingResource> {
+        Some(BindingResource::Buffer(
+            self.buffer()?.as_entire_buffer_binding(),
+        ))
+    }
+
+    /// Reserves space for one more element in the buffer and returns its index.
+    pub fn add(&mut self) -> usize {
+        self.add_multiple(1)
+    }
+
+    /// Reserves space for the given number of elements in the buffer and
+    /// returns the index of the first one.
+    pub fn add_multiple(&mut self, count: usize) -> usize {
+        let index = self.len;
+        self.len += count;
+        index
+    }
+
+    /// Returns true if no elements have been added to this [`UninitBufferVec`].
+    pub fn is_empty(&self) -> bool {
+        self.len == 0
+    }
+
+    /// Removes all elements from the buffer.
+    pub fn clear(&mut self) {
+        self.len = 0;
+    }
+
+    /// Returns the length of the buffer.
+    pub fn len(&self) -> usize {
+        self.len
+    }
+
+    /// Materializes the buffer on the GPU with space for `capacity` elements.
+    ///
+    /// If the buffer is already big enough, this function doesn't reallocate
+    /// the buffer.
+    pub fn reserve(&mut self, capacity: usize, device: &RenderDevice) {
+        if capacity <= self.capacity && !self.label_changed {
+            return;
+        }
+
+        self.capacity = capacity;
+        let size = self.item_size * capacity;
+        self.buffer = Some(device.create_buffer(&wgpu::BufferDescriptor {
+            label: self.label.as_deref(),
+            size: size as BufferAddress,
+            usage: BufferUsages::COPY_DST | self.buffer_usage,
+            mapped_at_creation: false,
+        }));
+
+        self.label_changed = false;
+    }
+
+    /// Materializes the buffer on the GPU, with an appropriate size for the
+    /// elements that have been pushed so far.
+    pub fn write_buffer(&mut self, device: &RenderDevice) {
+        if !self.is_empty() {
+            self.reserve(self.len, device);
+        }
+    }
+}

vendor/bevy_render/src/render_resource/gpu_array_buffer.rs

@@ -0,0 +1,117 @@
+use super::{
+    binding_types::{storage_buffer_read_only, uniform_buffer_sized},
+    BindGroupLayoutEntryBuilder, BufferVec,
+};
+use crate::{
+    render_resource::batched_uniform_buffer::BatchedUniformBuffer,
+    renderer::{RenderDevice, RenderQueue},
+};
+use bevy_ecs::{prelude::Component, resource::Resource};
+use core::marker::PhantomData;
+use encase::{private::WriteInto, ShaderSize, ShaderType};
+use nonmax::NonMaxU32;
+use wgpu::{BindingResource, BufferUsages};
+
+/// Trait for types able to go in a [`GpuArrayBuffer`].
+pub trait GpuArrayBufferable: ShaderType + ShaderSize + WriteInto + Clone {}
+impl<T: ShaderType + ShaderSize + WriteInto + Clone> GpuArrayBufferable for T {}
+
+/// Stores an array of elements to be transferred to the GPU and made accessible to shaders as a read-only array.
+///
+/// On platforms that support storage buffers, this is equivalent to
+/// [`BufferVec<T>`]. Otherwise, this falls back to a dynamic offset
+/// uniform buffer with the largest array of T that fits within a uniform buffer
+/// binding (within reasonable limits).
+///
+/// Other options for storing GPU-accessible data are:
+/// * [`BufferVec`]
+/// * [`DynamicStorageBuffer`](crate::render_resource::DynamicStorageBuffer)
+/// * [`DynamicUniformBuffer`](crate::render_resource::DynamicUniformBuffer)
+/// * [`RawBufferVec`](crate::render_resource::RawBufferVec)
+/// * [`StorageBuffer`](crate::render_resource::StorageBuffer)
+/// * [`Texture`](crate::render_resource::Texture)
+/// * [`UniformBuffer`](crate::render_resource::UniformBuffer)
+#[derive(Resource)]
+pub enum GpuArrayBuffer<T: GpuArrayBufferable> {
+    Uniform(BatchedUniformBuffer<T>),
+    Storage(BufferVec<T>),
+}
+
+impl<T: GpuArrayBufferable> GpuArrayBuffer<T> {
+    pub fn new(device: &RenderDevice) -> Self {
+        let limits = device.limits();
+        if limits.max_storage_buffers_per_shader_stage == 0 {
+            GpuArrayBuffer::Uniform(BatchedUniformBuffer::new(&limits))
+        } else {
+            GpuArrayBuffer::Storage(BufferVec::new(BufferUsages::STORAGE))
+        }
+    }
+
+    pub fn clear(&mut self) {
+        match self {
+            GpuArrayBuffer::Uniform(buffer) => buffer.clear(),
+            GpuArrayBuffer::Storage(buffer) => buffer.clear(),
+        }
+    }
+
+    pub fn push(&mut self, value: T) -> GpuArrayBufferIndex<T> {
+        match self {
+            GpuArrayBuffer::Uniform(buffer) => buffer.push(value),
+            GpuArrayBuffer::Storage(buffer) => {
+                let index = buffer.push(value) as u32;
+                GpuArrayBufferIndex {
+                    index,
+                    dynamic_offset: None,
+                    element_type: PhantomData,
+                }
+            }
+        }
+    }
+
+    pub fn write_buffer(&mut self, device: &RenderDevice, queue: &RenderQueue) {
+        match self {
+            GpuArrayBuffer::Uniform(buffer) => buffer.write_buffer(device, queue),
+            GpuArrayBuffer::Storage(buffer) => buffer.write_buffer(device, queue),
+        }
+    }
+
+    pub fn binding_layout(device: &RenderDevice) -> BindGroupLayoutEntryBuilder {
+        if device.limits().max_storage_buffers_per_shader_stage == 0 {
+            uniform_buffer_sized(
+                true,
+                // BatchedUniformBuffer uses a MaxCapacityArray that is runtime-sized, so we use
+                // None here and let wgpu figure out the size.
+                None,
+            )
+        } else {
+            storage_buffer_read_only::<T>(false)
+        }
+    }
+
+    pub fn binding(&self) -> Option<BindingResource> {
+        match self {
+            GpuArrayBuffer::Uniform(buffer) => buffer.binding(),
+            GpuArrayBuffer::Storage(buffer) => buffer.binding(),
+        }
+    }
+
+    pub fn batch_size(device: &RenderDevice) -> Option<u32> {
+        let limits = device.limits();
+        if limits.max_storage_buffers_per_shader_stage == 0 {
+            Some(BatchedUniformBuffer::<T>::batch_size(&limits) as u32)
+        } else {
+            None
+        }
+    }
+}
+
+/// An index into a [`GpuArrayBuffer`] for a given element.
+#[derive(Component, Clone)]
+pub struct GpuArrayBufferIndex<T: GpuArrayBufferable> {
+    /// The index to use in a shader into the array.
+    pub index: u32,
+    /// The dynamic offset to use when setting the bind group in a pass.
+    /// Only used on platforms that don't support storage buffers.
+    pub dynamic_offset: Option<NonMaxU32>,
+    pub element_type: PhantomData<T>,
+}

vendor/bevy_render/src/render_resource/mod.rs

@@ -0,0 +1,73 @@
+mod batched_uniform_buffer;
+mod bind_group;
+mod bind_group_entries;
+mod bind_group_layout;
+mod bind_group_layout_entries;
+mod bindless;
+mod buffer;
+mod buffer_vec;
+mod gpu_array_buffer;
+mod pipeline;
+mod pipeline_cache;
+mod pipeline_specializer;
+pub mod resource_macros;
+mod shader;
+mod storage_buffer;
+mod texture;
+mod uniform_buffer;
+
+pub use bind_group::*;
+pub use bind_group_entries::*;
+pub use bind_group_layout::*;
+pub use bind_group_layout_entries::*;
+pub use bindless::*;
+pub use buffer::*;
+pub use buffer_vec::*;
+pub use gpu_array_buffer::*;
+pub use pipeline::*;
+pub use pipeline_cache::*;
+pub use pipeline_specializer::*;
+pub use shader::*;
+pub use storage_buffer::*;
+pub use texture::*;
+pub use uniform_buffer::*;
+
+// TODO: decide where re-exports should go
+pub use wgpu::{
+    util::{
+        BufferInitDescriptor, DispatchIndirectArgs, DrawIndexedIndirectArgs, DrawIndirectArgs,
+        TextureDataOrder,
+    },
+    AdapterInfo as WgpuAdapterInfo, AddressMode, AstcBlock, AstcChannel, BindGroupDescriptor,
+    BindGroupEntry, BindGroupLayoutDescriptor, BindGroupLayoutEntry, BindingResource, BindingType,
+    BlendComponent, BlendFactor, BlendOperation, BlendState, BufferAddress, BufferAsyncError,
+    BufferBinding, BufferBindingType, BufferDescriptor, BufferSize, BufferUsages, ColorTargetState,
+    ColorWrites, CommandEncoder, CommandEncoderDescriptor, CompareFunction, ComputePass,
+    ComputePassDescriptor, ComputePipelineDescriptor as RawComputePipelineDescriptor,
+    DepthBiasState, DepthStencilState, DownlevelFlags, Extent3d, Face, Features as WgpuFeatures,
+    FilterMode, FragmentState as RawFragmentState, FrontFace, ImageSubresourceRange, IndexFormat,
+    Limits as WgpuLimits, LoadOp, Maintain, MapMode, MultisampleState, Operations, Origin3d,
+    PipelineCompilationOptions, PipelineLayout, PipelineLayoutDescriptor, PolygonMode,
+    PrimitiveState, PrimitiveTopology, PushConstantRange, RenderPassColorAttachment,
+    RenderPassDepthStencilAttachment, RenderPassDescriptor,
+    RenderPipelineDescriptor as RawRenderPipelineDescriptor, Sampler as WgpuSampler,
+    SamplerBindingType, SamplerBindingType as WgpuSamplerBindingType, SamplerDescriptor,
+    ShaderModule, ShaderModuleDescriptor, ShaderSource, ShaderStages, StencilFaceState,
+    StencilOperation, StencilState, StorageTextureAccess, StoreOp, TexelCopyBufferInfo,
+    TexelCopyBufferLayout, TexelCopyTextureInfo, TextureAspect, TextureDescriptor,
+    TextureDimension, TextureFormat, TextureFormatFeatureFlags, TextureFormatFeatures,
+    TextureSampleType, TextureUsages, TextureView as WgpuTextureView, TextureViewDescriptor,
+    TextureViewDimension, VertexAttribute, VertexBufferLayout as RawVertexBufferLayout,
+    VertexFormat, VertexState as RawVertexState, VertexStepMode, COPY_BUFFER_ALIGNMENT,
+};
+
+pub use crate::mesh::VertexBufferLayout;
+
+pub mod encase {
+    pub use bevy_encase_derive::ShaderType;
+    pub use encase::*;
+}
+
+pub use self::encase::{ShaderSize, ShaderType};
+
+pub use naga::ShaderStage;

vendor/bevy_render/src/render_resource/pipeline.rs

@@ -0,0 +1,155 @@
+use super::ShaderDefVal;
+use crate::mesh::VertexBufferLayout;
+use crate::renderer::WgpuWrapper;
+use crate::{
+    define_atomic_id,
+    render_resource::{BindGroupLayout, Shader},
+};
+use alloc::borrow::Cow;
+use bevy_asset::Handle;
+use core::ops::Deref;
+use wgpu::{
+    ColorTargetState, DepthStencilState, MultisampleState, PrimitiveState, PushConstantRange,
+};
+
+define_atomic_id!(RenderPipelineId);
+
+/// A [`RenderPipeline`] represents a graphics pipeline and its stages (shaders), bindings and vertex buffers.
+///
+/// May be converted from and dereferences to a wgpu [`RenderPipeline`](wgpu::RenderPipeline).
+/// Can be created via [`RenderDevice::create_render_pipeline`](crate::renderer::RenderDevice::create_render_pipeline).
+#[derive(Clone, Debug)]
+pub struct RenderPipeline {
+    id: RenderPipelineId,
+    value: WgpuWrapper<wgpu::RenderPipeline>,
+}
+
+impl RenderPipeline {
+    #[inline]
+    pub fn id(&self) -> RenderPipelineId {
+        self.id
+    }
+}
+
+impl From<wgpu::RenderPipeline> for RenderPipeline {
+    fn from(value: wgpu::RenderPipeline) -> Self {
+        RenderPipeline {
+            id: RenderPipelineId::new(),
+            value: WgpuWrapper::new(value),
+        }
+    }
+}
+
+impl Deref for RenderPipeline {
+    type Target = wgpu::RenderPipeline;
+
+    #[inline]
+    fn deref(&self) -> &Self::Target {
+        &self.value
+    }
+}
+
+define_atomic_id!(ComputePipelineId);
+
+/// A [`ComputePipeline`] represents a compute pipeline and its single shader stage.
+///
+/// May be converted from and dereferences to a wgpu [`ComputePipeline`](wgpu::ComputePipeline).
+/// Can be created via [`RenderDevice::create_compute_pipeline`](crate::renderer::RenderDevice::create_compute_pipeline).
+#[derive(Clone, Debug)]
+pub struct ComputePipeline {
+    id: ComputePipelineId,
+    value: WgpuWrapper<wgpu::ComputePipeline>,
+}
+
+impl ComputePipeline {
+    /// Returns the [`ComputePipelineId`].
+    #[inline]
+    pub fn id(&self) -> ComputePipelineId {
+        self.id
+    }
+}
+
+impl From<wgpu::ComputePipeline> for ComputePipeline {
+    fn from(value: wgpu::ComputePipeline) -> Self {
+        ComputePipeline {
+            id: ComputePipelineId::new(),
+            value: WgpuWrapper::new(value),
+        }
+    }
+}
+
+impl Deref for ComputePipeline {
+    type Target = wgpu::ComputePipeline;
+
+    #[inline]
+    fn deref(&self) -> &Self::Target {
+        &self.value
+    }
+}
+
+/// Describes a render (graphics) pipeline.
+#[derive(Clone, Debug, PartialEq)]
+pub struct RenderPipelineDescriptor {
+    /// Debug label of the pipeline. This will show up in graphics debuggers for easy identification.
+    pub label: Option<Cow<'static, str>>,
+    /// The layout of bind groups for this pipeline.
+    pub layout: Vec<BindGroupLayout>,
+    /// The push constant ranges for this pipeline.
+    /// Supply an empty vector if the pipeline doesn't use push constants.
+    pub push_constant_ranges: Vec<PushConstantRange>,
+    /// The compiled vertex stage, its entry point, and the input buffers layout.
+    pub vertex: VertexState,
+    /// The properties of the pipeline at the primitive assembly and rasterization level.
+    pub primitive: PrimitiveState,
+    /// The effect of draw calls on the depth and stencil aspects of the output target, if any.
+    pub depth_stencil: Option<DepthStencilState>,
+    /// The multi-sampling properties of the pipeline.
+    pub multisample: MultisampleState,
+    /// The compiled fragment stage, its entry point, and the color targets.
+    pub fragment: Option<FragmentState>,
+    /// Whether to zero-initialize workgroup memory by default. If you're not sure, set this to true.
+    /// If this is false, reading from workgroup variables before writing to them will result in garbage values.
+    pub zero_initialize_workgroup_memory: bool,
+}
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct VertexState {
+    /// The compiled shader module for this stage.
+    pub shader: Handle<Shader>,
+    pub shader_defs: Vec<ShaderDefVal>,
+    /// The name of the entry point in the compiled shader. There must be a
+    /// function with this name in the shader.
+    pub entry_point: Cow<'static, str>,
+    /// The format of any vertex buffers used with this pipeline.
+    pub buffers: Vec<VertexBufferLayout>,
+}
+
+/// Describes the fragment process in a render pipeline.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct FragmentState {
+    /// The compiled shader module for this stage.
+    pub shader: Handle<Shader>,
+    pub shader_defs: Vec<ShaderDefVal>,
+    /// The name of the entry point in the compiled shader. There must be a
+    /// function with this name in the shader.
+    pub entry_point: Cow<'static, str>,
+    /// The color state of the render targets.
+    pub targets: Vec<Option<ColorTargetState>>,
+}
+
+/// Describes a compute pipeline.
+#[derive(Clone, Debug)]
+pub struct ComputePipelineDescriptor {
+    pub label: Option<Cow<'static, str>>,
+    pub layout: Vec<BindGroupLayout>,
+    pub push_constant_ranges: Vec<PushConstantRange>,
+    /// The compiled shader module for this stage.
+    pub shader: Handle<Shader>,
+    pub shader_defs: Vec<ShaderDefVal>,
+    /// The name of the entry point in the compiled shader. There must be a
+    /// function with this name in the shader.
+    pub entry_point: Cow<'static, str>,
+    /// Whether to zero-initialize workgroup memory by default. If you're not sure, set this to true.
+    /// If this is false, reading from workgroup variables before writing to them will result in garbage values.
+    pub zero_initialize_workgroup_memory: bool,
+}

vendor/bevy_render/src/render_resource/pipeline_specializer.rs

@@ -0,0 +1,197 @@
+use crate::{
+    mesh::{MeshVertexBufferLayoutRef, MissingVertexAttributeError, VertexBufferLayout},
+    render_resource::{
+        CachedComputePipelineId, CachedRenderPipelineId, ComputePipelineDescriptor, PipelineCache,
+        RenderPipelineDescriptor,
+    },
+};
+use bevy_ecs::resource::Resource;
+use bevy_platform::{
+    collections::{
+        hash_map::{Entry, RawEntryMut, VacantEntry},
+        HashMap,
+    },
+    hash::FixedHasher,
+};
+use bevy_utils::default;
+use core::{fmt::Debug, hash::Hash};
+use thiserror::Error;
+use tracing::error;
+
+pub trait SpecializedRenderPipeline {
+    type Key: Clone + Hash + PartialEq + Eq;
+    fn specialize(&self, key: Self::Key) -> RenderPipelineDescriptor;
+}
+
+#[derive(Resource)]
+pub struct SpecializedRenderPipelines<S: SpecializedRenderPipeline> {
+    cache: HashMap<S::Key, CachedRenderPipelineId>,
+}
+
+impl<S: SpecializedRenderPipeline> Default for SpecializedRenderPipelines<S> {
+    fn default() -> Self {
+        Self { cache: default() }
+    }
+}
+
+impl<S: SpecializedRenderPipeline> SpecializedRenderPipelines<S> {
+    pub fn specialize(
+        &mut self,
+        cache: &PipelineCache,
+        specialize_pipeline: &S,
+        key: S::Key,
+    ) -> CachedRenderPipelineId {
+        *self.cache.entry(key.clone()).or_insert_with(|| {
+            let descriptor = specialize_pipeline.specialize(key);
+            cache.queue_render_pipeline(descriptor)
+        })
+    }
+}
+
+pub trait SpecializedComputePipeline {
+    type Key: Clone + Hash + PartialEq + Eq;
+    fn specialize(&self, key: Self::Key) -> ComputePipelineDescriptor;
+}
+
+#[derive(Resource)]
+pub struct SpecializedComputePipelines<S: SpecializedComputePipeline> {
+    cache: HashMap<S::Key, CachedComputePipelineId>,
+}
+
+impl<S: SpecializedComputePipeline> Default for SpecializedComputePipelines<S> {
+    fn default() -> Self {
+        Self { cache: default() }
+    }
+}
+
+impl<S: SpecializedComputePipeline> SpecializedComputePipelines<S> {
+    pub fn specialize(
+        &mut self,
+        cache: &PipelineCache,
+        specialize_pipeline: &S,
+        key: S::Key,
+    ) -> CachedComputePipelineId {
+        *self.cache.entry(key.clone()).or_insert_with(|| {
+            let descriptor = specialize_pipeline.specialize(key);
+            cache.queue_compute_pipeline(descriptor)
+        })
+    }
+}
+
+pub trait SpecializedMeshPipeline {
+    type Key: Clone + Hash + PartialEq + Eq;
+    fn specialize(
+        &self,
+        key: Self::Key,
+        layout: &MeshVertexBufferLayoutRef,
+    ) -> Result<RenderPipelineDescriptor, SpecializedMeshPipelineError>;
+}
+
+#[derive(Resource)]
+pub struct SpecializedMeshPipelines<S: SpecializedMeshPipeline> {
+    mesh_layout_cache: HashMap<(MeshVertexBufferLayoutRef, S::Key), CachedRenderPipelineId>,
+    vertex_layout_cache: VertexLayoutCache<S>,
+}
+
+pub type VertexLayoutCache<S> = HashMap<
+    VertexBufferLayout,
+    HashMap<<S as SpecializedMeshPipeline>::Key, CachedRenderPipelineId>,
+>;
+
+impl<S: SpecializedMeshPipeline> Default for SpecializedMeshPipelines<S> {
+    fn default() -> Self {
+        Self {
+            mesh_layout_cache: Default::default(),
+            vertex_layout_cache: Default::default(),
+        }
+    }
+}
+
+impl<S: SpecializedMeshPipeline> SpecializedMeshPipelines<S> {
+    #[inline]
+    pub fn specialize(
+        &mut self,
+        cache: &PipelineCache,
+        specialize_pipeline: &S,
+        key: S::Key,
+        layout: &MeshVertexBufferLayoutRef,
+    ) -> Result<CachedRenderPipelineId, SpecializedMeshPipelineError> {
+        return match self.mesh_layout_cache.entry((layout.clone(), key.clone())) {
+            Entry::Occupied(entry) => Ok(*entry.into_mut()),
+            Entry::Vacant(entry) => specialize_slow(
+                &mut self.vertex_layout_cache,
+                cache,
+                specialize_pipeline,
+                key,
+                layout,
+                entry,
+            ),
+        };
+
+        #[cold]
+        fn specialize_slow<S>(
+            vertex_layout_cache: &mut VertexLayoutCache<S>,
+            cache: &PipelineCache,
+            specialize_pipeline: &S,
+            key: S::Key,
+            layout: &MeshVertexBufferLayoutRef,
+            entry: VacantEntry<
+                (MeshVertexBufferLayoutRef, S::Key),
+                CachedRenderPipelineId,
+                FixedHasher,
+            >,
+        ) -> Result<CachedRenderPipelineId, SpecializedMeshPipelineError>
+        where
+            S: SpecializedMeshPipeline,
+        {
+            let descriptor = specialize_pipeline
+                .specialize(key.clone(), layout)
+                .map_err(|mut err| {
+                    {
+                        let SpecializedMeshPipelineError::MissingVertexAttribute(err) = &mut err;
+                        err.pipeline_type = Some(core::any::type_name::<S>());
+                    }
+                    err
+                })?;
+            // Different MeshVertexBufferLayouts can produce the same final VertexBufferLayout
+            // We want compatible vertex buffer layouts to use the same pipelines, so we must "deduplicate" them
+            let layout_map = match vertex_layout_cache
+                .raw_entry_mut()
+                .from_key(&descriptor.vertex.buffers[0])
+            {
+                RawEntryMut::Occupied(entry) => entry.into_mut(),
+                RawEntryMut::Vacant(entry) => {
+                    entry
+                        .insert(descriptor.vertex.buffers[0].clone(), Default::default())
+                        .1
+                }
+            };
+            Ok(*entry.insert(match layout_map.entry(key) {
+                Entry::Occupied(entry) => {
+                    if cfg!(debug_assertions) {
+                        let stored_descriptor = cache.get_render_pipeline_descriptor(*entry.get());
+                        if stored_descriptor != &descriptor {
+                            error!(
+                                "The cached pipeline descriptor for {} is not \
+                                    equal to the generated descriptor for the given key. \
+                                    This means the SpecializePipeline implementation uses \
+                                    unused' MeshVertexBufferLayout information to specialize \
+                                    the pipeline. This is not allowed because it would invalidate \
+                                    the pipeline cache.",
+                                core::any::type_name::<S>()
+                            );
+                        }
+                    }
+                    *entry.into_mut()
+                }
+                Entry::Vacant(entry) => *entry.insert(cache.queue_render_pipeline(descriptor)),
+            }))
+        }
+    }
+}
+
+#[derive(Error, Debug)]
+pub enum SpecializedMeshPipelineError {
+    #[error(transparent)]
+    MissingVertexAttribute(#[from] MissingVertexAttributeError),
+}

vendor/bevy_render/src/render_resource/resource_macros.rs

@@ -0,0 +1,39 @@
+#[macro_export]
+macro_rules! define_atomic_id {
+    ($atomic_id_type:ident) => {
+        #[derive(Copy, Clone, Hash, Eq, PartialEq, PartialOrd, Ord, Debug)]
+        pub struct $atomic_id_type(core::num::NonZero<u32>);
+
+        impl $atomic_id_type {
+            #[expect(
+                clippy::new_without_default,
+                reason = "Implementing the `Default` trait on atomic IDs would imply that two `<AtomicIdType>::default()` equal each other. By only implementing `new()`, we indicate that each atomic ID created will be unique."
+            )]
+            pub fn new() -> Self {
+                use core::sync::atomic::{AtomicU32, Ordering};
+
+                static COUNTER: AtomicU32 = AtomicU32::new(1);
+
+                let counter = COUNTER.fetch_add(1, Ordering::Relaxed);
+                Self(core::num::NonZero::<u32>::new(counter).unwrap_or_else(|| {
+                    panic!(
+                        "The system ran out of unique `{}`s.",
+                        stringify!($atomic_id_type)
+                    );
+                }))
+            }
+        }
+
+        impl From<$atomic_id_type> for core::num::NonZero<u32> {
+            fn from(value: $atomic_id_type) -> Self {
+                value.0
+            }
+        }
+
+        impl From<core::num::NonZero<u32>> for $atomic_id_type {
+            fn from(value: core::num::NonZero<u32>) -> Self {
+                Self(value)
+            }
+        }
+    };
+}

vendor/bevy_render/src/render_resource/shader.rs

@@ -0,0 +1,414 @@
+use super::ShaderDefVal;
+use crate::define_atomic_id;
+use alloc::borrow::Cow;
+use bevy_asset::{io::Reader, Asset, AssetLoader, AssetPath, Handle, LoadContext};
+use bevy_reflect::TypePath;
+use core::marker::Copy;
+use thiserror::Error;
+
+define_atomic_id!(ShaderId);
+
+#[derive(Error, Debug)]
+pub enum ShaderReflectError {
+    #[error(transparent)]
+    WgslParse(#[from] naga::front::wgsl::ParseError),
+    #[cfg(feature = "shader_format_glsl")]
+    #[error("GLSL Parse Error: {0:?}")]
+    GlslParse(Vec<naga::front::glsl::Error>),
+    #[cfg(feature = "shader_format_spirv")]
+    #[error(transparent)]
+    SpirVParse(#[from] naga::front::spv::Error),
+    #[error(transparent)]
+    Validation(#[from] naga::WithSpan<naga::valid::ValidationError>),
+}
+
+/// Describes whether or not to perform runtime checks on shaders.
+/// Runtime checks can be enabled for safety at the cost of speed.
+/// By default no runtime checks will be performed.
+///
+/// # Panics
+/// Because no runtime checks are performed for spirv,
+/// enabling `ValidateShader` for spirv will cause a panic
+#[derive(Clone, Debug, Default)]
+pub enum ValidateShader {
+    #[default]
+    /// No runtime checks for soundness (e.g. bound checking) are performed.
+    ///
+    /// This is suitable for trusted shaders, written by your program or dependencies you trust.
+    Disabled,
+    /// Enable's runtime checks for soundness (e.g. bound checking).
+    ///
+    /// While this can have a meaningful impact on performance,
+    /// this setting should *always* be enabled when loading untrusted shaders.
+    /// This might occur if you are creating a shader playground, running user-generated shaders
+    /// (as in `VRChat`), or writing a web browser in Bevy.
+    Enabled,
+}
+
+/// A shader, as defined by its [`ShaderSource`](wgpu::ShaderSource) and [`ShaderStage`](naga::ShaderStage)
+/// This is an "unprocessed" shader. It can contain preprocessor directives.
+#[derive(Asset, TypePath, Debug, Clone)]
+pub struct Shader {
+    pub path: String,
+    pub source: Source,
+    pub import_path: ShaderImport,
+    pub imports: Vec<ShaderImport>,
+    // extra imports not specified in the source string
+    pub additional_imports: Vec<naga_oil::compose::ImportDefinition>,
+    // any shader defs that will be included when this module is used
+    pub shader_defs: Vec<ShaderDefVal>,
+    // we must store strong handles to our dependencies to stop them
+    // from being immediately dropped if we are the only user.
+    pub file_dependencies: Vec<Handle<Shader>>,
+    /// Enable or disable runtime shader validation, trading safety against speed.
+    ///
+    /// Please read the [`ValidateShader`] docs for a discussion of the tradeoffs involved.
+    pub validate_shader: ValidateShader,
+}
+
+impl Shader {
+    fn preprocess(source: &str, path: &str) -> (ShaderImport, Vec<ShaderImport>) {
+        let (import_path, imports, _) = naga_oil::compose::get_preprocessor_data(source);
+
+        let import_path = import_path
+            .map(ShaderImport::Custom)
+            .unwrap_or_else(|| ShaderImport::AssetPath(path.to_owned()));
+
+        let imports = imports
+            .into_iter()
+            .map(|import| {
+                if import.import.starts_with('\"') {
+                    let import = import
+                        .import
+                        .chars()
+                        .skip(1)
+                        .take_while(|c| *c != '\"')
+                        .collect();
+                    ShaderImport::AssetPath(import)
+                } else {
+                    ShaderImport::Custom(import.import)
+                }
+            })
+            .collect();
+
+        (import_path, imports)
+    }
+
+    pub fn from_wgsl(source: impl Into<Cow<'static, str>>, path: impl Into<String>) -> Shader {
+        let source = source.into();
+        let path = path.into();
+        let (import_path, imports) = Shader::preprocess(&source, &path);
+        Shader {
+            path,
+            imports,
+            import_path,
+            source: Source::Wgsl(source),
+            additional_imports: Default::default(),
+            shader_defs: Default::default(),
+            file_dependencies: Default::default(),
+            validate_shader: ValidateShader::Disabled,
+        }
+    }
+
+    pub fn from_wgsl_with_defs(
+        source: impl Into<Cow<'static, str>>,
+        path: impl Into<String>,
+        shader_defs: Vec<ShaderDefVal>,
+    ) -> Shader {
+        Self {
+            shader_defs,
+            ..Self::from_wgsl(source, path)
+        }
+    }
+
+    pub fn from_glsl(
+        source: impl Into<Cow<'static, str>>,
+        stage: naga::ShaderStage,
+        path: impl Into<String>,
+    ) -> Shader {
+        let source = source.into();
+        let path = path.into();
+        let (import_path, imports) = Shader::preprocess(&source, &path);
+        Shader {
+            path,
+            imports,
+            import_path,
+            source: Source::Glsl(source, stage),
+            additional_imports: Default::default(),
+            shader_defs: Default::default(),
+            file_dependencies: Default::default(),
+            validate_shader: ValidateShader::Disabled,
+        }
+    }
+
+    pub fn from_spirv(source: impl Into<Cow<'static, [u8]>>, path: impl Into<String>) -> Shader {
+        let path = path.into();
+        Shader {
+            path: path.clone(),
+            imports: Vec::new(),
+            import_path: ShaderImport::AssetPath(path),
+            source: Source::SpirV(source.into()),
+            additional_imports: Default::default(),
+            shader_defs: Default::default(),
+            file_dependencies: Default::default(),
+            validate_shader: ValidateShader::Disabled,
+        }
+    }
+
+    #[cfg(feature = "shader_format_wesl")]
+    pub fn from_wesl(source: impl Into<Cow<'static, str>>, path: impl Into<String>) -> Shader {
+        let source = source.into();
+        let path = path.into();
+        let (import_path, imports) = Shader::preprocess(&source, &path);
+
+        match import_path {
+            ShaderImport::AssetPath(asset_path) => {
+                // Create the shader import path - always starting with "/"
+                let shader_path = std::path::Path::new("/").join(&asset_path);
+
+                // Convert to a string with forward slashes and without extension
+                let import_path_str = shader_path
+                    .with_extension("")
+                    .to_string_lossy()
+                    .replace('\\', "/");
+
+                let import_path = ShaderImport::AssetPath(import_path_str.to_string());
+
+                Shader {
+                    path,
+                    imports,
+                    import_path,
+                    source: Source::Wesl(source),
+                    additional_imports: Default::default(),
+                    shader_defs: Default::default(),
+                    file_dependencies: Default::default(),
+                    validate_shader: ValidateShader::Disabled,
+                }
+            }
+            ShaderImport::Custom(_) => {
+                panic!("Wesl shaders must be imported from an asset path");
+            }
+        }
+    }
+
+    pub fn set_import_path<P: Into<String>>(&mut self, import_path: P) {
+        self.import_path = ShaderImport::Custom(import_path.into());
+    }
+
+    #[must_use]
+    pub fn with_import_path<P: Into<String>>(mut self, import_path: P) -> Self {
+        self.set_import_path(import_path);
+        self
+    }
+
+    #[inline]
+    pub fn import_path(&self) -> &ShaderImport {
+        &self.import_path
+    }
+
+    pub fn imports(&self) -> impl ExactSizeIterator<Item = &ShaderImport> {
+        self.imports.iter()
+    }
+}
+
+impl<'a> From<&'a Shader> for naga_oil::compose::ComposableModuleDescriptor<'a> {
+    fn from(shader: &'a Shader) -> Self {
+        let shader_defs = shader
+            .shader_defs
+            .iter()
+            .map(|def| match def {
+                ShaderDefVal::Bool(name, b) => {
+                    (name.clone(), naga_oil::compose::ShaderDefValue::Bool(*b))
+                }
+                ShaderDefVal::Int(name, i) => {
+                    (name.clone(), naga_oil::compose::ShaderDefValue::Int(*i))
+                }
+                ShaderDefVal::UInt(name, i) => {
+                    (name.clone(), naga_oil::compose::ShaderDefValue::UInt(*i))
+                }
+            })
+            .collect();
+
+        let as_name = match &shader.import_path {
+            ShaderImport::AssetPath(asset_path) => Some(format!("\"{asset_path}\"")),
+            ShaderImport::Custom(_) => None,
+        };
+
+        naga_oil::compose::ComposableModuleDescriptor {
+            source: shader.source.as_str(),
+            file_path: &shader.path,
+            language: (&shader.source).into(),
+            additional_imports: &shader.additional_imports,
+            shader_defs,
+            as_name,
+        }
+    }
+}
+
+impl<'a> From<&'a Shader> for naga_oil::compose::NagaModuleDescriptor<'a> {
+    fn from(shader: &'a Shader) -> Self {
+        naga_oil::compose::NagaModuleDescriptor {
+            source: shader.source.as_str(),
+            file_path: &shader.path,
+            shader_type: (&shader.source).into(),
+            ..Default::default()
+        }
+    }
+}
+
+#[derive(Debug, Clone)]
+pub enum Source {
+    Wgsl(Cow<'static, str>),
+    Wesl(Cow<'static, str>),
+    Glsl(Cow<'static, str>, naga::ShaderStage),
+    SpirV(Cow<'static, [u8]>),
+    // TODO: consider the following
+    // PrecompiledSpirVMacros(HashMap<HashSet<String>, Vec<u32>>)
+    // NagaModule(Module) ... Module impls Serialize/Deserialize
+}
+
+impl Source {
+    pub fn as_str(&self) -> &str {
+        match self {
+            Source::Wgsl(s) | Source::Wesl(s) | Source::Glsl(s, _) => s,
+            Source::SpirV(_) => panic!("spirv not yet implemented"),
+        }
+    }
+}
+
+impl From<&Source> for naga_oil::compose::ShaderLanguage {
+    fn from(value: &Source) -> Self {
+        match value {
+            Source::Wgsl(_) => naga_oil::compose::ShaderLanguage::Wgsl,
+            #[cfg(any(feature = "shader_format_glsl", target_arch = "wasm32"))]
+            Source::Glsl(_, _) => naga_oil::compose::ShaderLanguage::Glsl,
+            #[cfg(all(not(feature = "shader_format_glsl"), not(target_arch = "wasm32")))]
+            Source::Glsl(_, _) => panic!(
+                "GLSL is not supported in this configuration; use the feature `shader_format_glsl`"
+            ),
+            Source::SpirV(_) => panic!("spirv not yet implemented"),
+            Source::Wesl(_) => panic!("wesl not yet implemented"),
+        }
+    }
+}
+
+impl From<&Source> for naga_oil::compose::ShaderType {
+    fn from(value: &Source) -> Self {
+        match value {
+            Source::Wgsl(_) => naga_oil::compose::ShaderType::Wgsl,
+            #[cfg(any(feature = "shader_format_glsl", target_arch = "wasm32"))]
+            Source::Glsl(_, shader_stage) => match shader_stage {
+                naga::ShaderStage::Vertex => naga_oil::compose::ShaderType::GlslVertex,
+                naga::ShaderStage::Fragment => naga_oil::compose::ShaderType::GlslFragment,
+                naga::ShaderStage::Compute => panic!("glsl compute not yet implemented"),
+            },
+            #[cfg(all(not(feature = "shader_format_glsl"), not(target_arch = "wasm32")))]
+            Source::Glsl(_, _) => panic!(
+                "GLSL is not supported in this configuration; use the feature `shader_format_glsl`"
+            ),
+            Source::SpirV(_) => panic!("spirv not yet implemented"),
+            Source::Wesl(_) => panic!("wesl not yet implemented"),
+        }
+    }
+}
+
+#[derive(Default)]
+pub struct ShaderLoader;
+
+#[non_exhaustive]
+#[derive(Debug, Error)]
+pub enum ShaderLoaderError {
+    #[error("Could not load shader: {0}")]
+    Io(#[from] std::io::Error),
+    #[error("Could not parse shader: {0}")]
+    Parse(#[from] alloc::string::FromUtf8Error),
+}
+
+impl AssetLoader for ShaderLoader {
+    type Asset = Shader;
+    type Settings = ();
+    type Error = ShaderLoaderError;
+    async fn load(
+        &self,
+        reader: &mut dyn Reader,
+        _settings: &Self::Settings,
+        load_context: &mut LoadContext<'_>,
+    ) -> Result<Shader, Self::Error> {
+        let ext = load_context.path().extension().unwrap().to_str().unwrap();
+        let path = load_context.asset_path().to_string();
+        // On windows, the path will inconsistently use \ or /.
+        // TODO: remove this once AssetPath forces cross-platform "slash" consistency. See #10511
+        let path = path.replace(std::path::MAIN_SEPARATOR, "/");
+        let mut bytes = Vec::new();
+        reader.read_to_end(&mut bytes).await?;
+        let mut shader = match ext {
+            "spv" => Shader::from_spirv(bytes, load_context.path().to_string_lossy()),
+            "wgsl" => Shader::from_wgsl(String::from_utf8(bytes)?, path),
+            "vert" => Shader::from_glsl(String::from_utf8(bytes)?, naga::ShaderStage::Vertex, path),
+            "frag" => {
+                Shader::from_glsl(String::from_utf8(bytes)?, naga::ShaderStage::Fragment, path)
+            }
+            "comp" => {
+                Shader::from_glsl(String::from_utf8(bytes)?, naga::ShaderStage::Compute, path)
+            }
+            #[cfg(feature = "shader_format_wesl")]
+            "wesl" => Shader::from_wesl(String::from_utf8(bytes)?, path),
+            _ => panic!("unhandled extension: {ext}"),
+        };
+
+        // collect and store file dependencies
+        for import in &shader.imports {
+            if let ShaderImport::AssetPath(asset_path) = import {
+                shader.file_dependencies.push(load_context.load(asset_path));
+            }
+        }
+        Ok(shader)
+    }
+
+    fn extensions(&self) -> &[&str] {
+        &["spv", "wgsl", "vert", "frag", "comp", "wesl"]
+    }
+}
+
+#[derive(Debug, PartialEq, Eq, Clone, Hash)]
+pub enum ShaderImport {
+    AssetPath(String),
+    Custom(String),
+}
+
+impl ShaderImport {
+    pub fn module_name(&self) -> Cow<'_, String> {
+        match self {
+            ShaderImport::AssetPath(s) => Cow::Owned(format!("\"{s}\"")),
+            ShaderImport::Custom(s) => Cow::Borrowed(s),
+        }
+    }
+}
+
+/// A reference to a shader asset.
+pub enum ShaderRef {
+    /// Use the "default" shader for the current context.
+    Default,
+    /// A handle to a shader stored in the [`Assets<Shader>`](bevy_asset::Assets) resource
+    Handle(Handle<Shader>),
+    /// An asset path leading to a shader
+    Path(AssetPath<'static>),
+}
+
+impl From<Handle<Shader>> for ShaderRef {
+    fn from(handle: Handle<Shader>) -> Self {
+        Self::Handle(handle)
+    }
+}
+
+impl From<AssetPath<'static>> for ShaderRef {
+    fn from(path: AssetPath<'static>) -> Self {
+        Self::Path(path)
+    }
+}
+
+impl From<&'static str> for ShaderRef {
+    fn from(path: &'static str) -> Self {
+        Self::Path(AssetPath::from(path))
+    }
+}

vendor/bevy_render/src/render_resource/storage_buffer.rs

@@ -0,0 +1,285 @@
+use core::marker::PhantomData;
+
+use super::Buffer;
+use crate::renderer::{RenderDevice, RenderQueue};
+use encase::{
+    internal::WriteInto, DynamicStorageBuffer as DynamicStorageBufferWrapper, ShaderType,
+    StorageBuffer as StorageBufferWrapper,
+};
+use wgpu::{util::BufferInitDescriptor, BindingResource, BufferBinding, BufferSize, BufferUsages};
+
+use super::IntoBinding;
+
+/// Stores data to be transferred to the GPU and made accessible to shaders as a storage buffer.
+///
+/// Storage buffers can be made available to shaders in some combination of read/write mode, and can store large amounts of data.
+/// Note however that WebGL2 does not support storage buffers, so consider alternative options in this case.
+///
+/// Storage buffers can store runtime-sized arrays, but only if they are the last field in a structure.
+///
+/// The contained data is stored in system RAM. [`write_buffer`](StorageBuffer::write_buffer) queues
+/// copying of the data from system RAM to VRAM. Storage buffers must conform to [std430 alignment/padding requirements], which
+/// is automatically enforced by this structure.
+///
+/// Other options for storing GPU-accessible data are:
+/// * [`BufferVec`](crate::render_resource::BufferVec)
+/// * [`DynamicStorageBuffer`]
+/// * [`DynamicUniformBuffer`](crate::render_resource::DynamicUniformBuffer)
+/// * [`GpuArrayBuffer`](crate::render_resource::GpuArrayBuffer)
+/// * [`RawBufferVec`](crate::render_resource::RawBufferVec)
+/// * [`Texture`](crate::render_resource::Texture)
+/// * [`UniformBuffer`](crate::render_resource::UniformBuffer)
+///
+/// [std430 alignment/padding requirements]: https://www.w3.org/TR/WGSL/#address-spaces-storage
+pub struct StorageBuffer<T: ShaderType> {
+    value: T,
+    scratch: StorageBufferWrapper<Vec<u8>>,
+    buffer: Option<Buffer>,
+    label: Option<String>,
+    changed: bool,
+    buffer_usage: BufferUsages,
+    last_written_size: Option<BufferSize>,
+}
+
+impl<T: ShaderType> From<T> for StorageBuffer<T> {
+    fn from(value: T) -> Self {
+        Self {
+            value,
+            scratch: StorageBufferWrapper::new(Vec::new()),
+            buffer: None,
+            label: None,
+            changed: false,
+            buffer_usage: BufferUsages::COPY_DST | BufferUsages::STORAGE,
+            last_written_size: None,
+        }
+    }
+}
+
+impl<T: ShaderType + Default> Default for StorageBuffer<T> {
+    fn default() -> Self {
+        Self {
+            value: T::default(),
+            scratch: StorageBufferWrapper::new(Vec::new()),
+            buffer: None,
+            label: None,
+            changed: false,
+            buffer_usage: BufferUsages::COPY_DST | BufferUsages::STORAGE,
+            last_written_size: None,
+        }
+    }
+}
+
+impl<T: ShaderType + WriteInto> StorageBuffer<T> {
+    #[inline]
+    pub fn buffer(&self) -> Option<&Buffer> {
+        self.buffer.as_ref()
+    }
+
+    #[inline]
+    pub fn binding(&self) -> Option<BindingResource> {
+        Some(BindingResource::Buffer(BufferBinding {
+            buffer: self.buffer()?,
+            offset: 0,
+            size: self.last_written_size,
+        }))
+    }
+
+    pub fn set(&mut self, value: T) {
+        self.value = value;
+    }
+
+    pub fn get(&self) -> &T {
+        &self.value
+    }
+
+    pub fn get_mut(&mut self) -> &mut T {
+        &mut self.value
+    }
+
+    pub fn set_label(&mut self, label: Option<&str>) {
+        let label = label.map(str::to_string);
+
+        if label != self.label {
+            self.changed = true;
+        }
+
+        self.label = label;
+    }
+
+    pub fn get_label(&self) -> Option<&str> {
+        self.label.as_deref()
+    }
+
+    /// Add more [`BufferUsages`] to the buffer.
+    ///
+    /// This method only allows addition of flags to the default usage flags.
+    ///
+    /// The default values for buffer usage are `BufferUsages::COPY_DST` and `BufferUsages::STORAGE`.
+    pub fn add_usages(&mut self, usage: BufferUsages) {
+        self.buffer_usage |= usage;
+        self.changed = true;
+    }
+
+    /// Queues writing of data from system RAM to VRAM using the [`RenderDevice`]
+    /// and the provided [`RenderQueue`].
+    ///
+    /// If there is no GPU-side buffer allocated to hold the data currently stored, or if a GPU-side buffer previously
+    /// allocated does not have enough capacity, a new GPU-side buffer is created.
+    pub fn write_buffer(&mut self, device: &RenderDevice, queue: &RenderQueue) {
+        self.scratch.write(&self.value).unwrap();
+
+        let capacity = self.buffer.as_deref().map(wgpu::Buffer::size).unwrap_or(0);
+        let size = self.scratch.as_ref().len() as u64;
+
+        if capacity < size || self.changed {
+            self.buffer = Some(device.create_buffer_with_data(&BufferInitDescriptor {
+                label: self.label.as_deref(),
+                usage: self.buffer_usage,
+                contents: self.scratch.as_ref(),
+            }));
+            self.changed = false;
+        } else if let Some(buffer) = &self.buffer {
+            queue.write_buffer(buffer, 0, self.scratch.as_ref());
+        }
+
+        self.last_written_size = BufferSize::new(size);
+    }
+}
+
+impl<'a, T: ShaderType + WriteInto> IntoBinding<'a> for &'a StorageBuffer<T> {
+    #[inline]
+    fn into_binding(self) -> BindingResource<'a> {
+        self.binding().expect("Failed to get buffer")
+    }
+}
+
+/// Stores data to be transferred to the GPU and made accessible to shaders as a dynamic storage buffer.
+///
+/// This is just a [`StorageBuffer`], but also allows you to set dynamic offsets.
+///
+/// Dynamic storage buffers can be made available to shaders in some combination of read/write mode, and can store large amounts
+/// of data. Note however that WebGL2 does not support storage buffers, so consider alternative options in this case. Dynamic
+/// storage buffers support multiple separate bindings at dynamic byte offsets and so have a
+/// [`push`](DynamicStorageBuffer::push) method.
+///
+/// The contained data is stored in system RAM. [`write_buffer`](DynamicStorageBuffer::write_buffer)
+/// queues copying of the data from system RAM to VRAM. The data within a storage buffer binding must conform to
+/// [std430 alignment/padding requirements]. `DynamicStorageBuffer` takes care of serializing the inner type to conform to
+/// these requirements. Each item [`push`](DynamicStorageBuffer::push)ed into this structure
+/// will additionally be aligned to meet dynamic offset alignment requirements.
+///
+/// Other options for storing GPU-accessible data are:
+/// * [`BufferVec`](crate::render_resource::BufferVec)
+/// * [`DynamicUniformBuffer`](crate::render_resource::DynamicUniformBuffer)
+/// * [`GpuArrayBuffer`](crate::render_resource::GpuArrayBuffer)
+/// * [`RawBufferVec`](crate::render_resource::RawBufferVec)
+/// * [`StorageBuffer`]
+/// * [`Texture`](crate::render_resource::Texture)
+/// * [`UniformBuffer`](crate::render_resource::UniformBuffer)
+///
+/// [std430 alignment/padding requirements]: https://www.w3.org/TR/WGSL/#address-spaces-storage
+pub struct DynamicStorageBuffer<T: ShaderType> {
+    scratch: DynamicStorageBufferWrapper<Vec<u8>>,
+    buffer: Option<Buffer>,
+    label: Option<String>,
+    changed: bool,
+    buffer_usage: BufferUsages,
+    last_written_size: Option<BufferSize>,
+    _marker: PhantomData<fn() -> T>,
+}
+
+impl<T: ShaderType> Default for DynamicStorageBuffer<T> {
+    fn default() -> Self {
+        Self {
+            scratch: DynamicStorageBufferWrapper::new(Vec::new()),
+            buffer: None,
+            label: None,
+            changed: false,
+            buffer_usage: BufferUsages::COPY_DST | BufferUsages::STORAGE,
+            last_written_size: None,
+            _marker: PhantomData,
+        }
+    }
+}
+
+impl<T: ShaderType + WriteInto> DynamicStorageBuffer<T> {
+    #[inline]
+    pub fn buffer(&self) -> Option<&Buffer> {
+        self.buffer.as_ref()
+    }
+
+    #[inline]
+    pub fn binding(&self) -> Option<BindingResource> {
+        Some(BindingResource::Buffer(BufferBinding {
+            buffer: self.buffer()?,
+            offset: 0,
+            size: self.last_written_size,
+        }))
+    }
+
+    #[inline]
+    pub fn is_empty(&self) -> bool {
+        self.scratch.as_ref().is_empty()
+    }
+
+    #[inline]
+    pub fn push(&mut self, value: T) -> u32 {
+        self.scratch.write(&value).unwrap() as u32
+    }
+
+    pub fn set_label(&mut self, label: Option<&str>) {
+        let label = label.map(str::to_string);
+
+        if label != self.label {
+            self.changed = true;
+        }
+
+        self.label = label;
+    }
+
+    pub fn get_label(&self) -> Option<&str> {
+        self.label.as_deref()
+    }
+
+    /// Add more [`BufferUsages`] to the buffer.
+    ///
+    /// This method only allows addition of flags to the default usage flags.
+    ///
+    /// The default values for buffer usage are `BufferUsages::COPY_DST` and `BufferUsages::STORAGE`.
+    pub fn add_usages(&mut self, usage: BufferUsages) {
+        self.buffer_usage |= usage;
+        self.changed = true;
+    }
+
+    #[inline]
+    pub fn write_buffer(&mut self, device: &RenderDevice, queue: &RenderQueue) {
+        let capacity = self.buffer.as_deref().map(wgpu::Buffer::size).unwrap_or(0);
+        let size = self.scratch.as_ref().len() as u64;
+
+        if capacity < size || (self.changed && size > 0) {
+            self.buffer = Some(device.create_buffer_with_data(&BufferInitDescriptor {
+                label: self.label.as_deref(),
+                usage: self.buffer_usage,
+                contents: self.scratch.as_ref(),
+            }));
+            self.changed = false;
+        } else if let Some(buffer) = &self.buffer {
+            queue.write_buffer(buffer, 0, self.scratch.as_ref());
+        }
+
+        self.last_written_size = BufferSize::new(size);
+    }
+
+    #[inline]
+    pub fn clear(&mut self) {
+        self.scratch.as_mut().clear();
+        self.scratch.set_offset(0);
+    }
+}
+
+impl<'a, T: ShaderType + WriteInto> IntoBinding<'a> for &'a DynamicStorageBuffer<T> {
+    #[inline]
+    fn into_binding(self) -> BindingResource<'a> {
+        self.binding().expect("Failed to get buffer")
+    }
+}

vendor/bevy_render/src/render_resource/texture.rs

@@ -0,0 +1,166 @@
+use crate::define_atomic_id;
+use crate::renderer::WgpuWrapper;
+use bevy_derive::{Deref, DerefMut};
+use bevy_ecs::resource::Resource;
+use core::ops::Deref;
+
+define_atomic_id!(TextureId);
+
+/// A GPU-accessible texture.
+///
+/// May be converted from and dereferences to a wgpu [`Texture`](wgpu::Texture).
+/// Can be created via [`RenderDevice::create_texture`](crate::renderer::RenderDevice::create_texture).
+///
+/// Other options for storing GPU-accessible data are:
+/// * [`BufferVec`](crate::render_resource::BufferVec)
+/// * [`DynamicStorageBuffer`](crate::render_resource::DynamicStorageBuffer)
+/// * [`DynamicUniformBuffer`](crate::render_resource::DynamicUniformBuffer)
+/// * [`GpuArrayBuffer`](crate::render_resource::GpuArrayBuffer)
+/// * [`RawBufferVec`](crate::render_resource::RawBufferVec)
+/// * [`StorageBuffer`](crate::render_resource::StorageBuffer)
+/// * [`UniformBuffer`](crate::render_resource::UniformBuffer)
+#[derive(Clone, Debug)]
+pub struct Texture {
+    id: TextureId,
+    value: WgpuWrapper<wgpu::Texture>,
+}
+
+impl Texture {
+    /// Returns the [`TextureId`].
+    #[inline]
+    pub fn id(&self) -> TextureId {
+        self.id
+    }
+
+    /// Creates a view of this texture.
+    pub fn create_view(&self, desc: &wgpu::TextureViewDescriptor) -> TextureView {
+        TextureView::from(self.value.create_view(desc))
+    }
+}
+
+impl From<wgpu::Texture> for Texture {
+    fn from(value: wgpu::Texture) -> Self {
+        Texture {
+            id: TextureId::new(),
+            value: WgpuWrapper::new(value),
+        }
+    }
+}
+
+impl Deref for Texture {
+    type Target = wgpu::Texture;
+
+    #[inline]
+    fn deref(&self) -> &Self::Target {
+        &self.value
+    }
+}
+
+define_atomic_id!(TextureViewId);
+
+/// Describes a [`Texture`] with its associated metadata required by a pipeline or [`BindGroup`](super::BindGroup).
+#[derive(Clone, Debug)]
+pub struct TextureView {
+    id: TextureViewId,
+    value: WgpuWrapper<wgpu::TextureView>,
+}
+
+pub struct SurfaceTexture {
+    value: WgpuWrapper<wgpu::SurfaceTexture>,
+}
+
+impl SurfaceTexture {
+    pub fn present(self) {
+        self.value.into_inner().present();
+    }
+}
+
+impl TextureView {
+    /// Returns the [`TextureViewId`].
+    #[inline]
+    pub fn id(&self) -> TextureViewId {
+        self.id
+    }
+}
+
+impl From<wgpu::TextureView> for TextureView {
+    fn from(value: wgpu::TextureView) -> Self {
+        TextureView {
+            id: TextureViewId::new(),
+            value: WgpuWrapper::new(value),
+        }
+    }
+}
+
+impl From<wgpu::SurfaceTexture> for SurfaceTexture {
+    fn from(value: wgpu::SurfaceTexture) -> Self {
+        SurfaceTexture {
+            value: WgpuWrapper::new(value),
+        }
+    }
+}
+
+impl Deref for TextureView {
+    type Target = wgpu::TextureView;
+
+    #[inline]
+    fn deref(&self) -> &Self::Target {
+        &self.value
+    }
+}
+
+impl Deref for SurfaceTexture {
+    type Target = wgpu::SurfaceTexture;
+
+    #[inline]
+    fn deref(&self) -> &Self::Target {
+        &self.value
+    }
+}
+
+define_atomic_id!(SamplerId);
+
+/// A Sampler defines how a pipeline will sample from a [`TextureView`].
+/// They define image filters (including anisotropy) and address (wrapping) modes, among other things.
+///
+/// May be converted from and dereferences to a wgpu [`Sampler`](wgpu::Sampler).
+/// Can be created via [`RenderDevice::create_sampler`](crate::renderer::RenderDevice::create_sampler).
+#[derive(Clone, Debug)]
+pub struct Sampler {
+    id: SamplerId,
+    value: WgpuWrapper<wgpu::Sampler>,
+}
+
+impl Sampler {
+    /// Returns the [`SamplerId`].
+    #[inline]
+    pub fn id(&self) -> SamplerId {
+        self.id
+    }
+}
+
+impl From<wgpu::Sampler> for Sampler {
+    fn from(value: wgpu::Sampler) -> Self {
+        Sampler {
+            id: SamplerId::new(),
+            value: WgpuWrapper::new(value),
+        }
+    }
+}
+
+impl Deref for Sampler {
+    type Target = wgpu::Sampler;
+
+    #[inline]
+    fn deref(&self) -> &Self::Target {
+        &self.value
+    }
+}
+
+/// A rendering resource for the default image sampler which is set during renderer
+/// initialization.
+///
+/// The [`ImagePlugin`](crate::texture::ImagePlugin) can be set during app initialization to change the default
+/// image sampler.
+#[derive(Resource, Debug, Clone, Deref, DerefMut)]
+pub struct DefaultImageSampler(pub(crate) Sampler);

vendor/bevy_render/src/render_resource/uniform_buffer.rs

@@ -0,0 +1,402 @@
+use core::{marker::PhantomData, num::NonZero};
+
+use crate::{
+    render_resource::Buffer,
+    renderer::{RenderDevice, RenderQueue},
+};
+use encase::{
+    internal::{AlignmentValue, BufferMut, WriteInto},
+    DynamicUniformBuffer as DynamicUniformBufferWrapper, ShaderType,
+    UniformBuffer as UniformBufferWrapper,
+};
+use wgpu::{
+    util::BufferInitDescriptor, BindingResource, BufferBinding, BufferDescriptor, BufferUsages,
+};
+
+use super::IntoBinding;
+
+/// Stores data to be transferred to the GPU and made accessible to shaders as a uniform buffer.
+///
+/// Uniform buffers are available to shaders on a read-only basis. Uniform buffers are commonly used to make available to shaders
+/// parameters that are constant during shader execution, and are best used for data that is relatively small in size as they are
+/// only guaranteed to support up to 16kB per binding.
+///
+/// The contained data is stored in system RAM. [`write_buffer`](UniformBuffer::write_buffer) queues
+/// copying of the data from system RAM to VRAM. Data in uniform buffers must follow [std140 alignment/padding requirements],
+/// which is automatically enforced by this structure. Per the WGPU spec, uniform buffers cannot store runtime-sized array
+/// (vectors), or structures with fields that are vectors.
+///
+/// Other options for storing GPU-accessible data are:
+/// * [`BufferVec`](crate::render_resource::BufferVec)
+/// * [`DynamicStorageBuffer`](crate::render_resource::DynamicStorageBuffer)
+/// * [`DynamicUniformBuffer`]
+/// * [`GpuArrayBuffer`](crate::render_resource::GpuArrayBuffer)
+/// * [`RawBufferVec`](crate::render_resource::RawBufferVec)
+/// * [`StorageBuffer`](crate::render_resource::StorageBuffer)
+/// * [`Texture`](crate::render_resource::Texture)
+///
+/// [std140 alignment/padding requirements]: https://www.w3.org/TR/WGSL/#address-spaces-uniform
+pub struct UniformBuffer<T: ShaderType> {
+    value: T,
+    scratch: UniformBufferWrapper<Vec<u8>>,
+    buffer: Option<Buffer>,
+    label: Option<String>,
+    changed: bool,
+    buffer_usage: BufferUsages,
+}
+
+impl<T: ShaderType> From<T> for UniformBuffer<T> {
+    fn from(value: T) -> Self {
+        Self {
+            value,
+            scratch: UniformBufferWrapper::new(Vec::new()),
+            buffer: None,
+            label: None,
+            changed: false,
+            buffer_usage: BufferUsages::COPY_DST | BufferUsages::UNIFORM,
+        }
+    }
+}
+
+impl<T: ShaderType + Default> Default for UniformBuffer<T> {
+    fn default() -> Self {
+        Self {
+            value: T::default(),
+            scratch: UniformBufferWrapper::new(Vec::new()),
+            buffer: None,
+            label: None,
+            changed: false,
+            buffer_usage: BufferUsages::COPY_DST | BufferUsages::UNIFORM,
+        }
+    }
+}
+
+impl<T: ShaderType + WriteInto> UniformBuffer<T> {
+    #[inline]
+    pub fn buffer(&self) -> Option<&Buffer> {
+        self.buffer.as_ref()
+    }
+
+    #[inline]
+    pub fn binding(&self) -> Option<BindingResource> {
+        Some(BindingResource::Buffer(
+            self.buffer()?.as_entire_buffer_binding(),
+        ))
+    }
+
+    /// Set the data the buffer stores.
+    pub fn set(&mut self, value: T) {
+        self.value = value;
+    }
+
+    pub fn get(&self) -> &T {
+        &self.value
+    }
+
+    pub fn get_mut(&mut self) -> &mut T {
+        &mut self.value
+    }
+
+    pub fn set_label(&mut self, label: Option<&str>) {
+        let label = label.map(str::to_string);
+
+        if label != self.label {
+            self.changed = true;
+        }
+
+        self.label = label;
+    }
+
+    pub fn get_label(&self) -> Option<&str> {
+        self.label.as_deref()
+    }
+
+    /// Add more [`BufferUsages`] to the buffer.
+    ///
+    /// This method only allows addition of flags to the default usage flags.
+    ///
+    /// The default values for buffer usage are `BufferUsages::COPY_DST` and `BufferUsages::UNIFORM`.
+    pub fn add_usages(&mut self, usage: BufferUsages) {
+        self.buffer_usage |= usage;
+        self.changed = true;
+    }
+
+    /// Queues writing of data from system RAM to VRAM using the [`RenderDevice`]
+    /// and the provided [`RenderQueue`], if a GPU-side backing buffer already exists.
+    ///
+    /// If a GPU-side buffer does not already exist for this data, such a buffer is initialized with currently
+    /// available data.
+    pub fn write_buffer(&mut self, device: &RenderDevice, queue: &RenderQueue) {
+        self.scratch.write(&self.value).unwrap();
+
+        if self.changed || self.buffer.is_none() {
+            self.buffer = Some(device.create_buffer_with_data(&BufferInitDescriptor {
+                label: self.label.as_deref(),
+                usage: self.buffer_usage,
+                contents: self.scratch.as_ref(),
+            }));
+            self.changed = false;
+        } else if let Some(buffer) = &self.buffer {
+            queue.write_buffer(buffer, 0, self.scratch.as_ref());
+        }
+    }
+}
+
+impl<'a, T: ShaderType + WriteInto> IntoBinding<'a> for &'a UniformBuffer<T> {
+    #[inline]
+    fn into_binding(self) -> BindingResource<'a> {
+        self.buffer()
+            .expect("Failed to get buffer")
+            .as_entire_buffer_binding()
+            .into_binding()
+    }
+}
+
+/// Stores data to be transferred to the GPU and made accessible to shaders as a dynamic uniform buffer.
+///
+/// Dynamic uniform buffers are available to shaders on a read-only basis. Dynamic uniform buffers are commonly used to make
+/// available to shaders runtime-sized arrays of parameters that are otherwise constant during shader execution, and are best
+/// suited to data that is relatively small in size as they are only guaranteed to support up to 16kB per binding.
+///
+/// The contained data is stored in system RAM. [`write_buffer`](DynamicUniformBuffer::write_buffer) queues
+/// copying of the data from system RAM to VRAM. Data in uniform buffers must follow [std140 alignment/padding requirements],
+/// which is automatically enforced by this structure. Per the WGPU spec, uniform buffers cannot store runtime-sized array
+/// (vectors), or structures with fields that are vectors.
+///
+/// Other options for storing GPU-accessible data are:
+/// * [`BufferVec`](crate::render_resource::BufferVec)
+/// * [`DynamicStorageBuffer`](crate::render_resource::DynamicStorageBuffer)
+/// * [`GpuArrayBuffer`](crate::render_resource::GpuArrayBuffer)
+/// * [`RawBufferVec`](crate::render_resource::RawBufferVec)
+/// * [`StorageBuffer`](crate::render_resource::StorageBuffer)
+/// * [`Texture`](crate::render_resource::Texture)
+/// * [`UniformBuffer`]
+///
+/// [std140 alignment/padding requirements]: https://www.w3.org/TR/WGSL/#address-spaces-uniform
+pub struct DynamicUniformBuffer<T: ShaderType> {
+    scratch: DynamicUniformBufferWrapper<Vec<u8>>,
+    buffer: Option<Buffer>,
+    label: Option<String>,
+    changed: bool,
+    buffer_usage: BufferUsages,
+    _marker: PhantomData<fn() -> T>,
+}
+
+impl<T: ShaderType> Default for DynamicUniformBuffer<T> {
+    fn default() -> Self {
+        Self {
+            scratch: DynamicUniformBufferWrapper::new(Vec::new()),
+            buffer: None,
+            label: None,
+            changed: false,
+            buffer_usage: BufferUsages::COPY_DST | BufferUsages::UNIFORM,
+            _marker: PhantomData,
+        }
+    }
+}
+
+impl<T: ShaderType + WriteInto> DynamicUniformBuffer<T> {
+    pub fn new_with_alignment(alignment: u64) -> Self {
+        Self {
+            scratch: DynamicUniformBufferWrapper::new_with_alignment(Vec::new(), alignment),
+            buffer: None,
+            label: None,
+            changed: false,
+            buffer_usage: BufferUsages::COPY_DST | BufferUsages::UNIFORM,
+            _marker: PhantomData,
+        }
+    }
+
+    #[inline]
+    pub fn buffer(&self) -> Option<&Buffer> {
+        self.buffer.as_ref()
+    }
+
+    #[inline]
+    pub fn binding(&self) -> Option<BindingResource> {
+        Some(BindingResource::Buffer(BufferBinding {
+            buffer: self.buffer()?,
+            offset: 0,
+            size: Some(T::min_size()),
+        }))
+    }
+
+    #[inline]
+    pub fn is_empty(&self) -> bool {
+        self.scratch.as_ref().is_empty()
+    }
+
+    /// Push data into the `DynamicUniformBuffer`'s internal vector (residing on system RAM).
+    #[inline]
+    pub fn push(&mut self, value: &T) -> u32 {
+        self.scratch.write(value).unwrap() as u32
+    }
+
+    pub fn set_label(&mut self, label: Option<&str>) {
+        let label = label.map(str::to_string);
+
+        if label != self.label {
+            self.changed = true;
+        }
+
+        self.label = label;
+    }
+
+    pub fn get_label(&self) -> Option<&str> {
+        self.label.as_deref()
+    }
+
+    /// Add more [`BufferUsages`] to the buffer.
+    ///
+    /// This method only allows addition of flags to the default usage flags.
+    ///
+    /// The default values for buffer usage are `BufferUsages::COPY_DST` and `BufferUsages::UNIFORM`.
+    pub fn add_usages(&mut self, usage: BufferUsages) {
+        self.buffer_usage |= usage;
+        self.changed = true;
+    }
+
+    /// Creates a writer that can be used to directly write elements into the target buffer.
+    ///
+    /// This method uses less memory and performs fewer memory copies using over [`push`] and [`write_buffer`].
+    ///
+    /// `max_count` *must* be greater than or equal to the number of elements that are to be written to the buffer, or
+    /// the writer will panic while writing.  Dropping the writer will schedule the buffer write into the provided
+    /// [`RenderQueue`].
+    ///
+    /// If there is no GPU-side buffer allocated to hold the data currently stored, or if a GPU-side buffer previously
+    /// allocated does not have enough capacity to hold `max_count` elements, a new GPU-side buffer is created.
+    ///
+    /// Returns `None` if there is no allocated GPU-side buffer, and `max_count` is 0.
+    ///
+    /// [`push`]: Self::push
+    /// [`write_buffer`]: Self::write_buffer
+    #[inline]
+    pub fn get_writer<'a>(
+        &'a mut self,
+        max_count: usize,
+        device: &RenderDevice,
+        queue: &'a RenderQueue,
+    ) -> Option<DynamicUniformBufferWriter<'a, T>> {
+        let alignment = if cfg!(target_abi = "sim") {
+            // On iOS simulator on silicon macs, metal validation check that the host OS alignment
+            // is respected, but the device reports the correct value for iOS, which is smaller.
+            // Use the larger value.
+            // See https://github.com/gfx-rs/wgpu/issues/7057 - remove if it's not needed anymore.
+            AlignmentValue::new(256)
+        } else {
+            AlignmentValue::new(device.limits().min_uniform_buffer_offset_alignment as u64)
+        };
+
+        let mut capacity = self.buffer.as_deref().map(wgpu::Buffer::size).unwrap_or(0);
+        let size = alignment
+            .round_up(T::min_size().get())
+            .checked_mul(max_count as u64)
+            .unwrap();
+
+        if capacity < size || (self.changed && size > 0) {
+            let buffer = device.create_buffer(&BufferDescriptor {
+                label: self.label.as_deref(),
+                usage: self.buffer_usage,
+                size,
+                mapped_at_creation: false,
+            });
+            capacity = buffer.size();
+            self.buffer = Some(buffer);
+            self.changed = false;
+        }
+
+        if let Some(buffer) = self.buffer.as_deref() {
+            let buffer_view = queue
+                .write_buffer_with(buffer, 0, NonZero::<u64>::new(buffer.size())?)
+                .unwrap();
+            Some(DynamicUniformBufferWriter {
+                buffer: encase::DynamicUniformBuffer::new_with_alignment(
+                    QueueWriteBufferViewWrapper {
+                        capacity: capacity as usize,
+                        buffer_view,
+                    },
+                    alignment.get(),
+                ),
+                _marker: PhantomData,
+            })
+        } else {
+            None
+        }
+    }
+
+    /// Queues writing of data from system RAM to VRAM using the [`RenderDevice`]
+    /// and the provided [`RenderQueue`].
+    ///
+    /// If there is no GPU-side buffer allocated to hold the data currently stored, or if a GPU-side buffer previously
+    /// allocated does not have enough capacity, a new GPU-side buffer is created.
+    #[inline]
+    pub fn write_buffer(&mut self, device: &RenderDevice, queue: &RenderQueue) {
+        let capacity = self.buffer.as_deref().map(wgpu::Buffer::size).unwrap_or(0);
+        let size = self.scratch.as_ref().len() as u64;
+
+        if capacity < size || (self.changed && size > 0) {
+            self.buffer = Some(device.create_buffer_with_data(&BufferInitDescriptor {
+                label: self.label.as_deref(),
+                usage: self.buffer_usage,
+                contents: self.scratch.as_ref(),
+            }));
+            self.changed = false;
+        } else if let Some(buffer) = &self.buffer {
+            queue.write_buffer(buffer, 0, self.scratch.as_ref());
+        }
+    }
+
+    #[inline]
+    pub fn clear(&mut self) {
+        self.scratch.as_mut().clear();
+        self.scratch.set_offset(0);
+    }
+}
+
+/// A writer that can be used to directly write elements into the target buffer.
+///
+/// For more information, see [`DynamicUniformBuffer::get_writer`].
+pub struct DynamicUniformBufferWriter<'a, T> {
+    buffer: encase::DynamicUniformBuffer<QueueWriteBufferViewWrapper<'a>>,
+    _marker: PhantomData<fn() -> T>,
+}
+
+impl<'a, T: ShaderType + WriteInto> DynamicUniformBufferWriter<'a, T> {
+    pub fn write(&mut self, value: &T) -> u32 {
+        self.buffer.write(value).unwrap() as u32
+    }
+}
+
+/// A wrapper to work around the orphan rule so that [`wgpu::QueueWriteBufferView`] can  implement
+/// [`BufferMut`].
+struct QueueWriteBufferViewWrapper<'a> {
+    buffer_view: wgpu::QueueWriteBufferView<'a>,
+    // Must be kept separately and cannot be retrieved from buffer_view, as the read-only access will
+    // invoke a panic.
+    capacity: usize,
+}
+
+impl<'a> BufferMut for QueueWriteBufferViewWrapper<'a> {
+    #[inline]
+    fn capacity(&self) -> usize {
+        self.capacity
+    }
+
+    #[inline]
+    fn write<const N: usize>(&mut self, offset: usize, val: &[u8; N]) {
+        self.buffer_view.write(offset, val);
+    }
+
+    #[inline]
+    fn write_slice(&mut self, offset: usize, val: &[u8]) {
+        self.buffer_view.write_slice(offset, val);
+    }
+}
+
+impl<'a, T: ShaderType + WriteInto> IntoBinding<'a> for &'a DynamicUniformBuffer<T> {
+    #[inline]
+    fn into_binding(self) -> BindingResource<'a> {
+        self.binding().unwrap()
+    }
+}

vendor/bevy_render/src/renderer/graph_runner.rs

@@ -0,0 +1,274 @@
+use bevy_ecs::{prelude::Entity, world::World};
+use bevy_platform::collections::HashMap;
+#[cfg(feature = "trace")]
+use tracing::info_span;
+
+use alloc::{borrow::Cow, collections::VecDeque};
+use smallvec::{smallvec, SmallVec};
+use thiserror::Error;
+
+use crate::{
+    diagnostic::internal::{DiagnosticsRecorder, RenderDiagnosticsMutex},
+    render_graph::{
+        Edge, InternedRenderLabel, InternedRenderSubGraph, NodeRunError, NodeState, RenderGraph,
+        RenderGraphContext, SlotLabel, SlotType, SlotValue,
+    },
+    renderer::{RenderContext, RenderDevice},
+};
+
+/// The [`RenderGraphRunner`] is responsible for executing a [`RenderGraph`].
+///
+/// It will run all nodes in the graph sequentially in the correct order (defined by the edges).
+/// Each [`Node`](crate::render_graph::Node) can run any arbitrary code, but will generally
+/// either send directly a [`CommandBuffer`] or a task that will asynchronously generate a [`CommandBuffer`]
+///
+/// After running the graph, the [`RenderGraphRunner`] will execute in parallel all the tasks to get
+/// an ordered list of [`CommandBuffer`]s to execute. These [`CommandBuffer`] will be submitted to the GPU
+/// sequentially in the order that the tasks were submitted. (which is the order of the [`RenderGraph`])
+///
+/// [`CommandBuffer`]: wgpu::CommandBuffer
+pub(crate) struct RenderGraphRunner;
+
+#[derive(Error, Debug)]
+pub enum RenderGraphRunnerError {
+    #[error(transparent)]
+    NodeRunError(#[from] NodeRunError),
+    #[error("node output slot not set (index {slot_index}, name {slot_name})")]
+    EmptyNodeOutputSlot {
+        type_name: &'static str,
+        slot_index: usize,
+        slot_name: Cow<'static, str>,
+    },
+    #[error("graph '{sub_graph:?}' could not be run because slot '{slot_name}' at index {slot_index} has no value")]
+    MissingInput {
+        slot_index: usize,
+        slot_name: Cow<'static, str>,
+        sub_graph: Option<InternedRenderSubGraph>,
+    },
+    #[error("attempted to use the wrong type for input slot")]
+    MismatchedInputSlotType {
+        slot_index: usize,
+        label: SlotLabel,
+        expected: SlotType,
+        actual: SlotType,
+    },
+    #[error(
+        "node (name: '{node_name:?}') has {slot_count} input slots, but was provided {value_count} values"
+    )]
+    MismatchedInputCount {
+        node_name: InternedRenderLabel,
+        slot_count: usize,
+        value_count: usize,
+    },
+}
+
+impl RenderGraphRunner {
+    pub fn run(
+        graph: &RenderGraph,
+        render_device: RenderDevice,
+        mut diagnostics_recorder: Option<DiagnosticsRecorder>,
+        queue: &wgpu::Queue,
+        #[cfg(not(all(target_arch = "wasm32", target_feature = "atomics")))]
+        adapter: &wgpu::Adapter,
+        world: &World,
+        finalizer: impl FnOnce(&mut wgpu::CommandEncoder),
+    ) -> Result<Option<DiagnosticsRecorder>, RenderGraphRunnerError> {
+        if let Some(recorder) = &mut diagnostics_recorder {
+            recorder.begin_frame();
+        }
+
+        let mut render_context = RenderContext::new(
+            render_device,
+            #[cfg(not(all(target_arch = "wasm32", target_feature = "atomics")))]
+            adapter.get_info(),
+            diagnostics_recorder,
+        );
+        Self::run_graph(graph, None, &mut render_context, world, &[], None)?;
+        finalizer(render_context.command_encoder());
+
+        let (render_device, mut diagnostics_recorder) = {
+            let (commands, render_device, diagnostics_recorder) = render_context.finish();
+
+            #[cfg(feature = "trace")]
+            let _span = info_span!("submit_graph_commands").entered();
+            queue.submit(commands);
+
+            (render_device, diagnostics_recorder)
+        };
+
+        if let Some(recorder) = &mut diagnostics_recorder {
+            let render_diagnostics_mutex = world.resource::<RenderDiagnosticsMutex>().0.clone();
+            recorder.finish_frame(&render_device, move |diagnostics| {
+                *render_diagnostics_mutex.lock().expect("lock poisoned") = Some(diagnostics);
+            });
+        }
+
+        Ok(diagnostics_recorder)
+    }
+
+    /// Runs the [`RenderGraph`] and all its sub-graphs sequentially, making sure that all nodes are
+    /// run in the correct order. (a node only runs when all its dependencies have finished running)
+    fn run_graph<'w>(
+        graph: &RenderGraph,
+        sub_graph: Option<InternedRenderSubGraph>,
+        render_context: &mut RenderContext<'w>,
+        world: &'w World,
+        inputs: &[SlotValue],
+        view_entity: Option<Entity>,
+    ) -> Result<(), RenderGraphRunnerError> {
+        let mut node_outputs: HashMap<InternedRenderLabel, SmallVec<[SlotValue; 4]>> =
+            HashMap::default();
+        #[cfg(feature = "trace")]
+        let span = if let Some(label) = &sub_graph {
+            info_span!("run_graph", name = format!("{label:?}"))
+        } else {
+            info_span!("run_graph", name = "main_graph")
+        };
+        #[cfg(feature = "trace")]
+        let _guard = span.enter();
+
+        // Queue up nodes without inputs, which can be run immediately
+        let mut node_queue: VecDeque<&NodeState> = graph
+            .iter_nodes()
+            .filter(|node| node.input_slots.is_empty())
+            .collect();
+
+        // pass inputs into the graph
+        if let Some(input_node) = graph.get_input_node() {
+            let mut input_values: SmallVec<[SlotValue; 4]> = SmallVec::new();
+            for (i, input_slot) in input_node.input_slots.iter().enumerate() {
+                if let Some(input_value) = inputs.get(i) {
+                    if input_slot.slot_type != input_value.slot_type() {
+                        return Err(RenderGraphRunnerError::MismatchedInputSlotType {
+                            slot_index: i,
+                            actual: input_value.slot_type(),
+                            expected: input_slot.slot_type,
+                            label: input_slot.name.clone().into(),
+                        });
+                    }
+                    input_values.push(input_value.clone());
+                } else {
+                    return Err(RenderGraphRunnerError::MissingInput {
+                        slot_index: i,
+                        slot_name: input_slot.name.clone(),
+                        sub_graph,
+                    });
+                }
+            }
+
+            node_outputs.insert(input_node.label, input_values);
+
+            for (_, node_state) in graph
+                .iter_node_outputs(input_node.label)
+                .expect("node exists")
+            {
+                node_queue.push_front(node_state);
+            }
+        }
+
+        'handle_node: while let Some(node_state) = node_queue.pop_back() {
+            // skip nodes that are already processed
+            if node_outputs.contains_key(&node_state.label) {
+                continue;
+            }
+
+            let mut slot_indices_and_inputs: SmallVec<[(usize, SlotValue); 4]> = SmallVec::new();
+            // check if all dependencies have finished running
+            for (edge, input_node) in graph
+                .iter_node_inputs(node_state.label)
+                .expect("node is in graph")
+            {
+                match edge {
+                    Edge::SlotEdge {
+                        output_index,
+                        input_index,
+                        ..
+                    } => {
+                        if let Some(outputs) = node_outputs.get(&input_node.label) {
+                            slot_indices_and_inputs
+                                .push((*input_index, outputs[*output_index].clone()));
+                        } else {
+                            node_queue.push_front(node_state);
+                            continue 'handle_node;
+                        }
+                    }
+                    Edge::NodeEdge { .. } => {
+                        if !node_outputs.contains_key(&input_node.label) {
+                            node_queue.push_front(node_state);
+                            continue 'handle_node;
+                        }
+                    }
+                }
+            }
+
+            // construct final sorted input list
+            slot_indices_and_inputs.sort_by_key(|(index, _)| *index);
+            let inputs: SmallVec<[SlotValue; 4]> = slot_indices_and_inputs
+                .into_iter()
+                .map(|(_, value)| value)
+                .collect();
+
+            if inputs.len() != node_state.input_slots.len() {
+                return Err(RenderGraphRunnerError::MismatchedInputCount {
+                    node_name: node_state.label,
+                    slot_count: node_state.input_slots.len(),
+                    value_count: inputs.len(),
+                });
+            }
+
+            let mut outputs: SmallVec<[Option<SlotValue>; 4]> =
+                smallvec![None; node_state.output_slots.len()];
+            {
+                let mut context = RenderGraphContext::new(graph, node_state, &inputs, &mut outputs);
+                if let Some(view_entity) = view_entity {
+                    context.set_view_entity(view_entity);
+                }
+
+                {
+                    #[cfg(feature = "trace")]
+                    let _span = info_span!("node", name = node_state.type_name).entered();
+
+                    node_state.node.run(&mut context, render_context, world)?;
+                }
+
+                for run_sub_graph in context.finish() {
+                    let sub_graph = graph
+                        .get_sub_graph(run_sub_graph.sub_graph)
+                        .expect("sub graph exists because it was validated when queued.");
+                    Self::run_graph(
+                        sub_graph,
+                        Some(run_sub_graph.sub_graph),
+                        render_context,
+                        world,
+                        &run_sub_graph.inputs,
+                        run_sub_graph.view_entity,
+                    )?;
+                }
+            }
+
+            let mut values: SmallVec<[SlotValue; 4]> = SmallVec::new();
+            for (i, output) in outputs.into_iter().enumerate() {
+                if let Some(value) = output {
+                    values.push(value);
+                } else {
+                    let empty_slot = node_state.output_slots.get_slot(i).unwrap();
+                    return Err(RenderGraphRunnerError::EmptyNodeOutputSlot {
+                        type_name: node_state.type_name,
+                        slot_index: i,
+                        slot_name: empty_slot.name.clone(),
+                    });
+                }
+            }
+            node_outputs.insert(node_state.label, values);
+
+            for (_, node_state) in graph
+                .iter_node_outputs(node_state.label)
+                .expect("node exists")
+            {
+                node_queue.push_front(node_state);
+            }
+        }
+
+        Ok(())
+    }
+}

vendor/bevy_render/src/renderer/mod.rs

@@ -0,0 +1,585 @@
+mod graph_runner;
+mod render_device;
+
+use bevy_derive::{Deref, DerefMut};
+#[cfg(not(all(target_arch = "wasm32", target_feature = "atomics")))]
+use bevy_tasks::ComputeTaskPool;
+pub use graph_runner::*;
+pub use render_device::*;
+use tracing::{error, info, info_span, warn};
+
+use crate::{
+    diagnostic::{internal::DiagnosticsRecorder, RecordDiagnostics},
+    render_graph::RenderGraph,
+    render_phase::TrackedRenderPass,
+    render_resource::RenderPassDescriptor,
+    settings::{WgpuSettings, WgpuSettingsPriority},
+    view::{ExtractedWindows, ViewTarget},
+};
+use alloc::sync::Arc;
+use bevy_ecs::{prelude::*, system::SystemState};
+use bevy_platform::time::Instant;
+use bevy_time::TimeSender;
+use wgpu::{
+    Adapter, AdapterInfo, CommandBuffer, CommandEncoder, DeviceType, Instance, Queue,
+    RequestAdapterOptions,
+};
+
+/// Updates the [`RenderGraph`] with all of its nodes and then runs it to render the entire frame.
+pub fn render_system(world: &mut World, state: &mut SystemState<Query<Entity, With<ViewTarget>>>) {
+    world.resource_scope(|world, mut graph: Mut<RenderGraph>| {
+        graph.update(world);
+    });
+
+    let diagnostics_recorder = world.remove_resource::<DiagnosticsRecorder>();
+
+    let graph = world.resource::<RenderGraph>();
+    let render_device = world.resource::<RenderDevice>();
+    let render_queue = world.resource::<RenderQueue>();
+    #[cfg(not(all(target_arch = "wasm32", target_feature = "atomics")))]
+    let render_adapter = world.resource::<RenderAdapter>();
+
+    let res = RenderGraphRunner::run(
+        graph,
+        render_device.clone(), // TODO: is this clone really necessary?
+        diagnostics_recorder,
+        &render_queue.0,
+        #[cfg(not(all(target_arch = "wasm32", target_feature = "atomics")))]
+        &render_adapter.0,
+        world,
+        |encoder| {
+            crate::view::screenshot::submit_screenshot_commands(world, encoder);
+            crate::gpu_readback::submit_readback_commands(world, encoder);
+        },
+    );
+
+    match res {
+        Ok(Some(diagnostics_recorder)) => {
+            world.insert_resource(diagnostics_recorder);
+        }
+        Ok(None) => {}
+        Err(e) => {
+            error!("Error running render graph:");
+            {
+                let mut src: &dyn core::error::Error = &e;
+                loop {
+                    error!("> {}", src);
+                    match src.source() {
+                        Some(s) => src = s,
+                        None => break,
+                    }
+                }
+            }
+
+            panic!("Error running render graph: {e}");
+        }
+    }
+
+    {
+        let _span = info_span!("present_frames").entered();
+
+        // Remove ViewTarget components to ensure swap chain TextureViews are dropped.
+        // If all TextureViews aren't dropped before present, acquiring the next swap chain texture will fail.
+        let view_entities = state.get(world).iter().collect::<Vec<_>>();
+        for view_entity in view_entities {
+            world.entity_mut(view_entity).remove::<ViewTarget>();
+        }
+
+        let mut windows = world.resource_mut::<ExtractedWindows>();
+        for window in windows.values_mut() {
+            if let Some(surface_texture) = window.swap_chain_texture.take() {
+                // TODO(clean): winit docs recommends calling pre_present_notify before this.
+                // though `present()` doesn't present the frame, it schedules it to be presented
+                // by wgpu.
+                // https://docs.rs/winit/0.29.9/wasm32-unknown-unknown/winit/window/struct.Window.html#method.pre_present_notify
+                surface_texture.present();
+            }
+        }
+
+        #[cfg(feature = "tracing-tracy")]
+        tracing::event!(
+            tracing::Level::INFO,
+            message = "finished frame",
+            tracy.frame_mark = true
+        );
+    }
+
+    crate::view::screenshot::collect_screenshots(world);
+
+    // update the time and send it to the app world
+    let time_sender = world.resource::<TimeSender>();
+    if let Err(error) = time_sender.0.try_send(Instant::now()) {
+        match error {
+            bevy_time::TrySendError::Full(_) => {
+                panic!("The TimeSender channel should always be empty during render. You might need to add the bevy::core::time_system to your app.",);
+            }
+            bevy_time::TrySendError::Disconnected(_) => {
+                // ignore disconnected errors, the main world probably just got dropped during shutdown
+            }
+        }
+    }
+}
+
+/// A wrapper to safely make `wgpu` types Send / Sync on web with atomics enabled.
+///
+/// On web with `atomics` enabled the inner value can only be accessed
+/// or dropped on the `wgpu` thread or else a panic will occur.
+/// On other platforms the wrapper simply contains the wrapped value.
+#[cfg(not(all(target_arch = "wasm32", target_feature = "atomics")))]
+#[derive(Debug, Clone, Deref, DerefMut)]
+pub struct WgpuWrapper<T>(T);
+#[cfg(all(target_arch = "wasm32", target_feature = "atomics"))]
+#[derive(Debug, Clone, Deref, DerefMut)]
+pub struct WgpuWrapper<T>(send_wrapper::SendWrapper<T>);
+
+// SAFETY: SendWrapper is always Send + Sync.
+#[cfg(all(target_arch = "wasm32", target_feature = "atomics"))]
+unsafe impl<T> Send for WgpuWrapper<T> {}
+#[cfg(all(target_arch = "wasm32", target_feature = "atomics"))]
+unsafe impl<T> Sync for WgpuWrapper<T> {}
+
+#[cfg(not(all(target_arch = "wasm32", target_feature = "atomics")))]
+impl<T> WgpuWrapper<T> {
+    pub fn new(t: T) -> Self {
+        Self(t)
+    }
+
+    pub fn into_inner(self) -> T {
+        self.0
+    }
+}
+
+#[cfg(all(target_arch = "wasm32", target_feature = "atomics"))]
+impl<T> WgpuWrapper<T> {
+    pub fn new(t: T) -> Self {
+        Self(send_wrapper::SendWrapper::new(t))
+    }
+
+    pub fn into_inner(self) -> T {
+        self.0.take()
+    }
+}
+
+/// This queue is used to enqueue tasks for the GPU to execute asynchronously.
+#[derive(Resource, Clone, Deref, DerefMut)]
+pub struct RenderQueue(pub Arc<WgpuWrapper<Queue>>);
+
+/// The handle to the physical device being used for rendering.
+/// See [`Adapter`] for more info.
+#[derive(Resource, Clone, Debug, Deref, DerefMut)]
+pub struct RenderAdapter(pub Arc<WgpuWrapper<Adapter>>);
+
+/// The GPU instance is used to initialize the [`RenderQueue`] and [`RenderDevice`],
+/// as well as to create [`WindowSurfaces`](crate::view::window::WindowSurfaces).
+#[derive(Resource, Clone, Deref, DerefMut)]
+pub struct RenderInstance(pub Arc<WgpuWrapper<Instance>>);
+
+/// The [`AdapterInfo`] of the adapter in use by the renderer.
+#[derive(Resource, Clone, Deref, DerefMut)]
+pub struct RenderAdapterInfo(pub WgpuWrapper<AdapterInfo>);
+
+const GPU_NOT_FOUND_ERROR_MESSAGE: &str = if cfg!(target_os = "linux") {
+    "Unable to find a GPU! Make sure you have installed required drivers! For extra information, see: https://github.com/bevyengine/bevy/blob/latest/docs/linux_dependencies.md"
+} else {
+    "Unable to find a GPU! Make sure you have installed required drivers!"
+};
+
+/// Initializes the renderer by retrieving and preparing the GPU instance, device and queue
+/// for the specified backend.
+pub async fn initialize_renderer(
+    instance: &Instance,
+    options: &WgpuSettings,
+    request_adapter_options: &RequestAdapterOptions<'_, '_>,
+) -> (RenderDevice, RenderQueue, RenderAdapterInfo, RenderAdapter) {
+    let adapter = instance
+        .request_adapter(request_adapter_options)
+        .await
+        .expect(GPU_NOT_FOUND_ERROR_MESSAGE);
+
+    let adapter_info = adapter.get_info();
+    info!("{:?}", adapter_info);
+
+    if adapter_info.device_type == DeviceType::Cpu {
+        warn!(
+            "The selected adapter is using a driver that only supports software rendering. \
+             This is likely to be very slow. See https://bevyengine.org/learn/errors/b0006/"
+        );
+    }
+
+    // Maybe get features and limits based on what is supported by the adapter/backend
+    let mut features = wgpu::Features::empty();
+    let mut limits = options.limits.clone();
+    if matches!(options.priority, WgpuSettingsPriority::Functionality) {
+        features = adapter.features();
+        if adapter_info.device_type == DeviceType::DiscreteGpu {
+            // `MAPPABLE_PRIMARY_BUFFERS` can have a significant, negative performance impact for
+            // discrete GPUs due to having to transfer data across the PCI-E bus and so it
+            // should not be automatically enabled in this case. It is however beneficial for
+            // integrated GPUs.
+            features -= wgpu::Features::MAPPABLE_PRIMARY_BUFFERS;
+        }
+
+        // RAY_QUERY and RAY_TRACING_ACCELERATION STRUCTURE will sometimes cause DeviceLost failures on platforms
+        // that report them as supported:
+        // <https://github.com/gfx-rs/wgpu/issues/5488>
+        features -= wgpu::Features::EXPERIMENTAL_RAY_QUERY;
+        features -= wgpu::Features::EXPERIMENTAL_RAY_TRACING_ACCELERATION_STRUCTURE;
+
+        limits = adapter.limits();
+    }
+
+    // Enforce the disabled features
+    if let Some(disabled_features) = options.disabled_features {
+        features -= disabled_features;
+    }
+    // NOTE: |= is used here to ensure that any explicitly-enabled features are respected.
+    features |= options.features;
+
+    // Enforce the limit constraints
+    if let Some(constrained_limits) = options.constrained_limits.as_ref() {
+        // NOTE: Respect the configured limits as an 'upper bound'. This means for 'max' limits, we
+        // take the minimum of the calculated limits according to the adapter/backend and the
+        // specified max_limits. For 'min' limits, take the maximum instead. This is intended to
+        // err on the side of being conservative. We can't claim 'higher' limits that are supported
+        // but we can constrain to 'lower' limits.
+        limits = wgpu::Limits {
+            max_texture_dimension_1d: limits
+                .max_texture_dimension_1d
+                .min(constrained_limits.max_texture_dimension_1d),
+            max_texture_dimension_2d: limits
+                .max_texture_dimension_2d
+                .min(constrained_limits.max_texture_dimension_2d),
+            max_texture_dimension_3d: limits
+                .max_texture_dimension_3d
+                .min(constrained_limits.max_texture_dimension_3d),
+            max_texture_array_layers: limits
+                .max_texture_array_layers
+                .min(constrained_limits.max_texture_array_layers),
+            max_bind_groups: limits
+                .max_bind_groups
+                .min(constrained_limits.max_bind_groups),
+            max_dynamic_uniform_buffers_per_pipeline_layout: limits
+                .max_dynamic_uniform_buffers_per_pipeline_layout
+                .min(constrained_limits.max_dynamic_uniform_buffers_per_pipeline_layout),
+            max_dynamic_storage_buffers_per_pipeline_layout: limits
+                .max_dynamic_storage_buffers_per_pipeline_layout
+                .min(constrained_limits.max_dynamic_storage_buffers_per_pipeline_layout),
+            max_sampled_textures_per_shader_stage: limits
+                .max_sampled_textures_per_shader_stage
+                .min(constrained_limits.max_sampled_textures_per_shader_stage),
+            max_samplers_per_shader_stage: limits
+                .max_samplers_per_shader_stage
+                .min(constrained_limits.max_samplers_per_shader_stage),
+            max_storage_buffers_per_shader_stage: limits
+                .max_storage_buffers_per_shader_stage
+                .min(constrained_limits.max_storage_buffers_per_shader_stage),
+            max_storage_textures_per_shader_stage: limits
+                .max_storage_textures_per_shader_stage
+                .min(constrained_limits.max_storage_textures_per_shader_stage),
+            max_uniform_buffers_per_shader_stage: limits
+                .max_uniform_buffers_per_shader_stage
+                .min(constrained_limits.max_uniform_buffers_per_shader_stage),
+            max_uniform_buffer_binding_size: limits
+                .max_uniform_buffer_binding_size
+                .min(constrained_limits.max_uniform_buffer_binding_size),
+            max_storage_buffer_binding_size: limits
+                .max_storage_buffer_binding_size
+                .min(constrained_limits.max_storage_buffer_binding_size),
+            max_vertex_buffers: limits
+                .max_vertex_buffers
+                .min(constrained_limits.max_vertex_buffers),
+            max_vertex_attributes: limits
+                .max_vertex_attributes
+                .min(constrained_limits.max_vertex_attributes),
+            max_vertex_buffer_array_stride: limits
+                .max_vertex_buffer_array_stride
+                .min(constrained_limits.max_vertex_buffer_array_stride),
+            max_push_constant_size: limits
+                .max_push_constant_size
+                .min(constrained_limits.max_push_constant_size),
+            min_uniform_buffer_offset_alignment: limits
+                .min_uniform_buffer_offset_alignment
+                .max(constrained_limits.min_uniform_buffer_offset_alignment),
+            min_storage_buffer_offset_alignment: limits
+                .min_storage_buffer_offset_alignment
+                .max(constrained_limits.min_storage_buffer_offset_alignment),
+            max_inter_stage_shader_components: limits
+                .max_inter_stage_shader_components
+                .min(constrained_limits.max_inter_stage_shader_components),
+            max_compute_workgroup_storage_size: limits
+                .max_compute_workgroup_storage_size
+                .min(constrained_limits.max_compute_workgroup_storage_size),
+            max_compute_invocations_per_workgroup: limits
+                .max_compute_invocations_per_workgroup
+                .min(constrained_limits.max_compute_invocations_per_workgroup),
+            max_compute_workgroup_size_x: limits
+                .max_compute_workgroup_size_x
+                .min(constrained_limits.max_compute_workgroup_size_x),
+            max_compute_workgroup_size_y: limits
+                .max_compute_workgroup_size_y
+                .min(constrained_limits.max_compute_workgroup_size_y),
+            max_compute_workgroup_size_z: limits
+                .max_compute_workgroup_size_z
+                .min(constrained_limits.max_compute_workgroup_size_z),
+            max_compute_workgroups_per_dimension: limits
+                .max_compute_workgroups_per_dimension
+                .min(constrained_limits.max_compute_workgroups_per_dimension),
+            max_buffer_size: limits
+                .max_buffer_size
+                .min(constrained_limits.max_buffer_size),
+            max_bindings_per_bind_group: limits
+                .max_bindings_per_bind_group
+                .min(constrained_limits.max_bindings_per_bind_group),
+            max_non_sampler_bindings: limits
+                .max_non_sampler_bindings
+                .min(constrained_limits.max_non_sampler_bindings),
+            max_color_attachments: limits
+                .max_color_attachments
+                .min(constrained_limits.max_color_attachments),
+            max_color_attachment_bytes_per_sample: limits
+                .max_color_attachment_bytes_per_sample
+                .min(constrained_limits.max_color_attachment_bytes_per_sample),
+            min_subgroup_size: limits
+                .min_subgroup_size
+                .max(constrained_limits.min_subgroup_size),
+            max_subgroup_size: limits
+                .max_subgroup_size
+                .min(constrained_limits.max_subgroup_size),
+        };
+    }
+
+    let (device, queue) = adapter
+        .request_device(
+            &wgpu::DeviceDescriptor {
+                label: options.device_label.as_ref().map(AsRef::as_ref),
+                required_features: features,
+                required_limits: limits,
+                memory_hints: options.memory_hints.clone(),
+            },
+            options.trace_path.as_deref(),
+        )
+        .await
+        .unwrap();
+    let queue = Arc::new(WgpuWrapper::new(queue));
+    let adapter = Arc::new(WgpuWrapper::new(adapter));
+    (
+        RenderDevice::from(device),
+        RenderQueue(queue),
+        RenderAdapterInfo(WgpuWrapper::new(adapter_info)),
+        RenderAdapter(adapter),
+    )
+}
+
+/// The context with all information required to interact with the GPU.
+///
+/// The [`RenderDevice`] is used to create render resources and the
+/// the [`CommandEncoder`] is used to record a series of GPU operations.
+pub struct RenderContext<'w> {
+    render_device: RenderDevice,
+    command_encoder: Option<CommandEncoder>,
+    command_buffer_queue: Vec<QueuedCommandBuffer<'w>>,
+    #[cfg(not(all(target_arch = "wasm32", target_feature = "atomics")))]
+    force_serial: bool,
+    diagnostics_recorder: Option<Arc<DiagnosticsRecorder>>,
+}
+
+impl<'w> RenderContext<'w> {
+    /// Creates a new [`RenderContext`] from a [`RenderDevice`].
+    pub fn new(
+        render_device: RenderDevice,
+        #[cfg(not(all(target_arch = "wasm32", target_feature = "atomics")))]
+        adapter_info: AdapterInfo,
+        diagnostics_recorder: Option<DiagnosticsRecorder>,
+    ) -> Self {
+        // HACK: Parallel command encoding is currently bugged on AMD + Windows/Linux + Vulkan
+        #[cfg(any(target_os = "windows", target_os = "linux"))]
+        let force_serial =
+            adapter_info.driver.contains("AMD") && adapter_info.backend == wgpu::Backend::Vulkan;
+        #[cfg(not(any(
+            target_os = "windows",
+            target_os = "linux",
+            all(target_arch = "wasm32", target_feature = "atomics")
+        )))]
+        let force_serial = {
+            drop(adapter_info);
+            false
+        };
+
+        Self {
+            render_device,
+            command_encoder: None,
+            command_buffer_queue: Vec::new(),
+            #[cfg(not(all(target_arch = "wasm32", target_feature = "atomics")))]
+            force_serial,
+            diagnostics_recorder: diagnostics_recorder.map(Arc::new),
+        }
+    }
+
+    /// Gets the underlying [`RenderDevice`].
+    pub fn render_device(&self) -> &RenderDevice {
+        &self.render_device
+    }
+
+    /// Gets the diagnostics recorder, used to track elapsed time and pipeline statistics
+    /// of various render and compute passes.
+    pub fn diagnostic_recorder(&self) -> impl RecordDiagnostics + use<> {
+        self.diagnostics_recorder.clone()
+    }
+
+    /// Gets the current [`CommandEncoder`].
+    pub fn command_encoder(&mut self) -> &mut CommandEncoder {
+        self.command_encoder.get_or_insert_with(|| {
+            self.render_device
+                .create_command_encoder(&wgpu::CommandEncoderDescriptor::default())
+        })
+    }
+
+    /// Creates a new [`TrackedRenderPass`] for the context,
+    /// configured using the provided `descriptor`.
+    pub fn begin_tracked_render_pass<'a>(
+        &'a mut self,
+        descriptor: RenderPassDescriptor<'_>,
+    ) -> TrackedRenderPass<'a> {
+        // Cannot use command_encoder() as we need to split the borrow on self
+        let command_encoder = self.command_encoder.get_or_insert_with(|| {
+            self.render_device
+                .create_command_encoder(&wgpu::CommandEncoderDescriptor::default())
+        });
+
+        let render_pass = command_encoder.begin_render_pass(&descriptor);
+        TrackedRenderPass::new(&self.render_device, render_pass)
+    }
+
+    /// Append a [`CommandBuffer`] to the command buffer queue.
+    ///
+    /// If present, this will flush the currently unflushed [`CommandEncoder`]
+    /// into a [`CommandBuffer`] into the queue before appending the provided
+    /// buffer.
+    pub fn add_command_buffer(&mut self, command_buffer: CommandBuffer) {
+        self.flush_encoder();
+
+        self.command_buffer_queue
+            .push(QueuedCommandBuffer::Ready(command_buffer));
+    }
+
+    /// Append a function that will generate a [`CommandBuffer`] to the
+    /// command buffer queue, to be ran later.
+    ///
+    /// If present, this will flush the currently unflushed [`CommandEncoder`]
+    /// into a [`CommandBuffer`] into the queue before appending the provided
+    /// buffer.
+    pub fn add_command_buffer_generation_task(
+        &mut self,
+        #[cfg(not(all(target_arch = "wasm32", target_feature = "atomics")))]
+        task: impl FnOnce(RenderDevice) -> CommandBuffer + 'w + Send,
+        #[cfg(all(target_arch = "wasm32", target_feature = "atomics"))]
+        task: impl FnOnce(RenderDevice) -> CommandBuffer + 'w,
+    ) {
+        self.flush_encoder();
+
+        self.command_buffer_queue
+            .push(QueuedCommandBuffer::Task(Box::new(task)));
+    }
+
+    /// Finalizes and returns the queue of [`CommandBuffer`]s.
+    ///
+    /// This function will wait until all command buffer generation tasks are complete
+    /// by running them in parallel (where supported).
+    ///
+    /// The [`CommandBuffer`]s will be returned in the order that they were added.
+    pub fn finish(
+        mut self,
+    ) -> (
+        Vec<CommandBuffer>,
+        RenderDevice,
+        Option<DiagnosticsRecorder>,
+    ) {
+        self.flush_encoder();
+
+        let mut command_buffers = Vec::with_capacity(self.command_buffer_queue.len());
+
+        #[cfg(feature = "trace")]
+        let _command_buffer_generation_tasks_span =
+            info_span!("command_buffer_generation_tasks").entered();
+
+        #[cfg(not(all(target_arch = "wasm32", target_feature = "atomics")))]
+        {
+            let mut task_based_command_buffers = ComputeTaskPool::get().scope(|task_pool| {
+                for (i, queued_command_buffer) in self.command_buffer_queue.into_iter().enumerate()
+                {
+                    match queued_command_buffer {
+                        QueuedCommandBuffer::Ready(command_buffer) => {
+                            command_buffers.push((i, command_buffer));
+                        }
+                        QueuedCommandBuffer::Task(command_buffer_generation_task) => {
+                            let render_device = self.render_device.clone();
+                            if self.force_serial {
+                                command_buffers
+                                    .push((i, command_buffer_generation_task(render_device)));
+                            } else {
+                                task_pool.spawn(async move {
+                                    (i, command_buffer_generation_task(render_device))
+                                });
+                            }
+                        }
+                    }
+                }
+            });
+            command_buffers.append(&mut task_based_command_buffers);
+        }
+
+        #[cfg(all(target_arch = "wasm32", target_feature = "atomics"))]
+        for (i, queued_command_buffer) in self.command_buffer_queue.into_iter().enumerate() {
+            match queued_command_buffer {
+                QueuedCommandBuffer::Ready(command_buffer) => {
+                    command_buffers.push((i, command_buffer));
+                }
+                QueuedCommandBuffer::Task(command_buffer_generation_task) => {
+                    let render_device = self.render_device.clone();
+                    command_buffers.push((i, command_buffer_generation_task(render_device)));
+                }
+            }
+        }
+
+        #[cfg(feature = "trace")]
+        drop(_command_buffer_generation_tasks_span);
+
+        command_buffers.sort_unstable_by_key(|(i, _)| *i);
+
+        let mut command_buffers = command_buffers
+            .into_iter()
+            .map(|(_, cb)| cb)
+            .collect::<Vec<CommandBuffer>>();
+
+        let mut diagnostics_recorder = self.diagnostics_recorder.take().map(|v| {
+            Arc::try_unwrap(v)
+                .ok()
+                .expect("diagnostic recorder shouldn't be held longer than necessary")
+        });
+
+        if let Some(recorder) = &mut diagnostics_recorder {
+            let mut command_encoder = self
+                .render_device
+                .create_command_encoder(&wgpu::CommandEncoderDescriptor::default());
+            recorder.resolve(&mut command_encoder);
+            command_buffers.push(command_encoder.finish());
+        }
+
+        (command_buffers, self.render_device, diagnostics_recorder)
+    }
+
+    fn flush_encoder(&mut self) {
+        if let Some(encoder) = self.command_encoder.take() {
+            self.command_buffer_queue
+                .push(QueuedCommandBuffer::Ready(encoder.finish()));
+        }
+    }
+}
+
+enum QueuedCommandBuffer<'w> {
+    Ready(CommandBuffer),
+    #[cfg(not(all(target_arch = "wasm32", target_feature = "atomics")))]
+    Task(Box<dyn FnOnce(RenderDevice) -> CommandBuffer + 'w + Send>),
+    #[cfg(all(target_arch = "wasm32", target_feature = "atomics"))]
+    Task(Box<dyn FnOnce(RenderDevice) -> CommandBuffer + 'w>),
+}

vendor/bevy_render/src/renderer/render_device.rs

@@ -0,0 +1,308 @@
+use super::RenderQueue;
+use crate::render_resource::{
+    BindGroup, BindGroupLayout, Buffer, ComputePipeline, RawRenderPipelineDescriptor,
+    RenderPipeline, Sampler, Texture,
+};
+use crate::WgpuWrapper;
+use bevy_ecs::resource::Resource;
+use wgpu::{
+    util::DeviceExt, BindGroupDescriptor, BindGroupEntry, BindGroupLayoutDescriptor,
+    BindGroupLayoutEntry, BufferAsyncError, BufferBindingType, MaintainResult,
+};
+
+/// This GPU device is responsible for the creation of most rendering and compute resources.
+#[derive(Resource, Clone)]
+pub struct RenderDevice {
+    device: WgpuWrapper<wgpu::Device>,
+}
+
+impl From<wgpu::Device> for RenderDevice {
+    fn from(device: wgpu::Device) -> Self {
+        Self::new(WgpuWrapper::new(device))
+    }
+}
+
+impl RenderDevice {
+    pub fn new(device: WgpuWrapper<wgpu::Device>) -> Self {
+        Self { device }
+    }
+
+    /// List all [`Features`](wgpu::Features) that may be used with this device.
+    ///
+    /// Functions may panic if you use unsupported features.
+    #[inline]
+    pub fn features(&self) -> wgpu::Features {
+        self.device.features()
+    }
+
+    /// List all [`Limits`](wgpu::Limits) that were requested of this device.
+    ///
+    /// If any of these limits are exceeded, functions may panic.
+    #[inline]
+    pub fn limits(&self) -> wgpu::Limits {
+        self.device.limits()
+    }
+
+    /// Creates a [`ShaderModule`](wgpu::ShaderModule) from either SPIR-V or WGSL source code.
+    ///
+    /// # Safety
+    ///
+    /// Creates a shader module with user-customizable runtime checks which allows shaders to
+    /// perform operations which can lead to undefined behavior like indexing out of bounds,
+    /// To avoid UB, ensure any unchecked shaders are sound!
+    /// This method should never be called for user-supplied shaders.
+    #[inline]
+    pub unsafe fn create_shader_module(
+        &self,
+        desc: wgpu::ShaderModuleDescriptor,
+    ) -> wgpu::ShaderModule {
+        #[cfg(feature = "spirv_shader_passthrough")]
+        match &desc.source {
+            wgpu::ShaderSource::SpirV(source)
+                if self
+                    .features()
+                    .contains(wgpu::Features::SPIRV_SHADER_PASSTHROUGH) =>
+            {
+                // SAFETY:
+                // This call passes binary data to the backend as-is and can potentially result in a driver crash or bogus behavior.
+                // No attempt is made to ensure that data is valid SPIR-V.
+                unsafe {
+                    self.device
+                        .create_shader_module_spirv(&wgpu::ShaderModuleDescriptorSpirV {
+                            label: desc.label,
+                            source: source.clone(),
+                        })
+                }
+            }
+            // SAFETY:
+            //
+            // This call passes binary data to the backend as-is and can potentially result in a driver crash or bogus behavior.
+            // No attempt is made to ensure that data is valid SPIR-V.
+            _ => unsafe {
+                self.device
+                    .create_shader_module_trusted(desc, wgpu::ShaderRuntimeChecks::unchecked())
+            },
+        }
+        #[cfg(not(feature = "spirv_shader_passthrough"))]
+        // SAFETY: the caller is responsible for upholding the safety requirements
+        unsafe {
+            self.device
+                .create_shader_module_trusted(desc, wgpu::ShaderRuntimeChecks::unchecked())
+        }
+    }
+
+    /// Creates and validates a [`ShaderModule`](wgpu::ShaderModule) from either SPIR-V or WGSL source code.
+    ///
+    /// See [`ValidateShader`](bevy_render::render_resource::ValidateShader) for more information on the tradeoffs involved with shader validation.
+    #[inline]
+    pub fn create_and_validate_shader_module(
+        &self,
+        desc: wgpu::ShaderModuleDescriptor,
+    ) -> wgpu::ShaderModule {
+        #[cfg(feature = "spirv_shader_passthrough")]
+        match &desc.source {
+            wgpu::ShaderSource::SpirV(_source) => panic!("no safety checks are performed for spirv shaders. use `create_shader_module` instead"),
+            _ => self.device.create_shader_module(desc),
+        }
+        #[cfg(not(feature = "spirv_shader_passthrough"))]
+        self.device.create_shader_module(desc)
+    }
+
+    /// Check for resource cleanups and mapping callbacks.
+    ///
+    /// Return `true` if the queue is empty, or `false` if there are more queue
+    /// submissions still in flight. (Note that, unless access to the [`wgpu::Queue`] is
+    /// coordinated somehow, this information could be out of date by the time
+    /// the caller receives it. `Queue`s can be shared between threads, so
+    /// other threads could submit new work at any time.)
+    ///
+    /// no-op on the web, device is automatically polled.
+    #[inline]
+    pub fn poll(&self, maintain: wgpu::Maintain) -> MaintainResult {
+        self.device.poll(maintain)
+    }
+
+    /// Creates an empty [`CommandEncoder`](wgpu::CommandEncoder).
+    #[inline]
+    pub fn create_command_encoder(
+        &self,
+        desc: &wgpu::CommandEncoderDescriptor,
+    ) -> wgpu::CommandEncoder {
+        self.device.create_command_encoder(desc)
+    }
+
+    /// Creates an empty [`RenderBundleEncoder`](wgpu::RenderBundleEncoder).
+    #[inline]
+    pub fn create_render_bundle_encoder(
+        &self,
+        desc: &wgpu::RenderBundleEncoderDescriptor,
+    ) -> wgpu::RenderBundleEncoder {
+        self.device.create_render_bundle_encoder(desc)
+    }
+
+    /// Creates a new [`BindGroup`](wgpu::BindGroup).
+    #[inline]
+    pub fn create_bind_group<'a>(
+        &self,
+        label: impl Into<wgpu::Label<'a>>,
+        layout: &'a BindGroupLayout,
+        entries: &'a [BindGroupEntry<'a>],
+    ) -> BindGroup {
+        let wgpu_bind_group = self.device.create_bind_group(&BindGroupDescriptor {
+            label: label.into(),
+            layout,
+            entries,
+        });
+        BindGroup::from(wgpu_bind_group)
+    }
+
+    /// Creates a [`BindGroupLayout`](wgpu::BindGroupLayout).
+    #[inline]
+    pub fn create_bind_group_layout<'a>(
+        &self,
+        label: impl Into<wgpu::Label<'a>>,
+        entries: &'a [BindGroupLayoutEntry],
+    ) -> BindGroupLayout {
+        BindGroupLayout::from(
+            self.device
+                .create_bind_group_layout(&BindGroupLayoutDescriptor {
+                    label: label.into(),
+                    entries,
+                }),
+        )
+    }
+
+    /// Creates a [`PipelineLayout`](wgpu::PipelineLayout).
+    #[inline]
+    pub fn create_pipeline_layout(
+        &self,
+        desc: &wgpu::PipelineLayoutDescriptor,
+    ) -> wgpu::PipelineLayout {
+        self.device.create_pipeline_layout(desc)
+    }
+
+    /// Creates a [`RenderPipeline`].
+    #[inline]
+    pub fn create_render_pipeline(&self, desc: &RawRenderPipelineDescriptor) -> RenderPipeline {
+        let wgpu_render_pipeline = self.device.create_render_pipeline(desc);
+        RenderPipeline::from(wgpu_render_pipeline)
+    }
+
+    /// Creates a [`ComputePipeline`].
+    #[inline]
+    pub fn create_compute_pipeline(
+        &self,
+        desc: &wgpu::ComputePipelineDescriptor,
+    ) -> ComputePipeline {
+        let wgpu_compute_pipeline = self.device.create_compute_pipeline(desc);
+        ComputePipeline::from(wgpu_compute_pipeline)
+    }
+
+    /// Creates a [`Buffer`].
+    pub fn create_buffer(&self, desc: &wgpu::BufferDescriptor) -> Buffer {
+        let wgpu_buffer = self.device.create_buffer(desc);
+        Buffer::from(wgpu_buffer)
+    }
+
+    /// Creates a [`Buffer`] and initializes it with the specified data.
+    pub fn create_buffer_with_data(&self, desc: &wgpu::util::BufferInitDescriptor) -> Buffer {
+        let wgpu_buffer = self.device.create_buffer_init(desc);
+        Buffer::from(wgpu_buffer)
+    }
+
+    /// Creates a new [`Texture`] and initializes it with the specified data.
+    ///
+    /// `desc` specifies the general format of the texture.
+    /// `data` is the raw data.
+    pub fn create_texture_with_data(
+        &self,
+        render_queue: &RenderQueue,
+        desc: &wgpu::TextureDescriptor,
+        order: wgpu::util::TextureDataOrder,
+        data: &[u8],
+    ) -> Texture {
+        let wgpu_texture =
+            self.device
+                .create_texture_with_data(render_queue.as_ref(), desc, order, data);
+        Texture::from(wgpu_texture)
+    }
+
+    /// Creates a new [`Texture`].
+    ///
+    /// `desc` specifies the general format of the texture.
+    pub fn create_texture(&self, desc: &wgpu::TextureDescriptor) -> Texture {
+        let wgpu_texture = self.device.create_texture(desc);
+        Texture::from(wgpu_texture)
+    }
+
+    /// Creates a new [`Sampler`].
+    ///
+    /// `desc` specifies the behavior of the sampler.
+    pub fn create_sampler(&self, desc: &wgpu::SamplerDescriptor) -> Sampler {
+        let wgpu_sampler = self.device.create_sampler(desc);
+        Sampler::from(wgpu_sampler)
+    }
+
+    /// Initializes [`Surface`](wgpu::Surface) for presentation.
+    ///
+    /// # Panics
+    ///
+    /// - A old [`SurfaceTexture`](wgpu::SurfaceTexture) is still alive referencing an old surface.
+    /// - Texture format requested is unsupported on the surface.
+    pub fn configure_surface(&self, surface: &wgpu::Surface, config: &wgpu::SurfaceConfiguration) {
+        surface.configure(&self.device, config);
+    }
+
+    /// Returns the wgpu [`Device`](wgpu::Device).
+    pub fn wgpu_device(&self) -> &wgpu::Device {
+        &self.device
+    }
+
+    pub fn map_buffer(
+        &self,
+        buffer: &wgpu::BufferSlice,
+        map_mode: wgpu::MapMode,
+        callback: impl FnOnce(Result<(), BufferAsyncError>) + Send + 'static,
+    ) {
+        buffer.map_async(map_mode, callback);
+    }
+
+    // Rounds up `row_bytes` to be a multiple of [`wgpu::COPY_BYTES_PER_ROW_ALIGNMENT`].
+    pub const fn align_copy_bytes_per_row(row_bytes: usize) -> usize {
+        let align = wgpu::COPY_BYTES_PER_ROW_ALIGNMENT as usize;
+
+        // If row_bytes is aligned calculate a value just under the next aligned value.
+        // Otherwise calculate a value greater than the next aligned value.
+        let over_aligned = row_bytes + align - 1;
+
+        // Round the number *down* to the nearest aligned value.
+        (over_aligned / align) * align
+    }
+
+    pub fn get_supported_read_only_binding_type(
+        &self,
+        buffers_per_shader_stage: u32,
+    ) -> BufferBindingType {
+        if self.limits().max_storage_buffers_per_shader_stage >= buffers_per_shader_stage {
+            BufferBindingType::Storage { read_only: true }
+        } else {
+            BufferBindingType::Uniform
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn align_copy_bytes_per_row() {
+        // Test for https://github.com/bevyengine/bevy/issues/16992
+        let align = wgpu::COPY_BYTES_PER_ROW_ALIGNMENT as usize;
+
+        assert_eq!(RenderDevice::align_copy_bytes_per_row(0), 0);
+        assert_eq!(RenderDevice::align_copy_bytes_per_row(1), align);
+        assert_eq!(RenderDevice::align_copy_bytes_per_row(align + 1), align * 2);
+        assert_eq!(RenderDevice::align_copy_bytes_per_row(align), align);
+    }
+}

vendor/bevy_render/src/settings.rs

@@ -0,0 +1,207 @@
+use crate::renderer::{
+    RenderAdapter, RenderAdapterInfo, RenderDevice, RenderInstance, RenderQueue,
+};
+use alloc::borrow::Cow;
+use std::path::PathBuf;
+
+pub use wgpu::{
+    Backends, Dx12Compiler, Features as WgpuFeatures, Gles3MinorVersion, InstanceFlags,
+    Limits as WgpuLimits, MemoryHints, PowerPreference,
+};
+
+/// Configures the priority used when automatically configuring the features/limits of `wgpu`.
+#[derive(Clone)]
+pub enum WgpuSettingsPriority {
+    /// WebGPU default features and limits
+    Compatibility,
+    /// The maximum supported features and limits of the adapter and backend
+    Functionality,
+    /// WebGPU default limits plus additional constraints in order to be compatible with WebGL2
+    WebGL2,
+}
+
+/// Provides configuration for renderer initialization. Use [`RenderDevice::features`](RenderDevice::features),
+/// [`RenderDevice::limits`](RenderDevice::limits), and the [`RenderAdapterInfo`]
+/// resource to get runtime information about the actual adapter, backend, features, and limits.
+/// NOTE: [`Backends::DX12`](Backends::DX12), [`Backends::METAL`](Backends::METAL), and
+/// [`Backends::VULKAN`](Backends::VULKAN) are enabled by default for non-web and the best choice
+/// is automatically selected. Web using the `webgl` feature uses [`Backends::GL`](Backends::GL).
+/// NOTE: If you want to use [`Backends::GL`](Backends::GL) in a native app on `Windows` and/or `macOS`, you must
+/// use [`ANGLE`](https://github.com/gfx-rs/wgpu#angle). This is because wgpu requires EGL to
+/// create a GL context without a window and only ANGLE supports that.
+#[derive(Clone)]
+pub struct WgpuSettings {
+    pub device_label: Option<Cow<'static, str>>,
+    pub backends: Option<Backends>,
+    pub power_preference: PowerPreference,
+    pub priority: WgpuSettingsPriority,
+    /// The features to ensure are enabled regardless of what the adapter/backend supports.
+    /// Setting these explicitly may cause renderer initialization to fail.
+    pub features: WgpuFeatures,
+    /// The features to ensure are disabled regardless of what the adapter/backend supports
+    pub disabled_features: Option<WgpuFeatures>,
+    /// The imposed limits.
+    pub limits: WgpuLimits,
+    /// The constraints on limits allowed regardless of what the adapter/backend supports
+    pub constrained_limits: Option<WgpuLimits>,
+    /// The shader compiler to use for the DX12 backend.
+    pub dx12_shader_compiler: Dx12Compiler,
+    /// Allows you to choose which minor version of GLES3 to use (3.0, 3.1, 3.2, or automatic)
+    /// This only applies when using ANGLE and the GL backend.
+    pub gles3_minor_version: Gles3MinorVersion,
+    /// These are for controlling WGPU's debug information to eg. enable validation and shader debug info in release builds.
+    pub instance_flags: InstanceFlags,
+    /// This hints to the WGPU device about the preferred memory allocation strategy.
+    pub memory_hints: MemoryHints,
+    /// The path to pass to wgpu for API call tracing. This only has an effect if wgpu's tracing functionality is enabled.
+    pub trace_path: Option<PathBuf>,
+}
+
+impl Default for WgpuSettings {
+    fn default() -> Self {
+        let default_backends = if cfg!(all(
+            feature = "webgl",
+            target_arch = "wasm32",
+            not(feature = "webgpu")
+        )) {
+            Backends::GL
+        } else if cfg!(all(feature = "webgpu", target_arch = "wasm32")) {
+            Backends::BROWSER_WEBGPU
+        } else {
+            Backends::all()
+        };
+
+        let backends = Some(Backends::from_env().unwrap_or(default_backends));
+
+        let power_preference =
+            PowerPreference::from_env().unwrap_or(PowerPreference::HighPerformance);
+
+        let priority = settings_priority_from_env().unwrap_or(WgpuSettingsPriority::Functionality);
+
+        let limits = if cfg!(all(
+            feature = "webgl",
+            target_arch = "wasm32",
+            not(feature = "webgpu")
+        )) || matches!(priority, WgpuSettingsPriority::WebGL2)
+        {
+            wgpu::Limits::downlevel_webgl2_defaults()
+        } else {
+            #[expect(clippy::allow_attributes, reason = "`unused_mut` is not always linted")]
+            #[allow(
+                unused_mut,
+                reason = "This variable needs to be mutable if the `ci_limits` feature is enabled"
+            )]
+            let mut limits = wgpu::Limits::default();
+            #[cfg(feature = "ci_limits")]
+            {
+                limits.max_storage_textures_per_shader_stage = 4;
+                limits.max_texture_dimension_3d = 1024;
+            }
+            limits
+        };
+
+        let dx12_shader_compiler =
+            Dx12Compiler::from_env().unwrap_or(if cfg!(feature = "statically-linked-dxc") {
+                Dx12Compiler::StaticDxc
+            } else {
+                let dxc = "dxcompiler.dll";
+                let dxil = "dxil.dll";
+
+                if cfg!(target_os = "windows")
+                    && std::fs::metadata(dxc).is_ok()
+                    && std::fs::metadata(dxil).is_ok()
+                {
+                    Dx12Compiler::DynamicDxc {
+                        dxc_path: String::from(dxc),
+                        dxil_path: String::from(dxil),
+                    }
+                } else {
+                    Dx12Compiler::Fxc
+                }
+            });
+
+        let gles3_minor_version = Gles3MinorVersion::from_env().unwrap_or_default();
+
+        let instance_flags = InstanceFlags::default().with_env();
+
+        Self {
+            device_label: Default::default(),
+            backends,
+            power_preference,
+            priority,
+            features: wgpu::Features::TEXTURE_ADAPTER_SPECIFIC_FORMAT_FEATURES,
+            disabled_features: None,
+            limits,
+            constrained_limits: None,
+            dx12_shader_compiler,
+            gles3_minor_version,
+            instance_flags,
+            memory_hints: MemoryHints::default(),
+            trace_path: None,
+        }
+    }
+}
+
+#[derive(Clone)]
+pub struct RenderResources(
+    pub RenderDevice,
+    pub RenderQueue,
+    pub RenderAdapterInfo,
+    pub RenderAdapter,
+    pub RenderInstance,
+);
+
+/// An enum describing how the renderer will initialize resources. This is used when creating the [`RenderPlugin`](crate::RenderPlugin).
+pub enum RenderCreation {
+    /// Allows renderer resource initialization to happen outside of the rendering plugin.
+    Manual(RenderResources),
+    /// Lets the rendering plugin create resources itself.
+    Automatic(WgpuSettings),
+}
+
+impl RenderCreation {
+    /// Function to create a [`RenderCreation::Manual`] variant.
+    pub fn manual(
+        device: RenderDevice,
+        queue: RenderQueue,
+        adapter_info: RenderAdapterInfo,
+        adapter: RenderAdapter,
+        instance: RenderInstance,
+    ) -> Self {
+        RenderResources(device, queue, adapter_info, adapter, instance).into()
+    }
+}
+
+impl From<RenderResources> for RenderCreation {
+    fn from(value: RenderResources) -> Self {
+        Self::Manual(value)
+    }
+}
+
+impl Default for RenderCreation {
+    fn default() -> Self {
+        Self::Automatic(Default::default())
+    }
+}
+
+impl From<WgpuSettings> for RenderCreation {
+    fn from(value: WgpuSettings) -> Self {
+        Self::Automatic(value)
+    }
+}
+
+/// Get a features/limits priority from the environment variable `WGPU_SETTINGS_PRIO`
+pub fn settings_priority_from_env() -> Option<WgpuSettingsPriority> {
+    Some(
+        match std::env::var("WGPU_SETTINGS_PRIO")
+            .as_deref()
+            .map(str::to_lowercase)
+            .as_deref()
+        {
+            Ok("compatibility") => WgpuSettingsPriority::Compatibility,
+            Ok("functionality") => WgpuSettingsPriority::Functionality,
+            Ok("webgl2") => WgpuSettingsPriority::WebGL2,
+            _ => return None,
+        },
+    )
+}

vendor/bevy_render/src/storage.rs

@@ -0,0 +1,135 @@
+use crate::{
+    render_asset::{PrepareAssetError, RenderAsset, RenderAssetPlugin, RenderAssetUsages},
+    render_resource::{Buffer, BufferUsages},
+    renderer::RenderDevice,
+};
+use bevy_app::{App, Plugin};
+use bevy_asset::{Asset, AssetApp, AssetId};
+use bevy_ecs::system::{lifetimeless::SRes, SystemParamItem};
+use bevy_reflect::{prelude::ReflectDefault, Reflect};
+use bevy_utils::default;
+use encase::{internal::WriteInto, ShaderType};
+use wgpu::util::BufferInitDescriptor;
+
+/// Adds [`ShaderStorageBuffer`] as an asset that is extracted and uploaded to the GPU.
+#[derive(Default)]
+pub struct StoragePlugin;
+
+impl Plugin for StoragePlugin {
+    fn build(&self, app: &mut App) {
+        app.add_plugins(RenderAssetPlugin::<GpuShaderStorageBuffer>::default())
+            .register_type::<ShaderStorageBuffer>()
+            .init_asset::<ShaderStorageBuffer>()
+            .register_asset_reflect::<ShaderStorageBuffer>();
+    }
+}
+
+/// A storage buffer that is prepared as a [`RenderAsset`] and uploaded to the GPU.
+#[derive(Asset, Reflect, Debug, Clone)]
+#[reflect(opaque)]
+#[reflect(Default, Debug, Clone)]
+pub struct ShaderStorageBuffer {
+    /// Optional data used to initialize the buffer.
+    pub data: Option<Vec<u8>>,
+    /// The buffer description used to create the buffer.
+    pub buffer_description: wgpu::BufferDescriptor<'static>,
+    /// The asset usage of the storage buffer.
+    pub asset_usage: RenderAssetUsages,
+}
+
+impl Default for ShaderStorageBuffer {
+    fn default() -> Self {
+        Self {
+            data: None,
+            buffer_description: wgpu::BufferDescriptor {
+                label: None,
+                size: 0,
+                usage: BufferUsages::STORAGE,
+                mapped_at_creation: false,
+            },
+            asset_usage: RenderAssetUsages::default(),
+        }
+    }
+}
+
+impl ShaderStorageBuffer {
+    /// Creates a new storage buffer with the given data and asset usage.
+    pub fn new(data: &[u8], asset_usage: RenderAssetUsages) -> Self {
+        let mut storage = ShaderStorageBuffer {
+            data: Some(data.to_vec()),
+            ..default()
+        };
+        storage.asset_usage = asset_usage;
+        storage
+    }
+
+    /// Creates a new storage buffer with the given size and asset usage.
+    pub fn with_size(size: usize, asset_usage: RenderAssetUsages) -> Self {
+        let mut storage = ShaderStorageBuffer {
+            data: None,
+            ..default()
+        };
+        storage.buffer_description.size = size as u64;
+        storage.buffer_description.mapped_at_creation = false;
+        storage.asset_usage = asset_usage;
+        storage
+    }
+
+    /// Sets the data of the storage buffer to the given [`ShaderType`].
+    pub fn set_data<T>(&mut self, value: T)
+    where
+        T: ShaderType + WriteInto,
+    {
+        let size = value.size().get() as usize;
+        let mut wrapper = encase::StorageBuffer::<Vec<u8>>::new(Vec::with_capacity(size));
+        wrapper.write(&value).unwrap();
+        self.data = Some(wrapper.into_inner());
+    }
+}
+
+impl<T> From<T> for ShaderStorageBuffer
+where
+    T: ShaderType + WriteInto,
+{
+    fn from(value: T) -> Self {
+        let size = value.size().get() as usize;
+        let mut wrapper = encase::StorageBuffer::<Vec<u8>>::new(Vec::with_capacity(size));
+        wrapper.write(&value).unwrap();
+        Self::new(wrapper.as_ref(), RenderAssetUsages::default())
+    }
+}
+
+/// A storage buffer that is prepared as a [`RenderAsset`] and uploaded to the GPU.
+pub struct GpuShaderStorageBuffer {
+    pub buffer: Buffer,
+}
+
+impl RenderAsset for GpuShaderStorageBuffer {
+    type SourceAsset = ShaderStorageBuffer;
+    type Param = SRes<RenderDevice>;
+
+    fn asset_usage(source_asset: &Self::SourceAsset) -> RenderAssetUsages {
+        source_asset.asset_usage
+    }
+
+    fn prepare_asset(
+        source_asset: Self::SourceAsset,
+        _: AssetId<Self::SourceAsset>,
+        render_device: &mut SystemParamItem<Self::Param>,
+    ) -> Result<Self, PrepareAssetError<Self::SourceAsset>> {
+        match source_asset.data {
+            Some(data) => {
+                let buffer = render_device.create_buffer_with_data(&BufferInitDescriptor {
+                    label: source_asset.buffer_description.label,
+                    contents: &data,
+                    usage: source_asset.buffer_description.usage,
+                });
+                Ok(GpuShaderStorageBuffer { buffer })
+            }
+            None => {
+                let buffer = render_device.create_buffer(&source_asset.buffer_description);
+                Ok(GpuShaderStorageBuffer { buffer })
+            }
+        }
+    }
+}

vendor/bevy_render/src/sync_component.rs

@@ -0,0 +1,42 @@
+use core::marker::PhantomData;
+
+use bevy_app::{App, Plugin};
+use bevy_ecs::component::Component;
+
+use crate::sync_world::{EntityRecord, PendingSyncEntity, SyncToRenderWorld};
+
+/// Plugin that registers a component for automatic sync to the render world. See [`SyncWorldPlugin`] for more information.
+///
+/// This plugin is automatically added by [`ExtractComponentPlugin`], and only needs to be added for manual extraction implementations.
+///
+/// # Implementation details
+///
+/// It adds [`SyncToRenderWorld`] as a required component to make the [`SyncWorldPlugin`] aware of the component, and
+/// handles cleanup of the component in the render world when it is removed from an entity.
+///
+/// # Warning
+/// When the component is removed from the main world entity, all components are removed from the entity in the render world.
+/// This is done in order to handle components with custom extraction logic and derived state.
+///
+/// [`ExtractComponentPlugin`]: crate::extract_component::ExtractComponentPlugin
+/// [`SyncWorldPlugin`]: crate::sync_world::SyncWorldPlugin
+pub struct SyncComponentPlugin<C: Component>(PhantomData<C>);
+
+impl<C: Component> Default for SyncComponentPlugin<C> {
+    fn default() -> Self {
+        Self(PhantomData)
+    }
+}
+
+impl<C: Component> Plugin for SyncComponentPlugin<C> {
+    fn build(&self, app: &mut App) {
+        app.register_required_components::<C, SyncToRenderWorld>();
+
+        app.world_mut()
+            .register_component_hooks::<C>()
+            .on_remove(|mut world, context| {
+                let mut pending = world.resource_mut::<PendingSyncEntity>();
+                pending.push(EntityRecord::ComponentRemoved(context.entity));
+            });
+    }
+}

vendor/bevy_render/src/sync_world.rs

@@ -0,0 +1,574 @@
+use bevy_app::Plugin;
+use bevy_derive::{Deref, DerefMut};
+use bevy_ecs::component::{ComponentCloneBehavior, Mutable, StorageType};
+use bevy_ecs::entity::EntityHash;
+use bevy_ecs::{
+    component::Component,
+    entity::{ContainsEntity, Entity, EntityEquivalent},
+    observer::Trigger,
+    query::With,
+    reflect::ReflectComponent,
+    resource::Resource,
+    system::{Local, Query, ResMut, SystemState},
+    world::{Mut, OnAdd, OnRemove, World},
+};
+use bevy_platform::collections::{HashMap, HashSet};
+use bevy_reflect::{std_traits::ReflectDefault, Reflect};
+
+/// A plugin that synchronizes entities with [`SyncToRenderWorld`] between the main world and the render world.
+///
+/// All entities with the [`SyncToRenderWorld`] component are kept in sync. It
+/// is automatically added as a required component by [`ExtractComponentPlugin`]
+/// and [`SyncComponentPlugin`], so it doesn't need to be added manually when
+/// spawning or as a required component when either of these plugins are used.
+///
+/// # Implementation
+///
+/// Bevy's renderer is architected independently from the main app.
+/// It operates in its own separate ECS [`World`], so the renderer logic can run in parallel with the main world logic.
+/// This is called "Pipelined Rendering", see [`PipelinedRenderingPlugin`] for more information.
+///
+/// [`SyncWorldPlugin`] is the first thing that runs every frame and it maintains an entity-to-entity mapping
+/// between the main world and the render world.
+/// It does so by spawning and despawning entities in the render world, to match spawned and despawned entities in the main world.
+/// The link between synced entities is maintained by the [`RenderEntity`] and [`MainEntity`] components.
+///
+/// The [`RenderEntity`] contains the corresponding render world entity of a main world entity, while [`MainEntity`] contains
+/// the corresponding main world entity of a render world entity.
+/// For convenience, [`QueryData`](bevy_ecs::query::QueryData) implementations are provided for both components:
+/// adding [`MainEntity`] to a query (without a `&`) will return the corresponding main world [`Entity`],
+/// and adding [`RenderEntity`] will return the corresponding render world [`Entity`].
+/// If you have access to the component itself, the underlying entities can be accessed by calling `.id()`.
+///
+/// Synchronization is necessary preparation for extraction ([`ExtractSchedule`](crate::ExtractSchedule)), which copies over component data from the main
+/// to the render world for these entities.
+///
+/// ```text
+/// |--------------------------------------------------------------------|
+/// |      |         |          Main world update                        |
+/// | sync | extract |---------------------------------------------------|
+/// |      |         |         Render world update                       |
+/// |--------------------------------------------------------------------|
+/// ```
+///
+/// An example for synchronized main entities 1v1 and 18v1
+///
+/// ```text
+/// |---------------------------Main World------------------------------|
+/// |  Entity  |                    Component                           |
+/// |-------------------------------------------------------------------|
+/// | ID: 1v1  | PointLight | RenderEntity(ID: 3V1) | SyncToRenderWorld |
+/// | ID: 18v1 | PointLight | RenderEntity(ID: 5V1) | SyncToRenderWorld |
+/// |-------------------------------------------------------------------|
+///
+/// |----------Render World-----------|
+/// |  Entity  |       Component      |
+/// |---------------------------------|
+/// | ID: 3v1  | MainEntity(ID: 1V1)  |
+/// | ID: 5v1  | MainEntity(ID: 18V1) |
+/// |---------------------------------|
+///
+/// ```
+///
+/// Note that this effectively establishes a link between the main world entity and the render world entity.
+/// Not every entity needs to be synchronized, however; only entities with the [`SyncToRenderWorld`] component are synced.
+/// Adding [`SyncToRenderWorld`] to a main world component will establish such a link.
+/// Once a synchronized main entity is despawned, its corresponding render entity will be automatically
+/// despawned in the next `sync`.
+///
+/// The sync step does not copy any of component data between worlds, since its often not necessary to transfer over all
+/// the components of a main world entity.
+/// The render world probably cares about a `Position` component, but not a `Velocity` component.
+/// The extraction happens in its own step, independently from, and after synchronization.
+///
+/// Moreover, [`SyncWorldPlugin`] only synchronizes *entities*. [`RenderAsset`](crate::render_asset::RenderAsset)s like meshes and textures are handled
+/// differently.
+///
+/// [`PipelinedRenderingPlugin`]: crate::pipelined_rendering::PipelinedRenderingPlugin
+/// [`ExtractComponentPlugin`]: crate::extract_component::ExtractComponentPlugin
+/// [`SyncComponentPlugin`]: crate::sync_component::SyncComponentPlugin
+#[derive(Default)]
+pub struct SyncWorldPlugin;
+
+impl Plugin for SyncWorldPlugin {
+    fn build(&self, app: &mut bevy_app::App) {
+        app.init_resource::<PendingSyncEntity>();
+        app.add_observer(
+            |trigger: Trigger<OnAdd, SyncToRenderWorld>, mut pending: ResMut<PendingSyncEntity>| {
+                pending.push(EntityRecord::Added(trigger.target()));
+            },
+        );
+        app.add_observer(
+            |trigger: Trigger<OnRemove, SyncToRenderWorld>,
+             mut pending: ResMut<PendingSyncEntity>,
+             query: Query<&RenderEntity>| {
+                if let Ok(e) = query.get(trigger.target()) {
+                    pending.push(EntityRecord::Removed(*e));
+                };
+            },
+        );
+    }
+}
+/// Marker component that indicates that its entity needs to be synchronized to the render world.
+///
+/// This component is automatically added as a required component by [`ExtractComponentPlugin`] and [`SyncComponentPlugin`].
+/// For more information see [`SyncWorldPlugin`].
+///
+/// NOTE: This component should persist throughout the entity's entire lifecycle.
+/// If this component is removed from its entity, the entity will be despawned.
+///
+/// [`ExtractComponentPlugin`]: crate::extract_component::ExtractComponentPlugin
+/// [`SyncComponentPlugin`]: crate::sync_component::SyncComponentPlugin
+#[derive(Component, Copy, Clone, Debug, Default, Reflect)]
+#[reflect[Component, Default, Clone]]
+#[component(storage = "SparseSet")]
+pub struct SyncToRenderWorld;
+
+/// Component added on the main world entities that are synced to the Render World in order to keep track of the corresponding render world entity.
+///
+/// Can also be used as a newtype wrapper for render world entities.
+#[derive(Deref, Copy, Clone, Debug, Eq, Hash, PartialEq)]
+pub struct RenderEntity(Entity);
+impl RenderEntity {
+    #[inline]
+    pub fn id(&self) -> Entity {
+        self.0
+    }
+}
+
+impl Component for RenderEntity {
+    const STORAGE_TYPE: StorageType = StorageType::Table;
+
+    type Mutability = Mutable;
+
+    fn clone_behavior() -> ComponentCloneBehavior {
+        ComponentCloneBehavior::Ignore
+    }
+}
+
+impl From<Entity> for RenderEntity {
+    fn from(entity: Entity) -> Self {
+        RenderEntity(entity)
+    }
+}
+
+impl ContainsEntity for RenderEntity {
+    fn entity(&self) -> Entity {
+        self.id()
+    }
+}
+
+// SAFETY: RenderEntity is a newtype around Entity that derives its comparison traits.
+unsafe impl EntityEquivalent for RenderEntity {}
+
+/// Component added on the render world entities to keep track of the corresponding main world entity.
+///
+/// Can also be used as a newtype wrapper for main world entities.
+#[derive(Component, Deref, Copy, Clone, Debug, Eq, Hash, PartialEq, PartialOrd, Ord)]
+pub struct MainEntity(Entity);
+impl MainEntity {
+    #[inline]
+    pub fn id(&self) -> Entity {
+        self.0
+    }
+}
+
+impl From<Entity> for MainEntity {
+    fn from(entity: Entity) -> Self {
+        MainEntity(entity)
+    }
+}
+
+impl ContainsEntity for MainEntity {
+    fn entity(&self) -> Entity {
+        self.id()
+    }
+}
+
+// SAFETY: RenderEntity is a newtype around Entity that derives its comparison traits.
+unsafe impl EntityEquivalent for MainEntity {}
+
+/// A [`HashMap`] pre-configured to use [`EntityHash`] hashing with a [`MainEntity`].
+pub type MainEntityHashMap<V> = HashMap<MainEntity, V, EntityHash>;
+
+/// A [`HashSet`] pre-configured to use [`EntityHash`] hashing with a [`MainEntity`]..
+pub type MainEntityHashSet = HashSet<MainEntity, EntityHash>;
+
+/// Marker component that indicates that its entity needs to be despawned at the end of the frame.
+#[derive(Component, Copy, Clone, Debug, Default, Reflect)]
+#[reflect(Component, Default, Clone)]
+pub struct TemporaryRenderEntity;
+
+/// A record enum to what entities with [`SyncToRenderWorld`] have been added or removed.
+#[derive(Debug)]
+pub(crate) enum EntityRecord {
+    /// When an entity is spawned on the main world, notify the render world so that it can spawn a corresponding
+    /// entity. This contains the main world entity.
+    Added(Entity),
+    /// When an entity is despawned on the main world, notify the render world so that the corresponding entity can be
+    /// despawned. This contains the render world entity.
+    Removed(RenderEntity),
+    /// When a component is removed from an entity, notify the render world so that the corresponding component can be
+    /// removed. This contains the main world entity.
+    ComponentRemoved(Entity),
+}
+
+// Entity Record in MainWorld pending to Sync
+#[derive(Resource, Default, Deref, DerefMut)]
+pub(crate) struct PendingSyncEntity {
+    records: Vec<EntityRecord>,
+}
+
+pub(crate) fn entity_sync_system(main_world: &mut World, render_world: &mut World) {
+    main_world.resource_scope(|world, mut pending: Mut<PendingSyncEntity>| {
+        // TODO : batching record
+        for record in pending.drain(..) {
+            match record {
+                EntityRecord::Added(e) => {
+                    if let Ok(mut main_entity) = world.get_entity_mut(e) {
+                        match main_entity.entry::<RenderEntity>() {
+                            bevy_ecs::world::Entry::Occupied(_) => {
+                                panic!("Attempting to synchronize an entity that has already been synchronized!");
+                            }
+                            bevy_ecs::world::Entry::Vacant(entry) => {
+                                let id = render_world.spawn(MainEntity(e)).id();
+
+                                entry.insert(RenderEntity(id));
+                            }
+                        };
+                    }
+                }
+                EntityRecord::Removed(render_entity) => {
+                    if let Ok(ec) = render_world.get_entity_mut(render_entity.id()) {
+                        ec.despawn();
+                    };
+                }
+                EntityRecord::ComponentRemoved(main_entity) => {
+                    let Some(mut render_entity) = world.get_mut::<RenderEntity>(main_entity) else {
+                        continue;
+                    };
+                    if let Ok(render_world_entity) = render_world.get_entity_mut(render_entity.id()) {
+                        // In order to handle components that extract to derived components, we clear the entity
+                        // and let the extraction system re-add the components.
+                        render_world_entity.despawn();
+
+                        let id = render_world.spawn(MainEntity(main_entity)).id();
+                        render_entity.0 = id;
+                    }
+                },
+            }
+        }
+    });
+}
+
+pub(crate) fn despawn_temporary_render_entities(
+    world: &mut World,
+    state: &mut SystemState<Query<Entity, With<TemporaryRenderEntity>>>,
+    mut local: Local<Vec<Entity>>,
+) {
+    let query = state.get(world);
+
+    local.extend(query.iter());
+
+    // Ensure next frame allocation keeps order
+    local.sort_unstable_by_key(|e| e.index());
+    for e in local.drain(..).rev() {
+        world.despawn(e);
+    }
+}
+
+/// This module exists to keep the complex unsafe code out of the main module.
+///
+/// The implementations for both [`MainEntity`] and [`RenderEntity`] should stay in sync,
+/// and are based off of the `&T` implementation in `bevy_ecs`.
+mod render_entities_world_query_impls {
+    use super::{MainEntity, RenderEntity};
+
+    use bevy_ecs::{
+        archetype::Archetype,
+        component::{ComponentId, Components, Tick},
+        entity::Entity,
+        query::{FilteredAccess, QueryData, ReadOnlyQueryData, WorldQuery},
+        storage::{Table, TableRow},
+        world::{unsafe_world_cell::UnsafeWorldCell, World},
+    };
+
+    /// SAFETY: defers completely to `&RenderEntity` implementation,
+    /// and then only modifies the output safely.
+    unsafe impl WorldQuery for RenderEntity {
+        type Fetch<'w> = <&'static RenderEntity as WorldQuery>::Fetch<'w>;
+        type State = <&'static RenderEntity as WorldQuery>::State;
+
+        fn shrink_fetch<'wlong: 'wshort, 'wshort>(
+            fetch: Self::Fetch<'wlong>,
+        ) -> Self::Fetch<'wshort> {
+            fetch
+        }
+
+        #[inline]
+        unsafe fn init_fetch<'w>(
+            world: UnsafeWorldCell<'w>,
+            component_id: &ComponentId,
+            last_run: Tick,
+            this_run: Tick,
+        ) -> Self::Fetch<'w> {
+            // SAFETY: defers to the `&T` implementation, with T set to `RenderEntity`.
+            unsafe {
+                <&RenderEntity as WorldQuery>::init_fetch(world, component_id, last_run, this_run)
+            }
+        }
+
+        const IS_DENSE: bool = <&'static RenderEntity as WorldQuery>::IS_DENSE;
+
+        #[inline]
+        unsafe fn set_archetype<'w>(
+            fetch: &mut Self::Fetch<'w>,
+            component_id: &ComponentId,
+            archetype: &'w Archetype,
+            table: &'w Table,
+        ) {
+            // SAFETY: defers to the `&T` implementation, with T set to `RenderEntity`.
+            unsafe {
+                <&RenderEntity as WorldQuery>::set_archetype(fetch, component_id, archetype, table);
+            }
+        }
+
+        #[inline]
+        unsafe fn set_table<'w>(
+            fetch: &mut Self::Fetch<'w>,
+            &component_id: &ComponentId,
+            table: &'w Table,
+        ) {
+            // SAFETY: defers to the `&T` implementation, with T set to `RenderEntity`.
+            unsafe { <&RenderEntity as WorldQuery>::set_table(fetch, &component_id, table) }
+        }
+
+        fn update_component_access(
+            &component_id: &ComponentId,
+            access: &mut FilteredAccess<ComponentId>,
+        ) {
+            <&RenderEntity as WorldQuery>::update_component_access(&component_id, access);
+        }
+
+        fn init_state(world: &mut World) -> ComponentId {
+            <&RenderEntity as WorldQuery>::init_state(world)
+        }
+
+        fn get_state(components: &Components) -> Option<Self::State> {
+            <&RenderEntity as WorldQuery>::get_state(components)
+        }
+
+        fn matches_component_set(
+            &state: &ComponentId,
+            set_contains_id: &impl Fn(ComponentId) -> bool,
+        ) -> bool {
+            <&RenderEntity as WorldQuery>::matches_component_set(&state, set_contains_id)
+        }
+    }
+
+    // SAFETY: Component access of Self::ReadOnly is a subset of Self.
+    // Self::ReadOnly matches exactly the same archetypes/tables as Self.
+    unsafe impl QueryData for RenderEntity {
+        const IS_READ_ONLY: bool = true;
+        type ReadOnly = RenderEntity;
+        type Item<'w> = Entity;
+
+        fn shrink<'wlong: 'wshort, 'wshort>(item: Entity) -> Entity {
+            item
+        }
+
+        #[inline(always)]
+        unsafe fn fetch<'w>(
+            fetch: &mut Self::Fetch<'w>,
+            entity: Entity,
+            table_row: TableRow,
+        ) -> Self::Item<'w> {
+            // SAFETY: defers to the `&T` implementation, with T set to `RenderEntity`.
+            let component =
+                unsafe { <&RenderEntity as QueryData>::fetch(fetch, entity, table_row) };
+            component.id()
+        }
+    }
+
+    // SAFETY: the underlying `Entity` is copied, and no mutable access is provided.
+    unsafe impl ReadOnlyQueryData for RenderEntity {}
+
+    /// SAFETY: defers completely to `&RenderEntity` implementation,
+    /// and then only modifies the output safely.
+    unsafe impl WorldQuery for MainEntity {
+        type Fetch<'w> = <&'static MainEntity as WorldQuery>::Fetch<'w>;
+        type State = <&'static MainEntity as WorldQuery>::State;
+
+        fn shrink_fetch<'wlong: 'wshort, 'wshort>(
+            fetch: Self::Fetch<'wlong>,
+        ) -> Self::Fetch<'wshort> {
+            fetch
+        }
+
+        #[inline]
+        unsafe fn init_fetch<'w>(
+            world: UnsafeWorldCell<'w>,
+            component_id: &ComponentId,
+            last_run: Tick,
+            this_run: Tick,
+        ) -> Self::Fetch<'w> {
+            // SAFETY: defers to the `&T` implementation, with T set to `MainEntity`.
+            unsafe {
+                <&MainEntity as WorldQuery>::init_fetch(world, component_id, last_run, this_run)
+            }
+        }
+
+        const IS_DENSE: bool = <&'static MainEntity as WorldQuery>::IS_DENSE;
+
+        #[inline]
+        unsafe fn set_archetype<'w>(
+            fetch: &mut Self::Fetch<'w>,
+            component_id: &ComponentId,
+            archetype: &'w Archetype,
+            table: &'w Table,
+        ) {
+            // SAFETY: defers to the `&T` implementation, with T set to `MainEntity`.
+            unsafe {
+                <&MainEntity as WorldQuery>::set_archetype(fetch, component_id, archetype, table);
+            }
+        }
+
+        #[inline]
+        unsafe fn set_table<'w>(
+            fetch: &mut Self::Fetch<'w>,
+            &component_id: &ComponentId,
+            table: &'w Table,
+        ) {
+            // SAFETY: defers to the `&T` implementation, with T set to `MainEntity`.
+            unsafe { <&MainEntity as WorldQuery>::set_table(fetch, &component_id, table) }
+        }
+
+        fn update_component_access(
+            &component_id: &ComponentId,
+            access: &mut FilteredAccess<ComponentId>,
+        ) {
+            <&MainEntity as WorldQuery>::update_component_access(&component_id, access);
+        }
+
+        fn init_state(world: &mut World) -> ComponentId {
+            <&MainEntity as WorldQuery>::init_state(world)
+        }
+
+        fn get_state(components: &Components) -> Option<Self::State> {
+            <&MainEntity as WorldQuery>::get_state(components)
+        }
+
+        fn matches_component_set(
+            &state: &ComponentId,
+            set_contains_id: &impl Fn(ComponentId) -> bool,
+        ) -> bool {
+            <&MainEntity as WorldQuery>::matches_component_set(&state, set_contains_id)
+        }
+    }
+
+    // SAFETY: Component access of Self::ReadOnly is a subset of Self.
+    // Self::ReadOnly matches exactly the same archetypes/tables as Self.
+    unsafe impl QueryData for MainEntity {
+        const IS_READ_ONLY: bool = true;
+        type ReadOnly = MainEntity;
+        type Item<'w> = Entity;
+
+        fn shrink<'wlong: 'wshort, 'wshort>(item: Entity) -> Entity {
+            item
+        }
+
+        #[inline(always)]
+        unsafe fn fetch<'w>(
+            fetch: &mut Self::Fetch<'w>,
+            entity: Entity,
+            table_row: TableRow,
+        ) -> Self::Item<'w> {
+            // SAFETY: defers to the `&T` implementation, with T set to `MainEntity`.
+            let component = unsafe { <&MainEntity as QueryData>::fetch(fetch, entity, table_row) };
+            component.id()
+        }
+    }
+
+    // SAFETY: the underlying `Entity` is copied, and no mutable access is provided.
+    unsafe impl ReadOnlyQueryData for MainEntity {}
+}
+
+#[cfg(test)]
+mod tests {
+    use bevy_ecs::{
+        component::Component,
+        entity::Entity,
+        observer::Trigger,
+        query::With,
+        system::{Query, ResMut},
+        world::{OnAdd, OnRemove, World},
+    };
+
+    use super::{
+        entity_sync_system, EntityRecord, MainEntity, PendingSyncEntity, RenderEntity,
+        SyncToRenderWorld,
+    };
+
+    #[derive(Component)]
+    struct RenderDataComponent;
+
+    #[test]
+    fn sync_world() {
+        let mut main_world = World::new();
+        let mut render_world = World::new();
+        main_world.init_resource::<PendingSyncEntity>();
+
+        main_world.add_observer(
+            |trigger: Trigger<OnAdd, SyncToRenderWorld>, mut pending: ResMut<PendingSyncEntity>| {
+                pending.push(EntityRecord::Added(trigger.target()));
+            },
+        );
+        main_world.add_observer(
+            |trigger: Trigger<OnRemove, SyncToRenderWorld>,
+             mut pending: ResMut<PendingSyncEntity>,
+             query: Query<&RenderEntity>| {
+                if let Ok(e) = query.get(trigger.target()) {
+                    pending.push(EntityRecord::Removed(*e));
+                };
+            },
+        );
+
+        // spawn some empty entities for test
+        for _ in 0..99 {
+            main_world.spawn_empty();
+        }
+
+        // spawn
+        let main_entity = main_world
+            .spawn(RenderDataComponent)
+            // indicates that its entity needs to be synchronized to the render world
+            .insert(SyncToRenderWorld)
+            .id();
+
+        entity_sync_system(&mut main_world, &mut render_world);
+
+        let mut q = render_world.query_filtered::<Entity, With<MainEntity>>();
+
+        // Only one synchronized entity
+        assert!(q.iter(&render_world).count() == 1);
+
+        let render_entity = q.single(&render_world).unwrap();
+        let render_entity_component = main_world.get::<RenderEntity>(main_entity).unwrap();
+
+        assert!(render_entity_component.id() == render_entity);
+
+        let main_entity_component = render_world
+            .get::<MainEntity>(render_entity_component.id())
+            .unwrap();
+
+        assert!(main_entity_component.id() == main_entity);
+
+        // despawn
+        main_world.despawn(main_entity);
+
+        entity_sync_system(&mut main_world, &mut render_world);
+
+        // Only one synchronized entity
+        assert!(q.iter(&render_world).count() == 0);
+    }
+}

vendor/bevy_render/src/texture/fallback_image.rs

@@ -0,0 +1,272 @@
+use crate::{
+    render_asset::RenderAssetUsages,
+    render_resource::*,
+    renderer::{RenderDevice, RenderQueue},
+    texture::{DefaultImageSampler, GpuImage},
+};
+use bevy_derive::{Deref, DerefMut};
+use bevy_ecs::{
+    prelude::{FromWorld, Res, ResMut},
+    resource::Resource,
+    system::SystemParam,
+};
+use bevy_image::{BevyDefault, Image, ImageSampler, TextureFormatPixelInfo};
+use bevy_platform::collections::HashMap;
+
+/// A [`RenderApp`](crate::RenderApp) resource that contains the default "fallback image",
+/// which can be used in situations where an image was not explicitly defined. The most common
+/// use case is [`AsBindGroup`] implementations (such as materials) that support optional textures.
+///
+/// Defaults to a 1x1 fully opaque white texture, (1.0, 1.0, 1.0, 1.0) which makes multiplying
+/// it with other colors a no-op.
+#[derive(Resource)]
+pub struct FallbackImage {
+    /// Fallback image for [`TextureViewDimension::D1`].
+    pub d1: GpuImage,
+    /// Fallback image for [`TextureViewDimension::D2`].
+    pub d2: GpuImage,
+    /// Fallback image for [`TextureViewDimension::D2Array`].
+    pub d2_array: GpuImage,
+    /// Fallback image for [`TextureViewDimension::Cube`].
+    pub cube: GpuImage,
+    /// Fallback image for [`TextureViewDimension::CubeArray`].
+    pub cube_array: GpuImage,
+    /// Fallback image for [`TextureViewDimension::D3`].
+    pub d3: GpuImage,
+}
+
+impl FallbackImage {
+    /// Returns the appropriate fallback image for the given texture dimension.
+    pub fn get(&self, texture_dimension: TextureViewDimension) -> &GpuImage {
+        match texture_dimension {
+            TextureViewDimension::D1 => &self.d1,
+            TextureViewDimension::D2 => &self.d2,
+            TextureViewDimension::D2Array => &self.d2_array,
+            TextureViewDimension::Cube => &self.cube,
+            TextureViewDimension::CubeArray => &self.cube_array,
+            TextureViewDimension::D3 => &self.d3,
+        }
+    }
+}
+
+/// A [`RenderApp`](crate::RenderApp) resource that contains a _zero-filled_ "fallback image",
+/// which can be used in place of [`FallbackImage`], when a fully transparent or black fallback
+/// is required instead of fully opaque white.
+///
+/// Defaults to a 1x1 fully transparent black texture, (0.0, 0.0, 0.0, 0.0) which makes adding
+/// or alpha-blending it to other colors a no-op.
+#[derive(Resource, Deref)]
+pub struct FallbackImageZero(GpuImage);
+
+/// A [`RenderApp`](crate::RenderApp) resource that contains a "cubemap fallback image",
+/// which can be used in situations where an image was not explicitly defined. The most common
+/// use case is [`AsBindGroup`] implementations (such as materials) that support optional textures.
+#[derive(Resource, Deref)]
+pub struct FallbackImageCubemap(GpuImage);
+
+fn fallback_image_new(
+    render_device: &RenderDevice,
+    render_queue: &RenderQueue,
+    default_sampler: &DefaultImageSampler,
+    format: TextureFormat,
+    dimension: TextureViewDimension,
+    samples: u32,
+    value: u8,
+) -> GpuImage {
+    // TODO make this configurable per channel
+
+    let extents = Extent3d {
+        width: 1,
+        height: 1,
+        depth_or_array_layers: match dimension {
+            TextureViewDimension::Cube | TextureViewDimension::CubeArray => 6,
+            _ => 1,
+        },
+    };
+
+    // We can't create textures with data when it's a depth texture or when using multiple samples
+    let create_texture_with_data = !format.is_depth_stencil_format() && samples == 1;
+
+    let image_dimension = dimension.compatible_texture_dimension();
+    let mut image = if create_texture_with_data {
+        let data = vec![value; format.pixel_size()];
+        Image::new_fill(
+            extents,
+            image_dimension,
+            &data,
+            format,
+            RenderAssetUsages::RENDER_WORLD,
+        )
+    } else {
+        let mut image = Image::default_uninit();
+        image.texture_descriptor.dimension = TextureDimension::D2;
+        image.texture_descriptor.size = extents;
+        image.texture_descriptor.format = format;
+        image
+    };
+    image.texture_descriptor.sample_count = samples;
+    if image_dimension == TextureDimension::D2 {
+        image.texture_descriptor.usage |= TextureUsages::RENDER_ATTACHMENT;
+    }
+
+    let texture = if create_texture_with_data {
+        render_device.create_texture_with_data(
+            render_queue,
+            &image.texture_descriptor,
+            TextureDataOrder::default(),
+            &image.data.expect("Image has no data"),
+        )
+    } else {
+        render_device.create_texture(&image.texture_descriptor)
+    };
+
+    let texture_view = texture.create_view(&TextureViewDescriptor {
+        dimension: Some(dimension),
+        array_layer_count: Some(extents.depth_or_array_layers),
+        ..TextureViewDescriptor::default()
+    });
+    let sampler = match image.sampler {
+        ImageSampler::Default => (**default_sampler).clone(),
+        ImageSampler::Descriptor(ref descriptor) => {
+            render_device.create_sampler(&descriptor.as_wgpu())
+        }
+    };
+    GpuImage {
+        texture,
+        texture_view,
+        texture_format: image.texture_descriptor.format,
+        sampler,
+        size: image.texture_descriptor.size,
+        mip_level_count: image.texture_descriptor.mip_level_count,
+    }
+}
+
+impl FromWorld for FallbackImage {
+    fn from_world(world: &mut bevy_ecs::prelude::World) -> Self {
+        let render_device = world.resource::<RenderDevice>();
+        let render_queue = world.resource::<RenderQueue>();
+        let default_sampler = world.resource::<DefaultImageSampler>();
+        Self {
+            d1: fallback_image_new(
+                render_device,
+                render_queue,
+                default_sampler,
+                TextureFormat::bevy_default(),
+                TextureViewDimension::D1,
+                1,
+                255,
+            ),
+            d2: fallback_image_new(
+                render_device,
+                render_queue,
+                default_sampler,
+                TextureFormat::bevy_default(),
+                TextureViewDimension::D2,
+                1,
+                255,
+            ),
+            d2_array: fallback_image_new(
+                render_device,
+                render_queue,
+                default_sampler,
+                TextureFormat::bevy_default(),
+                TextureViewDimension::D2Array,
+                1,
+                255,
+            ),
+            cube: fallback_image_new(
+                render_device,
+                render_queue,
+                default_sampler,
+                TextureFormat::bevy_default(),
+                TextureViewDimension::Cube,
+                1,
+                255,
+            ),
+            cube_array: fallback_image_new(
+                render_device,
+                render_queue,
+                default_sampler,
+                TextureFormat::bevy_default(),
+                TextureViewDimension::CubeArray,
+                1,
+                255,
+            ),
+            d3: fallback_image_new(
+                render_device,
+                render_queue,
+                default_sampler,
+                TextureFormat::bevy_default(),
+                TextureViewDimension::D3,
+                1,
+                255,
+            ),
+        }
+    }
+}
+
+impl FromWorld for FallbackImageZero {
+    fn from_world(world: &mut bevy_ecs::prelude::World) -> Self {
+        let render_device = world.resource::<RenderDevice>();
+        let render_queue = world.resource::<RenderQueue>();
+        let default_sampler = world.resource::<DefaultImageSampler>();
+        Self(fallback_image_new(
+            render_device,
+            render_queue,
+            default_sampler,
+            TextureFormat::bevy_default(),
+            TextureViewDimension::D2,
+            1,
+            0,
+        ))
+    }
+}
+
+impl FromWorld for FallbackImageCubemap {
+    fn from_world(world: &mut bevy_ecs::prelude::World) -> Self {
+        let render_device = world.resource::<RenderDevice>();
+        let render_queue = world.resource::<RenderQueue>();
+        let default_sampler = world.resource::<DefaultImageSampler>();
+        Self(fallback_image_new(
+            render_device,
+            render_queue,
+            default_sampler,
+            TextureFormat::bevy_default(),
+            TextureViewDimension::Cube,
+            1,
+            255,
+        ))
+    }
+}
+
+/// A Cache of fallback textures that uses the sample count and `TextureFormat` as a key
+///
+/// # WARNING
+/// Images using MSAA with sample count > 1 are not initialized with data, therefore,
+/// you shouldn't sample them before writing data to them first.
+#[derive(Resource, Deref, DerefMut, Default)]
+pub struct FallbackImageFormatMsaaCache(HashMap<(u32, TextureFormat), GpuImage>);
+
+#[derive(SystemParam)]
+pub struct FallbackImageMsaa<'w> {
+    cache: ResMut<'w, FallbackImageFormatMsaaCache>,
+    render_device: Res<'w, RenderDevice>,
+    render_queue: Res<'w, RenderQueue>,
+    default_sampler: Res<'w, DefaultImageSampler>,
+}
+
+impl<'w> FallbackImageMsaa<'w> {
+    pub fn image_for_samplecount(&mut self, sample_count: u32, format: TextureFormat) -> &GpuImage {
+        self.cache.entry((sample_count, format)).or_insert_with(|| {
+            fallback_image_new(
+                &self.render_device,
+                &self.render_queue,
+                &self.default_sampler,
+                format,
+                TextureViewDimension::D2,
+                sample_count,
+                255,
+            )
+        })
+    }
+}

vendor/bevy_render/src/texture/gpu_image.rs

@@ -0,0 +1,99 @@
+use crate::{
+    render_asset::{PrepareAssetError, RenderAsset, RenderAssetUsages},
+    render_resource::{DefaultImageSampler, Sampler, Texture, TextureView},
+    renderer::{RenderDevice, RenderQueue},
+};
+use bevy_asset::AssetId;
+use bevy_ecs::system::{lifetimeless::SRes, SystemParamItem};
+use bevy_image::{Image, ImageSampler};
+use bevy_math::{AspectRatio, UVec2};
+use wgpu::{Extent3d, TextureFormat, TextureViewDescriptor};
+
+/// The GPU-representation of an [`Image`].
+/// Consists of the [`Texture`], its [`TextureView`] and the corresponding [`Sampler`], and the texture's size.
+#[derive(Debug, Clone)]
+pub struct GpuImage {
+    pub texture: Texture,
+    pub texture_view: TextureView,
+    pub texture_format: TextureFormat,
+    pub sampler: Sampler,
+    pub size: Extent3d,
+    pub mip_level_count: u32,
+}
+
+impl RenderAsset for GpuImage {
+    type SourceAsset = Image;
+    type Param = (
+        SRes<RenderDevice>,
+        SRes<RenderQueue>,
+        SRes<DefaultImageSampler>,
+    );
+
+    #[inline]
+    fn asset_usage(image: &Self::SourceAsset) -> RenderAssetUsages {
+        image.asset_usage
+    }
+
+    #[inline]
+    fn byte_len(image: &Self::SourceAsset) -> Option<usize> {
+        image.data.as_ref().map(Vec::len)
+    }
+
+    /// Converts the extracted image into a [`GpuImage`].
+    fn prepare_asset(
+        image: Self::SourceAsset,
+        _: AssetId<Self::SourceAsset>,
+        (render_device, render_queue, default_sampler): &mut SystemParamItem<Self::Param>,
+    ) -> Result<Self, PrepareAssetError<Self::SourceAsset>> {
+        let texture = if let Some(ref data) = image.data {
+            render_device.create_texture_with_data(
+                render_queue,
+                &image.texture_descriptor,
+                // TODO: Is this correct? Do we need to use `MipMajor` if it's a ktx2 file?
+                wgpu::util::TextureDataOrder::default(),
+                data,
+            )
+        } else {
+            render_device.create_texture(&image.texture_descriptor)
+        };
+
+        let texture_view = texture.create_view(
+            image
+                .texture_view_descriptor
+                .or_else(|| Some(TextureViewDescriptor::default()))
+                .as_ref()
+                .unwrap(),
+        );
+        let sampler = match image.sampler {
+            ImageSampler::Default => (***default_sampler).clone(),
+            ImageSampler::Descriptor(descriptor) => {
+                render_device.create_sampler(&descriptor.as_wgpu())
+            }
+        };
+
+        Ok(GpuImage {
+            texture,
+            texture_view,
+            texture_format: image.texture_descriptor.format,
+            sampler,
+            size: image.texture_descriptor.size,
+            mip_level_count: image.texture_descriptor.mip_level_count,
+        })
+    }
+}
+
+impl GpuImage {
+    /// Returns the aspect ratio (width / height) of a 2D image.
+    #[inline]
+    pub fn aspect_ratio(&self) -> AspectRatio {
+        AspectRatio::try_from_pixels(self.size.width, self.size.height).expect(
+            "Failed to calculate aspect ratio: Image dimensions must be positive, non-zero values",
+        )
+    }
+
+    /// Returns the size of a 2D image.
+    #[inline]
+    pub fn size_2d(&self) -> UVec2 {
+        UVec2::new(self.size.width, self.size.height)
+    }
+}

vendor/bevy_render/src/texture/mod.rs

@@ -0,0 +1,136 @@
+mod fallback_image;
+mod gpu_image;
+mod texture_attachment;
+mod texture_cache;
+
+pub use crate::render_resource::DefaultImageSampler;
+#[cfg(feature = "basis-universal")]
+use bevy_image::CompressedImageSaver;
+#[cfg(feature = "hdr")]
+use bevy_image::HdrTextureLoader;
+use bevy_image::{CompressedImageFormats, Image, ImageLoader, ImageSamplerDescriptor};
+pub use fallback_image::*;
+pub use gpu_image::*;
+pub use texture_attachment::*;
+pub use texture_cache::*;
+
+use crate::{
+    render_asset::RenderAssetPlugin, renderer::RenderDevice, Render, RenderApp, RenderSet,
+};
+use bevy_app::{App, Plugin};
+use bevy_asset::{weak_handle, AssetApp, Assets, Handle};
+use bevy_ecs::prelude::*;
+
+/// A handle to a 1 x 1 transparent white image.
+///
+/// Like [`Handle<Image>::default`], this is a handle to a fallback image asset.
+/// While that handle points to an opaque white 1 x 1 image, this handle points to a transparent 1 x 1 white image.
+// Number randomly selected by fair WolframAlpha query. Totally arbitrary.
+pub const TRANSPARENT_IMAGE_HANDLE: Handle<Image> =
+    weak_handle!("d18ad97e-a322-4981-9505-44c59a4b5e46");
+
+// TODO: replace Texture names with Image names?
+/// Adds the [`Image`] as an asset and makes sure that they are extracted and prepared for the GPU.
+pub struct ImagePlugin {
+    /// The default image sampler to use when [`bevy_image::ImageSampler`] is set to `Default`.
+    pub default_sampler: ImageSamplerDescriptor,
+}
+
+impl Default for ImagePlugin {
+    fn default() -> Self {
+        ImagePlugin::default_linear()
+    }
+}
+
+impl ImagePlugin {
+    /// Creates image settings with linear sampling by default.
+    pub fn default_linear() -> ImagePlugin {
+        ImagePlugin {
+            default_sampler: ImageSamplerDescriptor::linear(),
+        }
+    }
+
+    /// Creates image settings with nearest sampling by default.
+    pub fn default_nearest() -> ImagePlugin {
+        ImagePlugin {
+            default_sampler: ImageSamplerDescriptor::nearest(),
+        }
+    }
+}
+
+impl Plugin for ImagePlugin {
+    fn build(&self, app: &mut App) {
+        #[cfg(feature = "exr")]
+        {
+            app.init_asset_loader::<bevy_image::ExrTextureLoader>();
+        }
+
+        #[cfg(feature = "hdr")]
+        {
+            app.init_asset_loader::<HdrTextureLoader>();
+        }
+
+        app.add_plugins(RenderAssetPlugin::<GpuImage>::default())
+            .register_type::<Image>()
+            .init_asset::<Image>()
+            .register_asset_reflect::<Image>();
+
+        let mut image_assets = app.world_mut().resource_mut::<Assets<Image>>();
+
+        image_assets.insert(&Handle::default(), Image::default());
+        image_assets.insert(&TRANSPARENT_IMAGE_HANDLE, Image::transparent());
+
+        #[cfg(feature = "basis-universal")]
+        if let Some(processor) = app
+            .world()
+            .get_resource::<bevy_asset::processor::AssetProcessor>()
+        {
+            processor.register_processor::<bevy_asset::processor::LoadTransformAndSave<
+                ImageLoader,
+                bevy_asset::transformer::IdentityAssetTransformer<Image>,
+                CompressedImageSaver,
+            >>(CompressedImageSaver.into());
+            processor.set_default_processor::<bevy_asset::processor::LoadTransformAndSave<
+                ImageLoader,
+                bevy_asset::transformer::IdentityAssetTransformer<Image>,
+                CompressedImageSaver,
+            >>("png");
+        }
+
+        if let Some(render_app) = app.get_sub_app_mut(RenderApp) {
+            render_app.init_resource::<TextureCache>().add_systems(
+                Render,
+                update_texture_cache_system.in_set(RenderSet::Cleanup),
+            );
+        }
+
+        if !ImageLoader::SUPPORTED_FILE_EXTENSIONS.is_empty() {
+            app.preregister_asset_loader::<ImageLoader>(ImageLoader::SUPPORTED_FILE_EXTENSIONS);
+        }
+    }
+
+    fn finish(&self, app: &mut App) {
+        if !ImageLoader::SUPPORTED_FORMATS.is_empty() {
+            let supported_compressed_formats = match app.world().get_resource::<RenderDevice>() {
+                Some(render_device) => {
+                    CompressedImageFormats::from_features(render_device.features())
+                }
+                None => CompressedImageFormats::NONE,
+            };
+            app.register_asset_loader(ImageLoader::new(supported_compressed_formats));
+        }
+
+        if let Some(render_app) = app.get_sub_app_mut(RenderApp) {
+            let default_sampler = {
+                let device = render_app.world().resource::<RenderDevice>();
+                device.create_sampler(&self.default_sampler.as_wgpu())
+            };
+            render_app
+                .insert_resource(DefaultImageSampler(default_sampler))
+                .init_resource::<FallbackImage>()
+                .init_resource::<FallbackImageZero>()
+                .init_resource::<FallbackImageCubemap>()
+                .init_resource::<FallbackImageFormatMsaaCache>();
+        }
+    }
+}

vendor/bevy_render/src/texture/texture_attachment.rs

@@ -0,0 +1,159 @@
+use super::CachedTexture;
+use crate::render_resource::{TextureFormat, TextureView};
+use alloc::sync::Arc;
+use bevy_color::LinearRgba;
+use core::sync::atomic::{AtomicBool, Ordering};
+use wgpu::{
+    LoadOp, Operations, RenderPassColorAttachment, RenderPassDepthStencilAttachment, StoreOp,
+};
+
+/// A wrapper for a [`CachedTexture`] that is used as a [`RenderPassColorAttachment`].
+#[derive(Clone)]
+pub struct ColorAttachment {
+    pub texture: CachedTexture,
+    pub resolve_target: Option<CachedTexture>,
+    clear_color: Option<LinearRgba>,
+    is_first_call: Arc<AtomicBool>,
+}
+
+impl ColorAttachment {
+    pub fn new(
+        texture: CachedTexture,
+        resolve_target: Option<CachedTexture>,
+        clear_color: Option<LinearRgba>,
+    ) -> Self {
+        Self {
+            texture,
+            resolve_target,
+            clear_color,
+            is_first_call: Arc::new(AtomicBool::new(true)),
+        }
+    }
+
+    /// Get this texture view as an attachment. The attachment will be cleared with a value of
+    /// `clear_color` if this is the first time calling this function, otherwise it will be loaded.
+    ///
+    /// The returned attachment will always have writing enabled (`store: StoreOp::Load`).
+    pub fn get_attachment(&self) -> RenderPassColorAttachment {
+        if let Some(resolve_target) = self.resolve_target.as_ref() {
+            let first_call = self.is_first_call.fetch_and(false, Ordering::SeqCst);
+
+            RenderPassColorAttachment {
+                view: &resolve_target.default_view,
+                resolve_target: Some(&self.texture.default_view),
+                ops: Operations {
+                    load: match (self.clear_color, first_call) {
+                        (Some(clear_color), true) => LoadOp::Clear(clear_color.into()),
+                        (None, _) | (Some(_), false) => LoadOp::Load,
+                    },
+                    store: StoreOp::Store,
+                },
+            }
+        } else {
+            self.get_unsampled_attachment()
+        }
+    }
+
+    /// Get this texture view as an attachment, without the resolve target. The attachment will be cleared with
+    /// a value of `clear_color` if this is the first time calling this function, otherwise it will be loaded.
+    ///
+    /// The returned attachment will always have writing enabled (`store: StoreOp::Load`).
+    pub fn get_unsampled_attachment(&self) -> RenderPassColorAttachment {
+        let first_call = self.is_first_call.fetch_and(false, Ordering::SeqCst);
+
+        RenderPassColorAttachment {
+            view: &self.texture.default_view,
+            resolve_target: None,
+            ops: Operations {
+                load: match (self.clear_color, first_call) {
+                    (Some(clear_color), true) => LoadOp::Clear(clear_color.into()),
+                    (None, _) | (Some(_), false) => LoadOp::Load,
+                },
+                store: StoreOp::Store,
+            },
+        }
+    }
+
+    pub(crate) fn mark_as_cleared(&self) {
+        self.is_first_call.store(false, Ordering::SeqCst);
+    }
+}
+
+/// A wrapper for a [`TextureView`] that is used as a depth-only [`RenderPassDepthStencilAttachment`].
+#[derive(Clone)]
+pub struct DepthAttachment {
+    pub view: TextureView,
+    clear_value: Option<f32>,
+    is_first_call: Arc<AtomicBool>,
+}
+
+impl DepthAttachment {
+    pub fn new(view: TextureView, clear_value: Option<f32>) -> Self {
+        Self {
+            view,
+            clear_value,
+            is_first_call: Arc::new(AtomicBool::new(clear_value.is_some())),
+        }
+    }
+
+    /// Get this texture view as an attachment. The attachment will be cleared with a value of
+    /// `clear_value` if this is the first time calling this function with `store` == [`StoreOp::Store`],
+    /// and a clear value was provided, otherwise it will be loaded.
+    pub fn get_attachment(&self, store: StoreOp) -> RenderPassDepthStencilAttachment {
+        let first_call = self
+            .is_first_call
+            .fetch_and(store != StoreOp::Store, Ordering::SeqCst);
+
+        RenderPassDepthStencilAttachment {
+            view: &self.view,
+            depth_ops: Some(Operations {
+                load: if first_call {
+                    // If first_call is true, then a clear value will always have been provided in the constructor
+                    LoadOp::Clear(self.clear_value.unwrap())
+                } else {
+                    LoadOp::Load
+                },
+                store,
+            }),
+            stencil_ops: None,
+        }
+    }
+}
+
+/// A wrapper for a [`TextureView`] that is used as a [`RenderPassColorAttachment`] for a view
+/// target's final output texture.
+#[derive(Clone)]
+pub struct OutputColorAttachment {
+    pub view: TextureView,
+    pub format: TextureFormat,
+    is_first_call: Arc<AtomicBool>,
+}
+
+impl OutputColorAttachment {
+    pub fn new(view: TextureView, format: TextureFormat) -> Self {
+        Self {
+            view,
+            format,
+            is_first_call: Arc::new(AtomicBool::new(true)),
+        }
+    }
+
+    /// Get this texture view as an attachment. The attachment will be cleared with a value of
+    /// the provided `clear_color` if this is the first time calling this function, otherwise it
+    /// will be loaded.
+    pub fn get_attachment(&self, clear_color: Option<LinearRgba>) -> RenderPassColorAttachment {
+        let first_call = self.is_first_call.fetch_and(false, Ordering::SeqCst);
+
+        RenderPassColorAttachment {
+            view: &self.view,
+            resolve_target: None,
+            ops: Operations {
+                load: match (clear_color, first_call) {
+                    (Some(clear_color), true) => LoadOp::Clear(clear_color.into()),
+                    (None, _) | (Some(_), false) => LoadOp::Load,
+                },
+                store: StoreOp::Store,
+            },
+        }
+    }
+}

vendor/bevy_render/src/texture/texture_cache.rs

@@ -0,0 +1,108 @@
+use crate::{
+    render_resource::{Texture, TextureView},
+    renderer::RenderDevice,
+};
+use bevy_ecs::{prelude::ResMut, resource::Resource};
+use bevy_platform::collections::{hash_map::Entry, HashMap};
+use wgpu::{TextureDescriptor, TextureViewDescriptor};
+
+/// The internal representation of a [`CachedTexture`] used to track whether it was recently used
+/// and is currently taken.
+struct CachedTextureMeta {
+    texture: Texture,
+    default_view: TextureView,
+    taken: bool,
+    frames_since_last_use: usize,
+}
+
+/// A cached GPU [`Texture`] with corresponding [`TextureView`].
+///
+/// This is useful for textures that are created repeatedly (each frame) in the rendering process
+/// to reduce the amount of GPU memory allocations.
+#[derive(Clone)]
+pub struct CachedTexture {
+    pub texture: Texture,
+    pub default_view: TextureView,
+}
+
+/// This resource caches textures that are created repeatedly in the rendering process and
+/// are only required for one frame.
+#[derive(Resource, Default)]
+pub struct TextureCache {
+    textures: HashMap<TextureDescriptor<'static>, Vec<CachedTextureMeta>>,
+}
+
+impl TextureCache {
+    /// Retrieves a texture that matches the `descriptor`. If no matching one is found a new
+    /// [`CachedTexture`] is created.
+    pub fn get(
+        &mut self,
+        render_device: &RenderDevice,
+        descriptor: TextureDescriptor<'static>,
+    ) -> CachedTexture {
+        match self.textures.entry(descriptor) {
+            Entry::Occupied(mut entry) => {
+                for texture in entry.get_mut().iter_mut() {
+                    if !texture.taken {
+                        texture.frames_since_last_use = 0;
+                        texture.taken = true;
+                        return CachedTexture {
+                            texture: texture.texture.clone(),
+                            default_view: texture.default_view.clone(),
+                        };
+                    }
+                }
+
+                let texture = render_device.create_texture(&entry.key().clone());
+                let default_view = texture.create_view(&TextureViewDescriptor::default());
+                entry.get_mut().push(CachedTextureMeta {
+                    texture: texture.clone(),
+                    default_view: default_view.clone(),
+                    frames_since_last_use: 0,
+                    taken: true,
+                });
+                CachedTexture {
+                    texture,
+                    default_view,
+                }
+            }
+            Entry::Vacant(entry) => {
+                let texture = render_device.create_texture(entry.key());
+                let default_view = texture.create_view(&TextureViewDescriptor::default());
+                entry.insert(vec![CachedTextureMeta {
+                    texture: texture.clone(),
+                    default_view: default_view.clone(),
+                    taken: true,
+                    frames_since_last_use: 0,
+                }]);
+                CachedTexture {
+                    texture,
+                    default_view,
+                }
+            }
+        }
+    }
+
+    /// Returns `true` if the texture cache contains no textures.
+    pub fn is_empty(&self) -> bool {
+        self.textures.is_empty()
+    }
+
+    /// Updates the cache and only retains recently used textures.
+    pub fn update(&mut self) {
+        self.textures.retain(|_, textures| {
+            for texture in textures.iter_mut() {
+                texture.frames_since_last_use += 1;
+                texture.taken = false;
+            }
+
+            textures.retain(|texture| texture.frames_since_last_use < 3);
+            !textures.is_empty()
+        });
+    }
+}
+
+/// Updates the [`TextureCache`] to only retains recently used textures.
+pub fn update_texture_cache_system(mut texture_cache: ResMut<TextureCache>) {
+    texture_cache.update();
+}

vendor/bevy_render/src/view/view.wgsl

@@ -0,0 +1,66 @@
+#define_import_path bevy_render::view
+
+struct ColorGrading {
+    balance: mat3x3<f32>,
+    saturation: vec3<f32>,
+    contrast: vec3<f32>,
+    gamma: vec3<f32>,
+    gain: vec3<f32>,
+    lift: vec3<f32>,
+    midtone_range: vec2<f32>,
+    exposure: f32,
+    hue: f32,
+    post_saturation: f32,
+}
+
+struct View {
+    clip_from_world: mat4x4<f32>,
+    unjittered_clip_from_world: mat4x4<f32>,
+    world_from_clip: mat4x4<f32>,
+    world_from_view: mat4x4<f32>,
+    view_from_world: mat4x4<f32>,
+    // Typically a column-major right-handed projection matrix, one of either:
+    //
+    // Perspective (infinite reverse z)
+    // ```
+    // f = 1 / tan(fov_y_radians / 2)
+    //
+    // ⎡ f / aspect  0   0     0 ⎤
+    // ⎢          0  f   0     0 ⎥
+    // ⎢          0  0   0  near ⎥
+    // ⎣          0  0  -1     0 ⎦
+    // ```
+    //
+    // Orthographic
+    // ```
+    // w = right - left
+    // h = top - bottom
+    // d = far - near
+    // cw = -right - left
+    // ch = -top - bottom
+    //
+    // ⎡ 2 / w      0      0   cw / w ⎤
+    // ⎢     0  2 / h      0   ch / h ⎥
+    // ⎢     0      0  1 / d  far / d ⎥
+    // ⎣     0      0      0        1 ⎦
+    // ```
+    //
+    // `clip_from_view[3][3] == 1.0` is the standard way to check if a projection is orthographic
+    //
+    // Wgsl matrices are column major, so for example getting the near plane of a perspective projection is `clip_from_view[3][2]`
+    // 
+    // Custom projections are also possible however.
+    clip_from_view: mat4x4<f32>,
+    view_from_clip: mat4x4<f32>,
+    world_position: vec3<f32>,
+    exposure: f32,
+    // viewport(x_origin, y_origin, width, height)
+    viewport: vec4<f32>,
+    // 6 world-space half spaces (normal: vec3, distance: f32) ordered left, right, top, bottom, near, far.
+    // The normal vectors point towards the interior of the frustum.
+    // A half space contains `p` if `normal.dot(p) + distance > 0.`
+    frustum: array<vec4<f32>, 6>,
+    color_grading: ColorGrading,
+    mip_bias: f32,
+    frame_count: u32,
+};

vendor/bevy_render/src/view/visibility/mod.rs

@@ -0,0 +1,973 @@
+mod range;
+mod render_layers;
+
+use core::any::TypeId;
+
+use bevy_ecs::component::HookContext;
+use bevy_ecs::entity::EntityHashSet;
+use bevy_ecs::world::DeferredWorld;
+use derive_more::derive::{Deref, DerefMut};
+pub use range::*;
+pub use render_layers::*;
+
+use bevy_app::{Plugin, PostUpdate};
+use bevy_asset::Assets;
+use bevy_ecs::{hierarchy::validate_parent_has_component, prelude::*};
+use bevy_reflect::{std_traits::ReflectDefault, Reflect};
+use bevy_transform::{components::GlobalTransform, TransformSystem};
+use bevy_utils::{Parallel, TypeIdMap};
+use smallvec::SmallVec;
+
+use super::NoCpuCulling;
+use crate::{
+    camera::{Camera, CameraProjection, Projection},
+    mesh::{Mesh, Mesh3d, MeshAabb},
+    primitives::{Aabb, Frustum, Sphere},
+    sync_world::MainEntity,
+};
+
+/// User indication of whether an entity is visible. Propagates down the entity hierarchy.
+///
+/// If an entity is hidden in this way, all [`Children`] (and all of their children and so on) who
+/// are set to [`Inherited`](Self::Inherited) will also be hidden.
+///
+/// This is done by the `visibility_propagate_system` which uses the entity hierarchy and
+/// `Visibility` to set the values of each entity's [`InheritedVisibility`] component.
+#[derive(Component, Clone, Copy, Reflect, Debug, PartialEq, Eq, Default)]
+#[reflect(Component, Default, Debug, PartialEq, Clone)]
+#[require(InheritedVisibility, ViewVisibility)]
+pub enum Visibility {
+    /// An entity with `Visibility::Inherited` will inherit the Visibility of its [`ChildOf`] target.
+    ///
+    /// A root-level entity that is set to `Inherited` will be visible.
+    #[default]
+    Inherited,
+    /// An entity with `Visibility::Hidden` will be unconditionally hidden.
+    Hidden,
+    /// An entity with `Visibility::Visible` will be unconditionally visible.
+    ///
+    /// Note that an entity with `Visibility::Visible` will be visible regardless of whether the
+    /// [`ChildOf`] target entity is hidden.
+    Visible,
+}
+
+impl Visibility {
+    /// Toggles between `Visibility::Inherited` and `Visibility::Visible`.
+    /// If the value is `Visibility::Hidden`, it remains unaffected.
+    #[inline]
+    pub fn toggle_inherited_visible(&mut self) {
+        *self = match *self {
+            Visibility::Inherited => Visibility::Visible,
+            Visibility::Visible => Visibility::Inherited,
+            _ => *self,
+        };
+    }
+    /// Toggles between `Visibility::Inherited` and `Visibility::Hidden`.
+    /// If the value is `Visibility::Visible`, it remains unaffected.
+    #[inline]
+    pub fn toggle_inherited_hidden(&mut self) {
+        *self = match *self {
+            Visibility::Inherited => Visibility::Hidden,
+            Visibility::Hidden => Visibility::Inherited,
+            _ => *self,
+        };
+    }
+    /// Toggles between `Visibility::Visible` and `Visibility::Hidden`.
+    /// If the value is `Visibility::Inherited`, it remains unaffected.
+    #[inline]
+    pub fn toggle_visible_hidden(&mut self) {
+        *self = match *self {
+            Visibility::Visible => Visibility::Hidden,
+            Visibility::Hidden => Visibility::Visible,
+            _ => *self,
+        };
+    }
+}
+
+// Allows `&Visibility == Visibility`
+impl PartialEq<Visibility> for &Visibility {
+    #[inline]
+    fn eq(&self, other: &Visibility) -> bool {
+        // Use the base Visibility == Visibility implementation.
+        <Visibility as PartialEq<Visibility>>::eq(*self, other)
+    }
+}
+
+// Allows `Visibility == &Visibility`
+impl PartialEq<&Visibility> for Visibility {
+    #[inline]
+    fn eq(&self, other: &&Visibility) -> bool {
+        // Use the base Visibility == Visibility implementation.
+        <Visibility as PartialEq<Visibility>>::eq(self, *other)
+    }
+}
+
+/// Whether or not an entity is visible in the hierarchy.
+/// This will not be accurate until [`VisibilityPropagate`] runs in the [`PostUpdate`] schedule.
+///
+/// If this is false, then [`ViewVisibility`] should also be false.
+///
+/// [`VisibilityPropagate`]: VisibilitySystems::VisibilityPropagate
+#[derive(Component, Deref, Debug, Default, Clone, Copy, Reflect, PartialEq, Eq)]
+#[reflect(Component, Default, Debug, PartialEq, Clone)]
+#[component(on_insert = validate_parent_has_component::<Self>)]
+pub struct InheritedVisibility(bool);
+
+impl InheritedVisibility {
+    /// An entity that is invisible in the hierarchy.
+    pub const HIDDEN: Self = Self(false);
+    /// An entity that is visible in the hierarchy.
+    pub const VISIBLE: Self = Self(true);
+
+    /// Returns `true` if the entity is visible in the hierarchy.
+    /// Otherwise, returns `false`.
+    #[inline]
+    pub fn get(self) -> bool {
+        self.0
+    }
+}
+
+/// A bucket into which we group entities for the purposes of visibility.
+///
+/// Bevy's various rendering subsystems (3D, 2D, UI, etc.) want to be able to
+/// quickly winnow the set of entities to only those that the subsystem is
+/// tasked with rendering, to avoid spending time examining irrelevant entities.
+/// At the same time, Bevy wants the [`check_visibility`] system to determine
+/// all entities' visibilities at the same time, regardless of what rendering
+/// subsystem is responsible for drawing them. Additionally, your application
+/// may want to add more types of renderable objects that Bevy determines
+/// visibility for just as it does for Bevy's built-in objects.
+///
+/// The solution to this problem is *visibility classes*. A visibility class is
+/// a type, typically the type of a component, that represents the subsystem
+/// that renders it: for example, `Mesh3d`, `Mesh2d`, and `Sprite`. The
+/// [`VisibilityClass`] component stores the visibility class or classes that
+/// the entity belongs to. (Generally, an object will belong to only one
+/// visibility class, but in rare cases it may belong to multiple.)
+///
+/// When adding a new renderable component, you'll typically want to write an
+/// add-component hook that adds the type ID of that component to the
+/// [`VisibilityClass`] array. See `custom_phase_item` for an example.
+//
+// Note: This can't be a `ComponentId` because the visibility classes are copied
+// into the render world, and component IDs are per-world.
+#[derive(Clone, Component, Default, Reflect, Deref, DerefMut)]
+#[reflect(Component, Default, Clone)]
+pub struct VisibilityClass(pub SmallVec<[TypeId; 1]>);
+
+/// Algorithmically-computed indication of whether an entity is visible and should be extracted for rendering.
+///
+/// Each frame, this will be reset to `false` during [`VisibilityPropagate`] systems in [`PostUpdate`].
+/// Later in the frame, systems in [`CheckVisibility`] will mark any visible entities using [`ViewVisibility::set`].
+/// Because of this, values of this type will be marked as changed every frame, even when they do not change.
+///
+/// If you wish to add custom visibility system that sets this value, make sure you add it to the [`CheckVisibility`] set.
+///
+/// [`VisibilityPropagate`]: VisibilitySystems::VisibilityPropagate
+/// [`CheckVisibility`]: VisibilitySystems::CheckVisibility
+#[derive(Component, Deref, Debug, Default, Clone, Copy, Reflect, PartialEq, Eq)]
+#[reflect(Component, Default, Debug, PartialEq, Clone)]
+pub struct ViewVisibility(bool);
+
+impl ViewVisibility {
+    /// An entity that cannot be seen from any views.
+    pub const HIDDEN: Self = Self(false);
+
+    /// Returns `true` if the entity is visible in any view.
+    /// Otherwise, returns `false`.
+    #[inline]
+    pub fn get(self) -> bool {
+        self.0
+    }
+
+    /// Sets the visibility to `true`. This should not be considered reversible for a given frame,
+    /// as this component tracks whether or not the entity visible in _any_ view.
+    ///
+    /// This will be automatically reset to `false` every frame in [`VisibilityPropagate`] and then set
+    /// to the proper value in [`CheckVisibility`].
+    ///
+    /// You should only manually set this if you are defining a custom visibility system,
+    /// in which case the system should be placed in the [`CheckVisibility`] set.
+    /// For normal user-defined entity visibility, see [`Visibility`].
+    ///
+    /// [`VisibilityPropagate`]: VisibilitySystems::VisibilityPropagate
+    /// [`CheckVisibility`]: VisibilitySystems::CheckVisibility
+    #[inline]
+    pub fn set(&mut self) {
+        self.0 = true;
+    }
+}
+
+/// Use this component to opt-out of built-in frustum culling for entities, see
+/// [`Frustum`].
+///
+/// It can be used for example:
+/// - when a [`Mesh`] is updated but its [`Aabb`] is not, which might happen with animations,
+/// - when using some light effects, like wanting a [`Mesh`] out of the [`Frustum`]
+///   to appear in the reflection of a [`Mesh`] within.
+#[derive(Debug, Component, Default, Reflect)]
+#[reflect(Component, Default, Debug)]
+pub struct NoFrustumCulling;
+
+/// Collection of entities visible from the current view.
+///
+/// This component contains all entities which are visible from the currently
+/// rendered view. The collection is updated automatically by the [`VisibilitySystems::CheckVisibility`]
+/// system set. Renderers can use the equivalent [`RenderVisibleEntities`] to optimize rendering of
+/// a particular view, to prevent drawing items not visible from that view.
+///
+/// This component is intended to be attached to the same entity as the [`Camera`] and
+/// the [`Frustum`] defining the view.
+#[derive(Clone, Component, Default, Debug, Reflect)]
+#[reflect(Component, Default, Debug, Clone)]
+pub struct VisibleEntities {
+    #[reflect(ignore, clone)]
+    pub entities: TypeIdMap<Vec<Entity>>,
+}
+
+impl VisibleEntities {
+    pub fn get(&self, type_id: TypeId) -> &[Entity] {
+        match self.entities.get(&type_id) {
+            Some(entities) => &entities[..],
+            None => &[],
+        }
+    }
+
+    pub fn get_mut(&mut self, type_id: TypeId) -> &mut Vec<Entity> {
+        self.entities.entry(type_id).or_default()
+    }
+
+    pub fn iter(&self, type_id: TypeId) -> impl DoubleEndedIterator<Item = &Entity> {
+        self.get(type_id).iter()
+    }
+
+    pub fn len(&self, type_id: TypeId) -> usize {
+        self.get(type_id).len()
+    }
+
+    pub fn is_empty(&self, type_id: TypeId) -> bool {
+        self.get(type_id).is_empty()
+    }
+
+    pub fn clear(&mut self, type_id: TypeId) {
+        self.get_mut(type_id).clear();
+    }
+
+    pub fn clear_all(&mut self) {
+        // Don't just nuke the hash table; we want to reuse allocations.
+        for entities in self.entities.values_mut() {
+            entities.clear();
+        }
+    }
+
+    pub fn push(&mut self, entity: Entity, type_id: TypeId) {
+        self.get_mut(type_id).push(entity);
+    }
+}
+
+/// Collection of entities visible from the current view.
+///
+/// This component is extracted from [`VisibleEntities`].
+#[derive(Clone, Component, Default, Debug, Reflect)]
+#[reflect(Component, Default, Debug, Clone)]
+pub struct RenderVisibleEntities {
+    #[reflect(ignore, clone)]
+    pub entities: TypeIdMap<Vec<(Entity, MainEntity)>>,
+}
+
+impl RenderVisibleEntities {
+    pub fn get<QF>(&self) -> &[(Entity, MainEntity)]
+    where
+        QF: 'static,
+    {
+        match self.entities.get(&TypeId::of::<QF>()) {
+            Some(entities) => &entities[..],
+            None => &[],
+        }
+    }
+
+    pub fn iter<QF>(&self) -> impl DoubleEndedIterator<Item = &(Entity, MainEntity)>
+    where
+        QF: 'static,
+    {
+        self.get::<QF>().iter()
+    }
+
+    pub fn len<QF>(&self) -> usize
+    where
+        QF: 'static,
+    {
+        self.get::<QF>().len()
+    }
+
+    pub fn is_empty<QF>(&self) -> bool
+    where
+        QF: 'static,
+    {
+        self.get::<QF>().is_empty()
+    }
+}
+
+#[derive(Debug, Hash, PartialEq, Eq, Clone, SystemSet)]
+pub enum VisibilitySystems {
+    /// Label for the [`calculate_bounds`], `calculate_bounds_2d` and `calculate_bounds_text2d` systems,
+    /// calculating and inserting an [`Aabb`] to relevant entities.
+    CalculateBounds,
+    /// Label for [`update_frusta`] in [`CameraProjectionPlugin`](crate::camera::CameraProjectionPlugin).
+    UpdateFrusta,
+    /// Label for the system propagating the [`InheritedVisibility`] in a
+    /// [`ChildOf`] / [`Children`] hierarchy.
+    VisibilityPropagate,
+    /// Label for the [`check_visibility`] system updating [`ViewVisibility`]
+    /// of each entity and the [`VisibleEntities`] of each view.\
+    ///
+    /// System order ambiguities between systems in this set are ignored:
+    /// the order of systems within this set is irrelevant, as [`check_visibility`]
+    /// assumes that its operations are irreversible during the frame.
+    CheckVisibility,
+    /// Label for the `mark_newly_hidden_entities_invisible` system, which sets
+    /// [`ViewVisibility`] to [`ViewVisibility::HIDDEN`] for entities that no
+    /// view has marked as visible.
+    MarkNewlyHiddenEntitiesInvisible,
+}
+
+pub struct VisibilityPlugin;
+
+impl Plugin for VisibilityPlugin {
+    fn build(&self, app: &mut bevy_app::App) {
+        use VisibilitySystems::*;
+
+        app.register_type::<VisibilityClass>()
+            .configure_sets(
+                PostUpdate,
+                (CalculateBounds, UpdateFrusta, VisibilityPropagate)
+                    .before(CheckVisibility)
+                    .after(TransformSystem::TransformPropagate),
+            )
+            .configure_sets(
+                PostUpdate,
+                MarkNewlyHiddenEntitiesInvisible.after(CheckVisibility),
+            )
+            .init_resource::<PreviousVisibleEntities>()
+            .add_systems(
+                PostUpdate,
+                (
+                    calculate_bounds.in_set(CalculateBounds),
+                    (visibility_propagate_system, reset_view_visibility)
+                        .in_set(VisibilityPropagate),
+                    check_visibility.in_set(CheckVisibility),
+                    mark_newly_hidden_entities_invisible.in_set(MarkNewlyHiddenEntitiesInvisible),
+                ),
+            );
+    }
+}
+
+/// Computes and adds an [`Aabb`] component to entities with a
+/// [`Mesh3d`] component and without a [`NoFrustumCulling`] component.
+///
+/// This system is used in system set [`VisibilitySystems::CalculateBounds`].
+pub fn calculate_bounds(
+    mut commands: Commands,
+    meshes: Res<Assets<Mesh>>,
+    without_aabb: Query<(Entity, &Mesh3d), (Without<Aabb>, Without<NoFrustumCulling>)>,
+) {
+    for (entity, mesh_handle) in &without_aabb {
+        if let Some(mesh) = meshes.get(mesh_handle) {
+            if let Some(aabb) = mesh.compute_aabb() {
+                commands.entity(entity).try_insert(aabb);
+            }
+        }
+    }
+}
+
+/// Updates [`Frustum`].
+///
+/// This system is used in [`CameraProjectionPlugin`](crate::camera::CameraProjectionPlugin).
+pub fn update_frusta(
+    mut views: Query<
+        (&GlobalTransform, &Projection, &mut Frustum),
+        Or<(Changed<GlobalTransform>, Changed<Projection>)>,
+    >,
+) {
+    for (transform, projection, mut frustum) in &mut views {
+        *frustum = projection.compute_frustum(transform);
+    }
+}
+
+fn visibility_propagate_system(
+    changed: Query<
+        (Entity, &Visibility, Option<&ChildOf>, Option<&Children>),
+        (
+            With<InheritedVisibility>,
+            Or<(Changed<Visibility>, Changed<ChildOf>)>,
+        ),
+    >,
+    mut visibility_query: Query<(&Visibility, &mut InheritedVisibility)>,
+    children_query: Query<&Children, (With<Visibility>, With<InheritedVisibility>)>,
+) {
+    for (entity, visibility, child_of, children) in &changed {
+        let is_visible = match visibility {
+            Visibility::Visible => true,
+            Visibility::Hidden => false,
+            // fall back to true if no parent is found or parent lacks components
+            Visibility::Inherited => child_of
+                .and_then(|c| visibility_query.get(c.parent()).ok())
+                .is_none_or(|(_, x)| x.get()),
+        };
+        let (_, mut inherited_visibility) = visibility_query
+            .get_mut(entity)
+            .expect("With<InheritedVisibility> ensures this query will return a value");
+
+        // Only update the visibility if it has changed.
+        // This will also prevent the visibility from propagating multiple times in the same frame
+        // if this entity's visibility has been updated recursively by its parent.
+        if inherited_visibility.get() != is_visible {
+            inherited_visibility.0 = is_visible;
+
+            // Recursively update the visibility of each child.
+            for &child in children.into_iter().flatten() {
+                let _ =
+                    propagate_recursive(is_visible, child, &mut visibility_query, &children_query);
+            }
+        }
+    }
+}
+
+fn propagate_recursive(
+    parent_is_visible: bool,
+    entity: Entity,
+    visibility_query: &mut Query<(&Visibility, &mut InheritedVisibility)>,
+    children_query: &Query<&Children, (With<Visibility>, With<InheritedVisibility>)>,
+    // BLOCKED: https://github.com/rust-lang/rust/issues/31436
+    // We use a result here to use the `?` operator. Ideally we'd use a try block instead
+) -> Result<(), ()> {
+    // Get the visibility components for the current entity.
+    // If the entity does not have the required components, just return early.
+    let (visibility, mut inherited_visibility) = visibility_query.get_mut(entity).map_err(drop)?;
+
+    let is_visible = match visibility {
+        Visibility::Visible => true,
+        Visibility::Hidden => false,
+        Visibility::Inherited => parent_is_visible,
+    };
+
+    // Only update the visibility if it has changed.
+    if inherited_visibility.get() != is_visible {
+        inherited_visibility.0 = is_visible;
+
+        // Recursively update the visibility of each child.
+        for &child in children_query.get(entity).ok().into_iter().flatten() {
+            let _ = propagate_recursive(is_visible, child, visibility_query, children_query);
+        }
+    }
+
+    Ok(())
+}
+
+/// Stores all entities that were visible in the previous frame.
+///
+/// As systems that check visibility judge entities visible, they remove them
+/// from this set. Afterward, the `mark_newly_hidden_entities_invisible` system
+/// runs and marks every mesh still remaining in this set as hidden.
+#[derive(Resource, Default, Deref, DerefMut)]
+pub struct PreviousVisibleEntities(EntityHashSet);
+
+/// Resets the view visibility of every entity.
+/// Entities that are visible will be marked as such later this frame
+/// by a [`VisibilitySystems::CheckVisibility`] system.
+fn reset_view_visibility(
+    mut query: Query<(Entity, &ViewVisibility)>,
+    mut previous_visible_entities: ResMut<PreviousVisibleEntities>,
+) {
+    previous_visible_entities.clear();
+
+    query.iter_mut().for_each(|(entity, view_visibility)| {
+        // Record the entities that were previously visible.
+        if view_visibility.get() {
+            previous_visible_entities.insert(entity);
+        }
+    });
+}
+
+/// System updating the visibility of entities each frame.
+///
+/// The system is part of the [`VisibilitySystems::CheckVisibility`] set. Each
+/// frame, it updates the [`ViewVisibility`] of all entities, and for each view
+/// also compute the [`VisibleEntities`] for that view.
+///
+/// To ensure that an entity is checked for visibility, make sure that it has a
+/// [`VisibilityClass`] component and that that component is nonempty.
+pub fn check_visibility(
+    mut thread_queues: Local<Parallel<TypeIdMap<Vec<Entity>>>>,
+    mut view_query: Query<(
+        Entity,
+        &mut VisibleEntities,
+        &Frustum,
+        Option<&RenderLayers>,
+        &Camera,
+        Has<NoCpuCulling>,
+    )>,
+    mut visible_aabb_query: Query<(
+        Entity,
+        &InheritedVisibility,
+        &mut ViewVisibility,
+        &VisibilityClass,
+        Option<&RenderLayers>,
+        Option<&Aabb>,
+        &GlobalTransform,
+        Has<NoFrustumCulling>,
+        Has<VisibilityRange>,
+    )>,
+    visible_entity_ranges: Option<Res<VisibleEntityRanges>>,
+    mut previous_visible_entities: ResMut<PreviousVisibleEntities>,
+) {
+    let visible_entity_ranges = visible_entity_ranges.as_deref();
+
+    for (view, mut visible_entities, frustum, maybe_view_mask, camera, no_cpu_culling) in
+        &mut view_query
+    {
+        if !camera.is_active {
+            continue;
+        }
+
+        let view_mask = maybe_view_mask.unwrap_or_default();
+
+        visible_aabb_query.par_iter_mut().for_each_init(
+            || thread_queues.borrow_local_mut(),
+            |queue, query_item| {
+                let (
+                    entity,
+                    inherited_visibility,
+                    mut view_visibility,
+                    visibility_class,
+                    maybe_entity_mask,
+                    maybe_model_aabb,
+                    transform,
+                    no_frustum_culling,
+                    has_visibility_range,
+                ) = query_item;
+
+                // Skip computing visibility for entities that are configured to be hidden.
+                // ViewVisibility has already been reset in `reset_view_visibility`.
+                if !inherited_visibility.get() {
+                    return;
+                }
+
+                let entity_mask = maybe_entity_mask.unwrap_or_default();
+                if !view_mask.intersects(entity_mask) {
+                    return;
+                }
+
+                // If outside of the visibility range, cull.
+                if has_visibility_range
+                    && visible_entity_ranges.is_some_and(|visible_entity_ranges| {
+                        !visible_entity_ranges.entity_is_in_range_of_view(entity, view)
+                    })
+                {
+                    return;
+                }
+
+                // If we have an aabb, do frustum culling
+                if !no_frustum_culling && !no_cpu_culling {
+                    if let Some(model_aabb) = maybe_model_aabb {
+                        let world_from_local = transform.affine();
+                        let model_sphere = Sphere {
+                            center: world_from_local.transform_point3a(model_aabb.center),
+                            radius: transform.radius_vec3a(model_aabb.half_extents),
+                        };
+                        // Do quick sphere-based frustum culling
+                        if !frustum.intersects_sphere(&model_sphere, false) {
+                            return;
+                        }
+                        // Do aabb-based frustum culling
+                        if !frustum.intersects_obb(model_aabb, &world_from_local, true, false) {
+                            return;
+                        }
+                    }
+                }
+
+                // Make sure we don't trigger changed notifications
+                // unnecessarily by checking whether the flag is set before
+                // setting it.
+                if !**view_visibility {
+                    view_visibility.set();
+                }
+
+                // Add the entity to the queue for all visibility classes the
+                // entity is in.
+                for visibility_class_id in visibility_class.iter() {
+                    queue.entry(*visibility_class_id).or_default().push(entity);
+                }
+            },
+        );
+
+        visible_entities.clear_all();
+
+        // Drain all the thread queues into the `visible_entities` list.
+        for class_queues in thread_queues.iter_mut() {
+            for (class, entities) in class_queues {
+                let visible_entities_for_class = visible_entities.get_mut(*class);
+                for entity in entities.drain(..) {
+                    // As we mark entities as visible, we remove them from the
+                    // `previous_visible_entities` list. At the end, all of the
+                    // entities remaining in `previous_visible_entities` will be
+                    // entities that were visible last frame but are no longer
+                    // visible this frame.
+                    previous_visible_entities.remove(&entity);
+
+                    visible_entities_for_class.push(entity);
+                }
+            }
+        }
+    }
+}
+
+/// Marks any entities that weren't judged visible this frame as invisible.
+///
+/// As visibility-determining systems run, they remove entities that they judge
+/// visible from [`PreviousVisibleEntities`]. At the end of visibility
+/// determination, all entities that remain in [`PreviousVisibleEntities`] must
+/// be invisible. This system goes through those entities and marks them newly
+/// invisible (which sets the change flag for them).
+fn mark_newly_hidden_entities_invisible(
+    mut view_visibilities: Query<&mut ViewVisibility>,
+    mut previous_visible_entities: ResMut<PreviousVisibleEntities>,
+) {
+    // Whatever previous visible entities are left are entities that were
+    // visible last frame but just became invisible.
+    for entity in previous_visible_entities.drain() {
+        if let Ok(mut view_visibility) = view_visibilities.get_mut(entity) {
+            *view_visibility = ViewVisibility::HIDDEN;
+        }
+    }
+}
+
+/// A generic component add hook that automatically adds the appropriate
+/// [`VisibilityClass`] to an entity.
+///
+/// This can be handy when creating custom renderable components. To use this
+/// hook, add it to your renderable component like this:
+///
+/// ```ignore
+/// #[derive(Component)]
+/// #[component(on_add = add_visibility_class::<MyComponent>)]
+/// struct MyComponent {
+///     ...
+/// }
+/// ```
+pub fn add_visibility_class<C>(
+    mut world: DeferredWorld<'_>,
+    HookContext { entity, .. }: HookContext,
+) where
+    C: 'static,
+{
+    if let Some(mut visibility_class) = world.get_mut::<VisibilityClass>(entity) {
+        visibility_class.push(TypeId::of::<C>());
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    use bevy_app::prelude::*;
+
+    #[test]
+    fn visibility_propagation() {
+        let mut app = App::new();
+        app.add_systems(Update, visibility_propagate_system);
+
+        let root1 = app.world_mut().spawn(Visibility::Hidden).id();
+        let root1_child1 = app.world_mut().spawn(Visibility::default()).id();
+        let root1_child2 = app.world_mut().spawn(Visibility::Hidden).id();
+        let root1_child1_grandchild1 = app.world_mut().spawn(Visibility::default()).id();
+        let root1_child2_grandchild1 = app.world_mut().spawn(Visibility::default()).id();
+
+        app.world_mut()
+            .entity_mut(root1)
+            .add_children(&[root1_child1, root1_child2]);
+        app.world_mut()
+            .entity_mut(root1_child1)
+            .add_children(&[root1_child1_grandchild1]);
+        app.world_mut()
+            .entity_mut(root1_child2)
+            .add_children(&[root1_child2_grandchild1]);
+
+        let root2 = app.world_mut().spawn(Visibility::default()).id();
+        let root2_child1 = app.world_mut().spawn(Visibility::default()).id();
+        let root2_child2 = app.world_mut().spawn(Visibility::Hidden).id();
+        let root2_child1_grandchild1 = app.world_mut().spawn(Visibility::default()).id();
+        let root2_child2_grandchild1 = app.world_mut().spawn(Visibility::default()).id();
+
+        app.world_mut()
+            .entity_mut(root2)
+            .add_children(&[root2_child1, root2_child2]);
+        app.world_mut()
+            .entity_mut(root2_child1)
+            .add_children(&[root2_child1_grandchild1]);
+        app.world_mut()
+            .entity_mut(root2_child2)
+            .add_children(&[root2_child2_grandchild1]);
+
+        app.update();
+
+        let is_visible = |e: Entity| {
+            app.world()
+                .entity(e)
+                .get::<InheritedVisibility>()
+                .unwrap()
+                .get()
+        };
+        assert!(
+            !is_visible(root1),
+            "invisibility propagates down tree from root"
+        );
+        assert!(
+            !is_visible(root1_child1),
+            "invisibility propagates down tree from root"
+        );
+        assert!(
+            !is_visible(root1_child2),
+            "invisibility propagates down tree from root"
+        );
+        assert!(
+            !is_visible(root1_child1_grandchild1),
+            "invisibility propagates down tree from root"
+        );
+        assert!(
+            !is_visible(root1_child2_grandchild1),
+            "invisibility propagates down tree from root"
+        );
+
+        assert!(
+            is_visible(root2),
+            "visibility propagates down tree from root"
+        );
+        assert!(
+            is_visible(root2_child1),
+            "visibility propagates down tree from root"
+        );
+        assert!(
+            !is_visible(root2_child2),
+            "visibility propagates down tree from root, but local invisibility is preserved"
+        );
+        assert!(
+            is_visible(root2_child1_grandchild1),
+            "visibility propagates down tree from root"
+        );
+        assert!(
+            !is_visible(root2_child2_grandchild1),
+            "child's invisibility propagates down to grandchild"
+        );
+    }
+
+    #[test]
+    fn test_visibility_propagation_on_parent_change() {
+        // Setup the world and schedule
+        let mut app = App::new();
+
+        app.add_systems(Update, visibility_propagate_system);
+
+        // Create entities with visibility and hierarchy
+        let parent1 = app.world_mut().spawn((Visibility::Hidden,)).id();
+        let parent2 = app.world_mut().spawn((Visibility::Visible,)).id();
+        let child1 = app.world_mut().spawn((Visibility::Inherited,)).id();
+        let child2 = app.world_mut().spawn((Visibility::Inherited,)).id();
+
+        // Build hierarchy
+        app.world_mut()
+            .entity_mut(parent1)
+            .add_children(&[child1, child2]);
+
+        // Run the system initially to set up visibility
+        app.update();
+
+        // Change parent visibility to Hidden
+        app.world_mut()
+            .entity_mut(parent2)
+            .insert(Visibility::Visible);
+        // Simulate a change in the parent component
+        app.world_mut().entity_mut(child2).insert(ChildOf(parent2)); // example of changing parent
+
+        // Run the system again to propagate changes
+        app.update();
+
+        let is_visible = |e: Entity| {
+            app.world()
+                .entity(e)
+                .get::<InheritedVisibility>()
+                .unwrap()
+                .get()
+        };
+
+        // Retrieve and assert visibility
+
+        assert!(
+            !is_visible(child1),
+            "Child1 should inherit visibility from parent"
+        );
+
+        assert!(
+            is_visible(child2),
+            "Child2 should inherit visibility from parent"
+        );
+    }
+
+    #[test]
+    fn visibility_propagation_unconditional_visible() {
+        use Visibility::{Hidden, Inherited, Visible};
+
+        let mut app = App::new();
+        app.add_systems(Update, visibility_propagate_system);
+
+        let root1 = app.world_mut().spawn(Visible).id();
+        let root1_child1 = app.world_mut().spawn(Inherited).id();
+        let root1_child2 = app.world_mut().spawn(Hidden).id();
+        let root1_child1_grandchild1 = app.world_mut().spawn(Visible).id();
+        let root1_child2_grandchild1 = app.world_mut().spawn(Visible).id();
+
+        let root2 = app.world_mut().spawn(Inherited).id();
+        let root3 = app.world_mut().spawn(Hidden).id();
+
+        app.world_mut()
+            .entity_mut(root1)
+            .add_children(&[root1_child1, root1_child2]);
+        app.world_mut()
+            .entity_mut(root1_child1)
+            .add_children(&[root1_child1_grandchild1]);
+        app.world_mut()
+            .entity_mut(root1_child2)
+            .add_children(&[root1_child2_grandchild1]);
+
+        app.update();
+
+        let is_visible = |e: Entity| {
+            app.world()
+                .entity(e)
+                .get::<InheritedVisibility>()
+                .unwrap()
+                .get()
+        };
+        assert!(
+            is_visible(root1),
+            "an unconditionally visible root is visible"
+        );
+        assert!(
+            is_visible(root1_child1),
+            "an inheriting child of an unconditionally visible parent is visible"
+        );
+        assert!(
+            !is_visible(root1_child2),
+            "a hidden child on an unconditionally visible parent is hidden"
+        );
+        assert!(
+            is_visible(root1_child1_grandchild1),
+            "an unconditionally visible child of an inheriting parent is visible"
+        );
+        assert!(
+            is_visible(root1_child2_grandchild1),
+            "an unconditionally visible child of a hidden parent is visible"
+        );
+        assert!(is_visible(root2), "an inheriting root is visible");
+        assert!(!is_visible(root3), "a hidden root is hidden");
+    }
+
+    #[test]
+    fn visibility_propagation_change_detection() {
+        let mut world = World::new();
+        let mut schedule = Schedule::default();
+        schedule.add_systems(visibility_propagate_system);
+
+        // Set up an entity hierarchy.
+
+        let id1 = world.spawn(Visibility::default()).id();
+
+        let id2 = world.spawn(Visibility::default()).id();
+        world.entity_mut(id1).add_children(&[id2]);
+
+        let id3 = world.spawn(Visibility::Hidden).id();
+        world.entity_mut(id2).add_children(&[id3]);
+
+        let id4 = world.spawn(Visibility::default()).id();
+        world.entity_mut(id3).add_children(&[id4]);
+
+        // Test the hierarchy.
+
+        // Make sure the hierarchy is up-to-date.
+        schedule.run(&mut world);
+        world.clear_trackers();
+
+        let mut q = world.query::<Ref<InheritedVisibility>>();
+
+        assert!(!q.get(&world, id1).unwrap().is_changed());
+        assert!(!q.get(&world, id2).unwrap().is_changed());
+        assert!(!q.get(&world, id3).unwrap().is_changed());
+        assert!(!q.get(&world, id4).unwrap().is_changed());
+
+        world.clear_trackers();
+        world.entity_mut(id1).insert(Visibility::Hidden);
+        schedule.run(&mut world);
+
+        assert!(q.get(&world, id1).unwrap().is_changed());
+        assert!(q.get(&world, id2).unwrap().is_changed());
+        assert!(!q.get(&world, id3).unwrap().is_changed());
+        assert!(!q.get(&world, id4).unwrap().is_changed());
+
+        world.clear_trackers();
+        schedule.run(&mut world);
+
+        assert!(!q.get(&world, id1).unwrap().is_changed());
+        assert!(!q.get(&world, id2).unwrap().is_changed());
+        assert!(!q.get(&world, id3).unwrap().is_changed());
+        assert!(!q.get(&world, id4).unwrap().is_changed());
+
+        world.clear_trackers();
+        world.entity_mut(id3).insert(Visibility::Inherited);
+        schedule.run(&mut world);
+
+        assert!(!q.get(&world, id1).unwrap().is_changed());
+        assert!(!q.get(&world, id2).unwrap().is_changed());
+        assert!(!q.get(&world, id3).unwrap().is_changed());
+        assert!(!q.get(&world, id4).unwrap().is_changed());
+
+        world.clear_trackers();
+        world.entity_mut(id2).insert(Visibility::Visible);
+        schedule.run(&mut world);
+
+        assert!(!q.get(&world, id1).unwrap().is_changed());
+        assert!(q.get(&world, id2).unwrap().is_changed());
+        assert!(q.get(&world, id3).unwrap().is_changed());
+        assert!(q.get(&world, id4).unwrap().is_changed());
+
+        world.clear_trackers();
+        schedule.run(&mut world);
+
+        assert!(!q.get(&world, id1).unwrap().is_changed());
+        assert!(!q.get(&world, id2).unwrap().is_changed());
+        assert!(!q.get(&world, id3).unwrap().is_changed());
+        assert!(!q.get(&world, id4).unwrap().is_changed());
+    }
+
+    #[test]
+    fn visibility_propagation_with_invalid_parent() {
+        let mut world = World::new();
+        let mut schedule = Schedule::default();
+        schedule.add_systems(visibility_propagate_system);
+
+        let parent = world.spawn(()).id();
+        let child = world.spawn(Visibility::default()).id();
+        world.entity_mut(parent).add_children(&[child]);
+
+        schedule.run(&mut world);
+        world.clear_trackers();
+
+        let child_visible = world.entity(child).get::<InheritedVisibility>().unwrap().0;
+        // defaults to same behavior of parent not found: visible = true
+        assert!(child_visible);
+    }
+
+    #[test]
+    fn ensure_visibility_enum_size() {
+        assert_eq!(1, size_of::<Visibility>());
+        assert_eq!(1, size_of::<Option<Visibility>>());
+    }
+}

vendor/bevy_render/src/view/visibility/range.rs

@@ -0,0 +1,501 @@
+//! Specific distances from the camera in which entities are visible, also known
+//! as *hierarchical levels of detail* or *HLOD*s.
+
+use core::{
+    hash::{Hash, Hasher},
+    ops::Range,
+};
+
+use bevy_app::{App, Plugin, PostUpdate};
+use bevy_ecs::{
+    component::Component,
+    entity::{Entity, EntityHashMap},
+    query::{Changed, With},
+    reflect::ReflectComponent,
+    removal_detection::RemovedComponents,
+    resource::Resource,
+    schedule::IntoScheduleConfigs as _,
+    system::{Local, Query, Res, ResMut},
+};
+use bevy_math::{vec4, FloatOrd, Vec4};
+use bevy_platform::collections::HashMap;
+use bevy_reflect::Reflect;
+use bevy_transform::components::GlobalTransform;
+use bevy_utils::{prelude::default, Parallel};
+use nonmax::NonMaxU16;
+use wgpu::{BufferBindingType, BufferUsages};
+
+use super::{check_visibility, VisibilitySystems};
+use crate::sync_world::{MainEntity, MainEntityHashMap};
+use crate::{
+    camera::Camera,
+    primitives::Aabb,
+    render_resource::BufferVec,
+    renderer::{RenderDevice, RenderQueue},
+    Extract, ExtractSchedule, Render, RenderApp, RenderSet,
+};
+
+/// We need at least 4 storage buffer bindings available to enable the
+/// visibility range buffer.
+///
+/// Even though we only use one storage buffer, the first 3 available storage
+/// buffers will go to various light-related buffers. We will grab the fourth
+/// buffer slot.
+pub const VISIBILITY_RANGES_STORAGE_BUFFER_COUNT: u32 = 4;
+
+/// The size of the visibility ranges buffer in elements (not bytes) when fewer
+/// than 6 storage buffers are available and we're forced to use a uniform
+/// buffer instead (most notably, on WebGL 2).
+const VISIBILITY_RANGE_UNIFORM_BUFFER_SIZE: usize = 64;
+
+/// A plugin that enables [`VisibilityRange`]s, which allow entities to be
+/// hidden or shown based on distance to the camera.
+pub struct VisibilityRangePlugin;
+
+impl Plugin for VisibilityRangePlugin {
+    fn build(&self, app: &mut App) {
+        app.register_type::<VisibilityRange>()
+            .init_resource::<VisibleEntityRanges>()
+            .add_systems(
+                PostUpdate,
+                check_visibility_ranges
+                    .in_set(VisibilitySystems::CheckVisibility)
+                    .before(check_visibility),
+            );
+
+        let Some(render_app) = app.get_sub_app_mut(RenderApp) else {
+            return;
+        };
+
+        render_app
+            .init_resource::<RenderVisibilityRanges>()
+            .add_systems(ExtractSchedule, extract_visibility_ranges)
+            .add_systems(
+                Render,
+                write_render_visibility_ranges.in_set(RenderSet::PrepareResourcesFlush),
+            );
+    }
+}
+
+/// Specifies the range of distances that this entity must be from the camera in
+/// order to be rendered.
+///
+/// This is also known as *hierarchical level of detail* or *HLOD*.
+///
+/// Use this component when you want to render a high-polygon mesh when the
+/// camera is close and a lower-polygon mesh when the camera is far away. This
+/// is a common technique for improving performance, because fine details are
+/// hard to see in a mesh at a distance. To avoid an artifact known as *popping*
+/// between levels, each level has a *margin*, within which the object
+/// transitions gradually from invisible to visible using a dithering effect.
+///
+/// You can also use this feature to replace multiple meshes with a single mesh
+/// when the camera is distant. This is the reason for the term "*hierarchical*
+/// level of detail". Reducing the number of meshes can be useful for reducing
+/// drawcall count. Note that you must place the [`VisibilityRange`] component
+/// on each entity you want to be part of a LOD group, as [`VisibilityRange`]
+/// isn't automatically propagated down to children.
+///
+/// A typical use of this feature might look like this:
+///
+/// | Entity                  | `start_margin` | `end_margin` |
+/// |-------------------------|----------------|--------------|
+/// | Root                    | N/A            | N/A          |
+/// | ├─ High-poly mesh       | [0, 0)         | [20, 25)     |
+/// | ├─ Low-poly mesh        | [20, 25)       | [70, 75)     |
+/// | └─ Billboard *imposter* | [70, 75)       | [150, 160)   |
+///
+/// With this setup, the user will see a high-poly mesh when the camera is
+/// closer than 20 units. As the camera zooms out, between 20 units to 25 units,
+/// the high-poly mesh will gradually fade to a low-poly mesh. When the camera
+/// is 70 to 75 units away, the low-poly mesh will fade to a single textured
+/// quad. And between 150 and 160 units, the object fades away entirely. Note
+/// that the `end_margin` of a higher LOD is always identical to the
+/// `start_margin` of the next lower LOD; this is important for the crossfade
+/// effect to function properly.
+#[derive(Component, Clone, PartialEq, Default, Reflect)]
+#[reflect(Component, PartialEq, Hash, Clone)]
+pub struct VisibilityRange {
+    /// The range of distances, in world units, between which this entity will
+    /// smoothly fade into view as the camera zooms out.
+    ///
+    /// If the start and end of this range are identical, the transition will be
+    /// abrupt, with no crossfading.
+    ///
+    /// `start_margin.end` must be less than or equal to `end_margin.start`.
+    pub start_margin: Range<f32>,
+
+    /// The range of distances, in world units, between which this entity will
+    /// smoothly fade out of view as the camera zooms out.
+    ///
+    /// If the start and end of this range are identical, the transition will be
+    /// abrupt, with no crossfading.
+    ///
+    /// `end_margin.start` must be greater than or equal to `start_margin.end`.
+    pub end_margin: Range<f32>,
+
+    /// If set to true, Bevy will use the center of the axis-aligned bounding
+    /// box ([`Aabb`]) as the position of the mesh for the purposes of
+    /// visibility range computation.
+    ///
+    /// Otherwise, if this field is set to false, Bevy will use the origin of
+    /// the mesh as the mesh's position.
+    ///
+    /// Usually you will want to leave this set to false, because different LODs
+    /// may have different AABBs, and smooth crossfades between LOD levels
+    /// require that all LODs of a mesh be at *precisely* the same position. If
+    /// you aren't using crossfading, however, and your meshes aren't centered
+    /// around their origins, then this flag may be useful.
+    pub use_aabb: bool,
+}
+
+impl Eq for VisibilityRange {}
+
+impl Hash for VisibilityRange {
+    fn hash<H>(&self, state: &mut H)
+    where
+        H: Hasher,
+    {
+        FloatOrd(self.start_margin.start).hash(state);
+        FloatOrd(self.start_margin.end).hash(state);
+        FloatOrd(self.end_margin.start).hash(state);
+        FloatOrd(self.end_margin.end).hash(state);
+    }
+}
+
+impl VisibilityRange {
+    /// Creates a new *abrupt* visibility range, with no crossfade.
+    ///
+    /// There will be no crossfade; the object will immediately vanish if the
+    /// camera is closer than `start` units or farther than `end` units from the
+    /// model.
+    ///
+    /// The `start` value must be less than or equal to the `end` value.
+    #[inline]
+    pub fn abrupt(start: f32, end: f32) -> Self {
+        Self {
+            start_margin: start..start,
+            end_margin: end..end,
+            use_aabb: false,
+        }
+    }
+
+    /// Returns true if both the start and end transitions for this range are
+    /// abrupt: that is, there is no crossfading.
+    #[inline]
+    pub fn is_abrupt(&self) -> bool {
+        self.start_margin.start == self.start_margin.end
+            && self.end_margin.start == self.end_margin.end
+    }
+
+    /// Returns true if the object will be visible at all, given a camera
+    /// `camera_distance` units away.
+    ///
+    /// Any amount of visibility, even with the heaviest dithering applied, is
+    /// considered visible according to this check.
+    #[inline]
+    pub fn is_visible_at_all(&self, camera_distance: f32) -> bool {
+        camera_distance >= self.start_margin.start && camera_distance < self.end_margin.end
+    }
+
+    /// Returns true if the object is completely invisible, given a camera
+    /// `camera_distance` units away.
+    ///
+    /// This is equivalent to `!VisibilityRange::is_visible_at_all()`.
+    #[inline]
+    pub fn is_culled(&self, camera_distance: f32) -> bool {
+        !self.is_visible_at_all(camera_distance)
+    }
+}
+
+/// Stores information related to [`VisibilityRange`]s in the render world.
+#[derive(Resource)]
+pub struct RenderVisibilityRanges {
+    /// Information corresponding to each entity.
+    entities: MainEntityHashMap<RenderVisibilityEntityInfo>,
+
+    /// Maps a [`VisibilityRange`] to its index within the `buffer`.
+    ///
+    /// This map allows us to deduplicate identical visibility ranges, which
+    /// saves GPU memory.
+    range_to_index: HashMap<VisibilityRange, NonMaxU16>,
+
+    /// The GPU buffer that stores [`VisibilityRange`]s.
+    ///
+    /// Each [`Vec4`] contains the start margin start, start margin end, end
+    /// margin start, and end margin end distances, in that order.
+    buffer: BufferVec<Vec4>,
+
+    /// True if the buffer has been changed since the last frame and needs to be
+    /// reuploaded to the GPU.
+    buffer_dirty: bool,
+}
+
+/// Per-entity information related to [`VisibilityRange`]s.
+struct RenderVisibilityEntityInfo {
+    /// The index of the range within the GPU buffer.
+    buffer_index: NonMaxU16,
+    /// True if the range is abrupt: i.e. has no crossfade.
+    is_abrupt: bool,
+}
+
+impl Default for RenderVisibilityRanges {
+    fn default() -> Self {
+        Self {
+            entities: default(),
+            range_to_index: default(),
+            buffer: BufferVec::new(
+                BufferUsages::STORAGE | BufferUsages::UNIFORM | BufferUsages::VERTEX,
+            ),
+            buffer_dirty: true,
+        }
+    }
+}
+
+impl RenderVisibilityRanges {
+    /// Clears out the [`RenderVisibilityRanges`] in preparation for a new
+    /// frame.
+    fn clear(&mut self) {
+        self.entities.clear();
+        self.range_to_index.clear();
+        self.buffer.clear();
+        self.buffer_dirty = true;
+    }
+
+    /// Inserts a new entity into the [`RenderVisibilityRanges`].
+    fn insert(&mut self, entity: MainEntity, visibility_range: &VisibilityRange) {
+        // Grab a slot in the GPU buffer, or take the existing one if there
+        // already is one.
+        let buffer_index = *self
+            .range_to_index
+            .entry(visibility_range.clone())
+            .or_insert_with(|| {
+                NonMaxU16::try_from(self.buffer.push(vec4(
+                    visibility_range.start_margin.start,
+                    visibility_range.start_margin.end,
+                    visibility_range.end_margin.start,
+                    visibility_range.end_margin.end,
+                )) as u16)
+                .unwrap_or_default()
+            });
+
+        self.entities.insert(
+            entity,
+            RenderVisibilityEntityInfo {
+                buffer_index,
+                is_abrupt: visibility_range.is_abrupt(),
+            },
+        );
+    }
+
+    /// Returns the index in the GPU buffer corresponding to the visible range
+    /// for the given entity.
+    ///
+    /// If the entity has no visible range, returns `None`.
+    #[inline]
+    pub fn lod_index_for_entity(&self, entity: MainEntity) -> Option<NonMaxU16> {
+        self.entities.get(&entity).map(|info| info.buffer_index)
+    }
+
+    /// Returns true if the entity has a visibility range and it isn't abrupt:
+    /// i.e. if it has a crossfade.
+    #[inline]
+    pub fn entity_has_crossfading_visibility_ranges(&self, entity: MainEntity) -> bool {
+        self.entities
+            .get(&entity)
+            .is_some_and(|info| !info.is_abrupt)
+    }
+
+    /// Returns a reference to the GPU buffer that stores visibility ranges.
+    #[inline]
+    pub fn buffer(&self) -> &BufferVec<Vec4> {
+        &self.buffer
+    }
+}
+
+/// Stores which entities are in within the [`VisibilityRange`]s of views.
+///
+/// This doesn't store the results of frustum or occlusion culling; use
+/// [`super::ViewVisibility`] for that. Thus entities in this list may not
+/// actually be visible.
+///
+/// For efficiency, these tables only store entities that have
+/// [`VisibilityRange`] components. Entities without such a component won't be
+/// in these tables at all.
+///
+/// The table is indexed by entity and stores a 32-bit bitmask with one bit for
+/// each camera, where a 0 bit corresponds to "out of range" and a 1 bit
+/// corresponds to "in range". Hence it's limited to storing information for 32
+/// views.
+#[derive(Resource, Default)]
+pub struct VisibleEntityRanges {
+    /// Stores which bit index each view corresponds to.
+    views: EntityHashMap<u8>,
+
+    /// Stores a bitmask in which each view has a single bit.
+    ///
+    /// A 0 bit for a view corresponds to "out of range"; a 1 bit corresponds to
+    /// "in range".
+    entities: EntityHashMap<u32>,
+}
+
+impl VisibleEntityRanges {
+    /// Clears out the [`VisibleEntityRanges`] in preparation for a new frame.
+    fn clear(&mut self) {
+        self.views.clear();
+        self.entities.clear();
+    }
+
+    /// Returns true if the entity is in range of the given camera.
+    ///
+    /// This only checks [`VisibilityRange`]s and doesn't perform any frustum or
+    /// occlusion culling. Thus the entity might not *actually* be visible.
+    ///
+    /// The entity is assumed to have a [`VisibilityRange`] component. If the
+    /// entity doesn't have that component, this method will return false.
+    #[inline]
+    pub fn entity_is_in_range_of_view(&self, entity: Entity, view: Entity) -> bool {
+        let Some(visibility_bitmask) = self.entities.get(&entity) else {
+            return false;
+        };
+        let Some(view_index) = self.views.get(&view) else {
+            return false;
+        };
+        (visibility_bitmask & (1 << view_index)) != 0
+    }
+
+    /// Returns true if the entity is in range of any view.
+    ///
+    /// This only checks [`VisibilityRange`]s and doesn't perform any frustum or
+    /// occlusion culling. Thus the entity might not *actually* be visible.
+    ///
+    /// The entity is assumed to have a [`VisibilityRange`] component. If the
+    /// entity doesn't have that component, this method will return false.
+    #[inline]
+    pub fn entity_is_in_range_of_any_view(&self, entity: Entity) -> bool {
+        self.entities.contains_key(&entity)
+    }
+}
+
+/// Checks all entities against all views in order to determine which entities
+/// with [`VisibilityRange`]s are potentially visible.
+///
+/// This only checks distance from the camera and doesn't frustum or occlusion
+/// cull.
+pub fn check_visibility_ranges(
+    mut visible_entity_ranges: ResMut<VisibleEntityRanges>,
+    view_query: Query<(Entity, &GlobalTransform), With<Camera>>,
+    mut par_local: Local<Parallel<Vec<(Entity, u32)>>>,
+    entity_query: Query<(Entity, &GlobalTransform, Option<&Aabb>, &VisibilityRange)>,
+) {
+    visible_entity_ranges.clear();
+
+    // Early out if the visibility range feature isn't in use.
+    if entity_query.is_empty() {
+        return;
+    }
+
+    // Assign an index to each view.
+    let mut views = vec![];
+    for (view, view_transform) in view_query.iter().take(32) {
+        let view_index = views.len() as u8;
+        visible_entity_ranges.views.insert(view, view_index);
+        views.push((view, view_transform.translation_vec3a()));
+    }
+
+    // Check each entity/view pair. Only consider entities with
+    // [`VisibilityRange`] components.
+    entity_query.par_iter().for_each(
+        |(entity, entity_transform, maybe_model_aabb, visibility_range)| {
+            let mut visibility = 0;
+            for (view_index, &(_, view_position)) in views.iter().enumerate() {
+                // If instructed to use the AABB and the model has one, use its
+                // center as the model position. Otherwise, use the model's
+                // translation.
+                let model_position = match (visibility_range.use_aabb, maybe_model_aabb) {
+                    (true, Some(model_aabb)) => entity_transform
+                        .affine()
+                        .transform_point3a(model_aabb.center),
+                    _ => entity_transform.translation_vec3a(),
+                };
+
+                if visibility_range.is_visible_at_all((view_position - model_position).length()) {
+                    visibility |= 1 << view_index;
+                }
+            }
+
+            // Invisible entities have no entry at all in the hash map. This speeds
+            // up checks slightly in this common case.
+            if visibility != 0 {
+                par_local.borrow_local_mut().push((entity, visibility));
+            }
+        },
+    );
+
+    visible_entity_ranges.entities.extend(par_local.drain());
+}
+
+/// Extracts all [`VisibilityRange`] components from the main world to the
+/// render world and inserts them into [`RenderVisibilityRanges`].
+pub fn extract_visibility_ranges(
+    mut render_visibility_ranges: ResMut<RenderVisibilityRanges>,
+    visibility_ranges_query: Extract<Query<(Entity, &VisibilityRange)>>,
+    changed_ranges_query: Extract<Query<Entity, Changed<VisibilityRange>>>,
+    mut removed_visibility_ranges: Extract<RemovedComponents<VisibilityRange>>,
+) {
+    if changed_ranges_query.is_empty() && removed_visibility_ranges.read().next().is_none() {
+        return;
+    }
+
+    render_visibility_ranges.clear();
+    for (entity, visibility_range) in visibility_ranges_query.iter() {
+        render_visibility_ranges.insert(entity.into(), visibility_range);
+    }
+}
+
+/// Writes the [`RenderVisibilityRanges`] table to the GPU.
+pub fn write_render_visibility_ranges(
+    render_device: Res<RenderDevice>,
+    render_queue: Res<RenderQueue>,
+    mut render_visibility_ranges: ResMut<RenderVisibilityRanges>,
+) {
+    // If there haven't been any changes, early out.
+    if !render_visibility_ranges.buffer_dirty {
+        return;
+    }
+
+    // Mess with the length of the buffer to meet API requirements if necessary.
+    match render_device.get_supported_read_only_binding_type(VISIBILITY_RANGES_STORAGE_BUFFER_COUNT)
+    {
+        // If we're using a uniform buffer, we must have *exactly*
+        // `VISIBILITY_RANGE_UNIFORM_BUFFER_SIZE` elements.
+        BufferBindingType::Uniform
+            if render_visibility_ranges.buffer.len() > VISIBILITY_RANGE_UNIFORM_BUFFER_SIZE =>
+        {
+            render_visibility_ranges
+                .buffer
+                .truncate(VISIBILITY_RANGE_UNIFORM_BUFFER_SIZE);
+        }
+        BufferBindingType::Uniform
+            if render_visibility_ranges.buffer.len() < VISIBILITY_RANGE_UNIFORM_BUFFER_SIZE =>
+        {
+            while render_visibility_ranges.buffer.len() < VISIBILITY_RANGE_UNIFORM_BUFFER_SIZE {
+                render_visibility_ranges.buffer.push(default());
+            }
+        }
+
+        // Otherwise, if we're using a storage buffer, just ensure there's
+        // something in the buffer, or else it won't get allocated.
+        BufferBindingType::Storage { .. } if render_visibility_ranges.buffer.is_empty() => {
+            render_visibility_ranges.buffer.push(default());
+        }
+
+        _ => {}
+    }
+
+    // Schedule the write.
+    render_visibility_ranges
+        .buffer
+        .write_buffer(&render_device, &render_queue);
+    render_visibility_ranges.buffer_dirty = false;
+}

vendor/bevy_render/src/view/visibility/render_layers.rs

@@ -0,0 +1,371 @@
+use bevy_ecs::prelude::{Component, ReflectComponent};
+use bevy_reflect::{std_traits::ReflectDefault, Reflect};
+use smallvec::SmallVec;
+
+pub const DEFAULT_LAYERS: &RenderLayers = &RenderLayers::layer(0);
+
+/// An identifier for a rendering layer.
+pub type Layer = usize;
+
+/// Describes which rendering layers an entity belongs to.
+///
+/// Cameras with this component will only render entities with intersecting
+/// layers.
+///
+/// Entities may belong to one or more layers, or no layer at all.
+///
+/// The [`Default`] instance of `RenderLayers` contains layer `0`, the first layer.
+///
+/// An entity with this component without any layers is invisible.
+///
+/// Entities without this component belong to layer `0`.
+#[derive(Component, Clone, Reflect, PartialEq, Eq, PartialOrd, Ord)]
+#[reflect(Component, Default, PartialEq, Debug, Clone)]
+pub struct RenderLayers(SmallVec<[u64; INLINE_BLOCKS]>);
+
+/// The number of memory blocks stored inline
+const INLINE_BLOCKS: usize = 1;
+
+impl Default for &RenderLayers {
+    fn default() -> Self {
+        DEFAULT_LAYERS
+    }
+}
+
+impl core::fmt::Debug for RenderLayers {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        f.debug_tuple("RenderLayers")
+            .field(&self.iter().collect::<Vec<_>>())
+            .finish()
+    }
+}
+
+impl FromIterator<Layer> for RenderLayers {
+    fn from_iter<T: IntoIterator<Item = Layer>>(i: T) -> Self {
+        i.into_iter().fold(Self::none(), RenderLayers::with)
+    }
+}
+
+impl Default for RenderLayers {
+    /// By default, this structure includes layer `0`, which represents the first layer.
+    ///
+    /// This is distinct from [`RenderLayers::none`], which doesn't belong to any layers.
+    fn default() -> Self {
+        const { Self::layer(0) }
+    }
+}
+
+impl RenderLayers {
+    /// Create a new `RenderLayers` belonging to the given layer.
+    ///
+    /// This `const` constructor is limited to `size_of::<usize>()` layers.
+    /// If you need to support an arbitrary number of layers, use [`with`](RenderLayers::with)
+    /// or [`from_layers`](RenderLayers::from_layers).
+    pub const fn layer(n: Layer) -> Self {
+        let (buffer_index, bit) = Self::layer_info(n);
+        assert!(
+            buffer_index < INLINE_BLOCKS,
+            "layer is out of bounds for const construction"
+        );
+        let mut buffer = [0; INLINE_BLOCKS];
+        buffer[buffer_index] = bit;
+        RenderLayers(SmallVec::from_const(buffer))
+    }
+
+    /// Create a new `RenderLayers` that belongs to no layers.
+    ///
+    /// This is distinct from [`RenderLayers::default`], which belongs to the first layer.
+    pub const fn none() -> Self {
+        RenderLayers(SmallVec::from_const([0; INLINE_BLOCKS]))
+    }
+
+    /// Create a `RenderLayers` from a list of layers.
+    pub fn from_layers(layers: &[Layer]) -> Self {
+        layers.iter().copied().collect()
+    }
+
+    /// Add the given layer.
+    ///
+    /// This may be called multiple times to allow an entity to belong
+    /// to multiple rendering layers.
+    #[must_use]
+    pub fn with(mut self, layer: Layer) -> Self {
+        let (buffer_index, bit) = Self::layer_info(layer);
+        self.extend_buffer(buffer_index + 1);
+        self.0[buffer_index] |= bit;
+        self
+    }
+
+    /// Removes the given rendering layer.
+    #[must_use]
+    pub fn without(mut self, layer: Layer) -> Self {
+        let (buffer_index, bit) = Self::layer_info(layer);
+        if buffer_index < self.0.len() {
+            self.0[buffer_index] &= !bit;
+            // Drop trailing zero memory blocks.
+            // NOTE: This is not just an optimization, it is necessary for the derived PartialEq impl to be correct.
+            if buffer_index == self.0.len() - 1 {
+                self = self.shrink();
+            }
+        }
+        self
+    }
+
+    /// Get an iterator of the layers.
+    pub fn iter(&self) -> impl Iterator<Item = Layer> + '_ {
+        self.0.iter().copied().zip(0..).flat_map(Self::iter_layers)
+    }
+
+    /// Determine if a `RenderLayers` intersects another.
+    ///
+    /// `RenderLayers`s intersect if they share any common layers.
+    ///
+    /// A `RenderLayers` with no layers will not match any other
+    /// `RenderLayers`, even another with no layers.
+    pub fn intersects(&self, other: &RenderLayers) -> bool {
+        // Check for the common case where the view layer and entity layer
+        // both point towards our default layer.
+        if self.0.as_ptr() == other.0.as_ptr() {
+            return true;
+        }
+
+        for (self_layer, other_layer) in self.0.iter().zip(other.0.iter()) {
+            if (*self_layer & *other_layer) != 0 {
+                return true;
+            }
+        }
+
+        false
+    }
+
+    /// Get the bitmask representation of the contained layers.
+    pub fn bits(&self) -> &[u64] {
+        self.0.as_slice()
+    }
+
+    const fn layer_info(layer: usize) -> (usize, u64) {
+        let buffer_index = layer / 64;
+        let bit_index = layer % 64;
+        let bit = 1u64 << bit_index;
+
+        (buffer_index, bit)
+    }
+
+    fn extend_buffer(&mut self, other_len: usize) {
+        let new_size = core::cmp::max(self.0.len(), other_len);
+        self.0.reserve_exact(new_size - self.0.len());
+        self.0.resize(new_size, 0u64);
+    }
+
+    fn iter_layers(buffer_and_offset: (u64, usize)) -> impl Iterator<Item = Layer> + 'static {
+        let (mut buffer, mut layer) = buffer_and_offset;
+        layer *= 64;
+        core::iter::from_fn(move || {
+            if buffer == 0 {
+                return None;
+            }
+            let next = buffer.trailing_zeros() + 1;
+            buffer = buffer.checked_shr(next).unwrap_or(0);
+            layer += next as usize;
+            Some(layer - 1)
+        })
+    }
+
+    /// Returns the set of [layers](Layer) shared by two instances of [`RenderLayers`].
+    ///
+    /// This corresponds to the `self & other` operation.
+    pub fn intersection(&self, other: &Self) -> Self {
+        self.combine_blocks(other, |a, b| a & b).shrink()
+    }
+
+    /// Returns all [layers](Layer) included in either instance of [`RenderLayers`].
+    ///
+    /// This corresponds to the `self | other` operation.
+    pub fn union(&self, other: &Self) -> Self {
+        self.combine_blocks(other, |a, b| a | b) // doesn't need to be shrunk, if the inputs are nonzero then the result will be too
+    }
+
+    /// Returns all [layers](Layer) included in exactly one of the instances of [`RenderLayers`].
+    ///
+    /// This corresponds to the "exclusive or" (XOR) operation: `self ^ other`.
+    pub fn symmetric_difference(&self, other: &Self) -> Self {
+        self.combine_blocks(other, |a, b| a ^ b).shrink()
+    }
+
+    /// Deallocates any trailing-zero memory blocks from this instance
+    fn shrink(mut self) -> Self {
+        let mut any_dropped = false;
+        while self.0.len() > INLINE_BLOCKS && self.0.last() == Some(&0) {
+            self.0.pop();
+            any_dropped = true;
+        }
+        if any_dropped && self.0.len() <= INLINE_BLOCKS {
+            self.0.shrink_to_fit();
+        }
+        self
+    }
+
+    /// Creates a new instance of [`RenderLayers`] by applying a function to the memory blocks
+    /// of self and another instance.
+    ///
+    /// If the function `f` might return `0` for non-zero inputs, you should call [`Self::shrink`]
+    /// on the output to ensure that there are no trailing zero memory blocks that would break
+    /// this type's equality comparison.
+    fn combine_blocks(&self, other: &Self, mut f: impl FnMut(u64, u64) -> u64) -> Self {
+        let mut a = self.0.iter();
+        let mut b = other.0.iter();
+        let mask = core::iter::from_fn(|| {
+            let a = a.next().copied();
+            let b = b.next().copied();
+            if a.is_none() && b.is_none() {
+                return None;
+            }
+            Some(f(a.unwrap_or_default(), b.unwrap_or_default()))
+        });
+        Self(mask.collect())
+    }
+}
+
+impl core::ops::BitAnd for RenderLayers {
+    type Output = Self;
+    fn bitand(self, rhs: Self) -> Self::Output {
+        self.intersection(&rhs)
+    }
+}
+
+impl core::ops::BitOr for RenderLayers {
+    type Output = Self;
+    fn bitor(self, rhs: Self) -> Self::Output {
+        self.union(&rhs)
+    }
+}
+
+impl core::ops::BitXor for RenderLayers {
+    type Output = Self;
+    fn bitxor(self, rhs: Self) -> Self::Output {
+        self.symmetric_difference(&rhs)
+    }
+}
+
+#[cfg(test)]
+mod rendering_mask_tests {
+    use super::{Layer, RenderLayers};
+    use smallvec::SmallVec;
+
+    #[test]
+    fn rendering_mask_sanity() {
+        let layer_0 = RenderLayers::layer(0);
+        assert_eq!(layer_0.0.len(), 1, "layer 0 is one buffer");
+        assert_eq!(layer_0.0[0], 1, "layer 0 is mask 1");
+        let layer_1 = RenderLayers::layer(1);
+        assert_eq!(layer_1.0.len(), 1, "layer 1 is one buffer");
+        assert_eq!(layer_1.0[0], 2, "layer 1 is mask 2");
+        let layer_0_1 = RenderLayers::layer(0).with(1);
+        assert_eq!(layer_0_1.0.len(), 1, "layer 0 + 1 is one buffer");
+        assert_eq!(layer_0_1.0[0], 3, "layer 0 + 1 is mask 3");
+        let layer_0_1_without_0 = layer_0_1.without(0);
+        assert_eq!(
+            layer_0_1_without_0.0.len(),
+            1,
+            "layer 0 + 1 - 0 is one buffer"
+        );
+        assert_eq!(layer_0_1_without_0.0[0], 2, "layer 0 + 1 - 0 is mask 2");
+        let layer_0_2345 = RenderLayers::layer(0).with(2345);
+        assert_eq!(layer_0_2345.0.len(), 37, "layer 0 + 2345 is 37 buffers");
+        assert_eq!(layer_0_2345.0[0], 1, "layer 0 + 2345 is mask 1");
+        assert_eq!(
+            layer_0_2345.0[36], 2199023255552,
+            "layer 0 + 2345 is mask 2199023255552"
+        );
+        assert!(
+            layer_0_2345.intersects(&layer_0),
+            "layer 0 + 2345 intersects 0"
+        );
+        assert!(
+            RenderLayers::layer(1).intersects(&RenderLayers::layer(1)),
+            "layers match like layers"
+        );
+        assert!(
+            RenderLayers::layer(0).intersects(&RenderLayers(SmallVec::from_const([1]))),
+            "a layer of 0 means the mask is just 1 bit"
+        );
+
+        assert!(
+            RenderLayers::layer(0)
+                .with(3)
+                .intersects(&RenderLayers::layer(3)),
+            "a mask will match another mask containing any similar layers"
+        );
+
+        assert!(
+            RenderLayers::default().intersects(&RenderLayers::default()),
+            "default masks match each other"
+        );
+
+        assert!(
+            !RenderLayers::layer(0).intersects(&RenderLayers::layer(1)),
+            "masks with differing layers do not match"
+        );
+        assert!(
+            !RenderLayers::none().intersects(&RenderLayers::none()),
+            "empty masks don't match"
+        );
+        assert_eq!(
+            RenderLayers::from_layers(&[0, 2, 16, 30])
+                .iter()
+                .collect::<Vec<_>>(),
+            vec![0, 2, 16, 30],
+            "from_layers and get_layers should roundtrip"
+        );
+        assert_eq!(
+            format!("{:?}", RenderLayers::from_layers(&[0, 1, 2, 3])).as_str(),
+            "RenderLayers([0, 1, 2, 3])",
+            "Debug instance shows layers"
+        );
+        assert_eq!(
+            RenderLayers::from_layers(&[0, 1, 2]),
+            <RenderLayers as FromIterator<Layer>>::from_iter(vec![0, 1, 2]),
+            "from_layers and from_iter are equivalent"
+        );
+
+        let tricky_layers = vec![0, 5, 17, 55, 999, 1025, 1026];
+        let layers = RenderLayers::from_layers(&tricky_layers);
+        let out = layers.iter().collect::<Vec<_>>();
+        assert_eq!(tricky_layers, out, "tricky layers roundtrip");
+    }
+
+    const MANY: RenderLayers = RenderLayers(SmallVec::from_const([u64::MAX]));
+
+    #[test]
+    fn render_layer_ops() {
+        let a = RenderLayers::from_layers(&[2, 4, 6]);
+        let b = RenderLayers::from_layers(&[1, 2, 3, 4, 5]);
+
+        assert_eq!(
+            a.clone() | b.clone(),
+            RenderLayers::from_layers(&[1, 2, 3, 4, 5, 6])
+        );
+        assert_eq!(a.clone() & b.clone(), RenderLayers::from_layers(&[2, 4]));
+        assert_eq!(a ^ b, RenderLayers::from_layers(&[1, 3, 5, 6]));
+
+        assert_eq!(RenderLayers::none() & MANY, RenderLayers::none());
+        assert_eq!(RenderLayers::none() | MANY, MANY);
+        assert_eq!(RenderLayers::none() ^ MANY, MANY);
+    }
+
+    #[test]
+    fn render_layer_shrink() {
+        // Since it has layers greater than 64, the instance should take up two memory blocks
+        let layers = RenderLayers::from_layers(&[1, 77]);
+        assert!(layers.0.len() == 2);
+        // When excluding that layer, it should drop the extra memory block
+        let layers = layers.without(77);
+        assert!(layers.0.len() == 1);
+    }
+
+    #[test]
+    fn render_layer_iter_no_overflow() {
+        let layers = RenderLayers::from_layers(&[63]);
+        layers.iter().count();
+    }
+}

vendor/bevy_render/src/view/window/mod.rs

@@ -0,0 +1,408 @@
+use crate::{
+    render_resource::{SurfaceTexture, TextureView},
+    renderer::{RenderAdapter, RenderDevice, RenderInstance},
+    Extract, ExtractSchedule, Render, RenderApp, RenderSet, WgpuWrapper,
+};
+use bevy_app::{App, Plugin};
+use bevy_ecs::{entity::EntityHashMap, prelude::*};
+use bevy_platform::collections::HashSet;
+use bevy_utils::default;
+use bevy_window::{
+    CompositeAlphaMode, PresentMode, PrimaryWindow, RawHandleWrapper, Window, WindowClosing,
+};
+use core::{
+    num::NonZero,
+    ops::{Deref, DerefMut},
+};
+use tracing::{debug, warn};
+use wgpu::{
+    SurfaceConfiguration, SurfaceTargetUnsafe, TextureFormat, TextureUsages, TextureViewDescriptor,
+};
+
+pub mod screenshot;
+
+use screenshot::{ScreenshotPlugin, ScreenshotToScreenPipeline};
+
+pub struct WindowRenderPlugin;
+
+impl Plugin for WindowRenderPlugin {
+    fn build(&self, app: &mut App) {
+        app.add_plugins(ScreenshotPlugin);
+
+        if let Some(render_app) = app.get_sub_app_mut(RenderApp) {
+            render_app
+                .init_resource::<ExtractedWindows>()
+                .init_resource::<WindowSurfaces>()
+                .add_systems(ExtractSchedule, extract_windows)
+                .add_systems(
+                    Render,
+                    create_surfaces
+                        .run_if(need_surface_configuration)
+                        .before(prepare_windows),
+                )
+                .add_systems(Render, prepare_windows.in_set(RenderSet::ManageViews));
+        }
+    }
+
+    fn finish(&self, app: &mut App) {
+        if let Some(render_app) = app.get_sub_app_mut(RenderApp) {
+            render_app.init_resource::<ScreenshotToScreenPipeline>();
+        }
+    }
+}
+
+pub struct ExtractedWindow {
+    /// An entity that contains the components in [`Window`].
+    pub entity: Entity,
+    pub handle: RawHandleWrapper,
+    pub physical_width: u32,
+    pub physical_height: u32,
+    pub present_mode: PresentMode,
+    pub desired_maximum_frame_latency: Option<NonZero<u32>>,
+    /// Note: this will not always be the swap chain texture view. When taking a screenshot,
+    /// this will point to an alternative texture instead to allow for copying the render result
+    /// to CPU memory.
+    pub swap_chain_texture_view: Option<TextureView>,
+    pub swap_chain_texture: Option<SurfaceTexture>,
+    pub swap_chain_texture_format: Option<TextureFormat>,
+    pub size_changed: bool,
+    pub present_mode_changed: bool,
+    pub alpha_mode: CompositeAlphaMode,
+}
+
+impl ExtractedWindow {
+    fn set_swapchain_texture(&mut self, frame: wgpu::SurfaceTexture) {
+        let texture_view_descriptor = TextureViewDescriptor {
+            format: Some(frame.texture.format().add_srgb_suffix()),
+            ..default()
+        };
+        self.swap_chain_texture_view = Some(TextureView::from(
+            frame.texture.create_view(&texture_view_descriptor),
+        ));
+        self.swap_chain_texture = Some(SurfaceTexture::from(frame));
+    }
+}
+
+#[derive(Default, Resource)]
+pub struct ExtractedWindows {
+    pub primary: Option<Entity>,
+    pub windows: EntityHashMap<ExtractedWindow>,
+}
+
+impl Deref for ExtractedWindows {
+    type Target = EntityHashMap<ExtractedWindow>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.windows
+    }
+}
+
+impl DerefMut for ExtractedWindows {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.windows
+    }
+}
+
+fn extract_windows(
+    mut extracted_windows: ResMut<ExtractedWindows>,
+    mut closing: Extract<EventReader<WindowClosing>>,
+    windows: Extract<Query<(Entity, &Window, &RawHandleWrapper, Option<&PrimaryWindow>)>>,
+    mut removed: Extract<RemovedComponents<RawHandleWrapper>>,
+    mut window_surfaces: ResMut<WindowSurfaces>,
+) {
+    for (entity, window, handle, primary) in windows.iter() {
+        if primary.is_some() {
+            extracted_windows.primary = Some(entity);
+        }
+
+        let (new_width, new_height) = (
+            window.resolution.physical_width().max(1),
+            window.resolution.physical_height().max(1),
+        );
+
+        let extracted_window = extracted_windows.entry(entity).or_insert(ExtractedWindow {
+            entity,
+            handle: handle.clone(),
+            physical_width: new_width,
+            physical_height: new_height,
+            present_mode: window.present_mode,
+            desired_maximum_frame_latency: window.desired_maximum_frame_latency,
+            swap_chain_texture: None,
+            swap_chain_texture_view: None,
+            size_changed: false,
+            swap_chain_texture_format: None,
+            present_mode_changed: false,
+            alpha_mode: window.composite_alpha_mode,
+        });
+
+        // NOTE: Drop the swap chain frame here
+        extracted_window.swap_chain_texture_view = None;
+        extracted_window.size_changed = new_width != extracted_window.physical_width
+            || new_height != extracted_window.physical_height;
+        extracted_window.present_mode_changed =
+            window.present_mode != extracted_window.present_mode;
+
+        if extracted_window.size_changed {
+            debug!(
+                "Window size changed from {}x{} to {}x{}",
+                extracted_window.physical_width,
+                extracted_window.physical_height,
+                new_width,
+                new_height
+            );
+            extracted_window.physical_width = new_width;
+            extracted_window.physical_height = new_height;
+        }
+
+        if extracted_window.present_mode_changed {
+            debug!(
+                "Window Present Mode changed from {:?} to {:?}",
+                extracted_window.present_mode, window.present_mode
+            );
+            extracted_window.present_mode = window.present_mode;
+        }
+    }
+
+    for closing_window in closing.read() {
+        extracted_windows.remove(&closing_window.window);
+        window_surfaces.remove(&closing_window.window);
+    }
+    for removed_window in removed.read() {
+        extracted_windows.remove(&removed_window);
+        window_surfaces.remove(&removed_window);
+    }
+}
+
+struct SurfaceData {
+    // TODO: what lifetime should this be?
+    surface: WgpuWrapper<wgpu::Surface<'static>>,
+    configuration: SurfaceConfiguration,
+}
+
+#[derive(Resource, Default)]
+pub struct WindowSurfaces {
+    surfaces: EntityHashMap<SurfaceData>,
+    /// List of windows that we have already called the initial `configure_surface` for
+    configured_windows: HashSet<Entity>,
+}
+
+impl WindowSurfaces {
+    fn remove(&mut self, window: &Entity) {
+        self.surfaces.remove(window);
+        self.configured_windows.remove(window);
+    }
+}
+
+/// (re)configures window surfaces, and obtains a swapchain texture for rendering.
+///
+/// NOTE: `get_current_texture` in `prepare_windows` can take a long time if the GPU workload is
+/// the performance bottleneck. This can be seen in profiles as multiple prepare-set systems all
+/// taking an unusually long time to complete, and all finishing at about the same time as the
+/// `prepare_windows` system. Improvements in bevy are planned to avoid this happening when it
+/// should not but it will still happen as it is easy for a user to create a large GPU workload
+/// relative to the GPU performance and/or CPU workload.
+/// This can be caused by many reasons, but several of them are:
+/// - GPU workload is more than your current GPU can manage
+/// - Error / performance bug in your custom shaders
+/// - wgpu was unable to detect a proper GPU hardware-accelerated device given the chosen
+///   [`Backends`](crate::settings::Backends), [`WgpuLimits`](crate::settings::WgpuLimits),
+///   and/or [`WgpuFeatures`](crate::settings::WgpuFeatures). For example, on Windows currently
+///   `DirectX 11` is not supported by wgpu 0.12 and so if your GPU/drivers do not support Vulkan,
+///   it may be that a software renderer called "Microsoft Basic Render Driver" using `DirectX 12`
+///   will be chosen and performance will be very poor. This is visible in a log message that is
+///   output during renderer initialization. Future versions of wgpu will support `DirectX 11`, but
+///   another alternative is to try to use [`ANGLE`](https://github.com/gfx-rs/wgpu#angle) and
+///   [`Backends::GL`](crate::settings::Backends::GL) if your GPU/drivers support `OpenGL 4.3` / `OpenGL ES 3.0` or
+///   later.
+pub fn prepare_windows(
+    mut windows: ResMut<ExtractedWindows>,
+    mut window_surfaces: ResMut<WindowSurfaces>,
+    render_device: Res<RenderDevice>,
+    #[cfg(target_os = "linux")] render_instance: Res<RenderInstance>,
+) {
+    for window in windows.windows.values_mut() {
+        let window_surfaces = window_surfaces.deref_mut();
+        let Some(surface_data) = window_surfaces.surfaces.get(&window.entity) else {
+            continue;
+        };
+
+        // A recurring issue is hitting `wgpu::SurfaceError::Timeout` on certain Linux
+        // mesa driver implementations. This seems to be a quirk of some drivers.
+        // We'd rather keep panicking when not on Linux mesa, because in those case,
+        // the `Timeout` is still probably the symptom of a degraded unrecoverable
+        // application state.
+        // see https://github.com/bevyengine/bevy/pull/5957
+        // and https://github.com/gfx-rs/wgpu/issues/1218
+        #[cfg(target_os = "linux")]
+        let may_erroneously_timeout = || {
+            render_instance
+                .enumerate_adapters(wgpu::Backends::VULKAN)
+                .iter()
+                .any(|adapter| {
+                    let name = adapter.get_info().name;
+                    name.starts_with("Radeon")
+                        || name.starts_with("AMD")
+                        || name.starts_with("Intel")
+                })
+        };
+
+        let surface = &surface_data.surface;
+        match surface.get_current_texture() {
+            Ok(frame) => {
+                window.set_swapchain_texture(frame);
+            }
+            Err(wgpu::SurfaceError::Outdated) => {
+                render_device.configure_surface(surface, &surface_data.configuration);
+                let frame = match surface.get_current_texture() {
+                    Ok(frame) => frame,
+                    Err(err) => {
+                        // This is a common occurrence on X11 and Xwayland with NVIDIA drivers
+                        // when opening and resizing the window.
+                        warn!("Couldn't get swap chain texture after configuring. Cause: '{err}'");
+                        continue;
+                    }
+                };
+                window.set_swapchain_texture(frame);
+            }
+            #[cfg(target_os = "linux")]
+            Err(wgpu::SurfaceError::Timeout) if may_erroneously_timeout() => {
+                tracing::trace!(
+                    "Couldn't get swap chain texture. This is probably a quirk \
+                        of your Linux GPU driver, so it can be safely ignored."
+                );
+            }
+            Err(err) => {
+                panic!("Couldn't get swap chain texture, operation unrecoverable: {err}");
+            }
+        }
+        window.swap_chain_texture_format = Some(surface_data.configuration.format);
+    }
+}
+
+pub fn need_surface_configuration(
+    windows: Res<ExtractedWindows>,
+    window_surfaces: Res<WindowSurfaces>,
+) -> bool {
+    for window in windows.windows.values() {
+        if !window_surfaces.configured_windows.contains(&window.entity)
+            || window.size_changed
+            || window.present_mode_changed
+        {
+            return true;
+        }
+    }
+    false
+}
+
+// 2 is wgpu's default/what we've been using so far.
+// 1 is the minimum, but may cause lower framerates due to the cpu waiting for the gpu to finish
+// all work for the previous frame before starting work on the next frame, which then means the gpu
+// has to wait for the cpu to finish to start on the next frame.
+const DEFAULT_DESIRED_MAXIMUM_FRAME_LATENCY: u32 = 2;
+
+/// Creates window surfaces.
+pub fn create_surfaces(
+    // By accessing a NonSend resource, we tell the scheduler to put this system on the main thread,
+    // which is necessary for some OS's
+    #[cfg(any(target_os = "macos", target_os = "ios"))] _marker: Option<
+        NonSend<bevy_app::NonSendMarker>,
+    >,
+    windows: Res<ExtractedWindows>,
+    mut window_surfaces: ResMut<WindowSurfaces>,
+    render_instance: Res<RenderInstance>,
+    render_adapter: Res<RenderAdapter>,
+    render_device: Res<RenderDevice>,
+) {
+    for window in windows.windows.values() {
+        let data = window_surfaces
+            .surfaces
+            .entry(window.entity)
+            .or_insert_with(|| {
+                let surface_target = SurfaceTargetUnsafe::RawHandle {
+                    raw_display_handle: window.handle.get_display_handle(),
+                    raw_window_handle: window.handle.get_window_handle(),
+                };
+                // SAFETY: The window handles in ExtractedWindows will always be valid objects to create surfaces on
+                let surface = unsafe {
+                    // NOTE: On some OSes this MUST be called from the main thread.
+                    // As of wgpu 0.15, only fallible if the given window is a HTML canvas and obtaining a WebGPU or WebGL2 context fails.
+                    render_instance
+                        .create_surface_unsafe(surface_target)
+                        .expect("Failed to create wgpu surface")
+                };
+                let caps = surface.get_capabilities(&render_adapter);
+                let formats = caps.formats;
+                // For future HDR output support, we'll need to request a format that supports HDR,
+                // but as of wgpu 0.15 that is not yet supported.
+                // Prefer sRGB formats for surfaces, but fall back to first available format if no sRGB formats are available.
+                let mut format = *formats.first().expect("No supported formats for surface");
+                for available_format in formats {
+                    // Rgba8UnormSrgb and Bgra8UnormSrgb and the only sRGB formats wgpu exposes that we can use for surfaces.
+                    if available_format == TextureFormat::Rgba8UnormSrgb
+                        || available_format == TextureFormat::Bgra8UnormSrgb
+                    {
+                        format = available_format;
+                        break;
+                    }
+                }
+
+                let configuration = SurfaceConfiguration {
+                    format,
+                    width: window.physical_width,
+                    height: window.physical_height,
+                    usage: TextureUsages::RENDER_ATTACHMENT,
+                    present_mode: match window.present_mode {
+                        PresentMode::Fifo => wgpu::PresentMode::Fifo,
+                        PresentMode::FifoRelaxed => wgpu::PresentMode::FifoRelaxed,
+                        PresentMode::Mailbox => wgpu::PresentMode::Mailbox,
+                        PresentMode::Immediate => wgpu::PresentMode::Immediate,
+                        PresentMode::AutoVsync => wgpu::PresentMode::AutoVsync,
+                        PresentMode::AutoNoVsync => wgpu::PresentMode::AutoNoVsync,
+                    },
+                    desired_maximum_frame_latency: window
+                        .desired_maximum_frame_latency
+                        .map(NonZero::<u32>::get)
+                        .unwrap_or(DEFAULT_DESIRED_MAXIMUM_FRAME_LATENCY),
+                    alpha_mode: match window.alpha_mode {
+                        CompositeAlphaMode::Auto => wgpu::CompositeAlphaMode::Auto,
+                        CompositeAlphaMode::Opaque => wgpu::CompositeAlphaMode::Opaque,
+                        CompositeAlphaMode::PreMultiplied => {
+                            wgpu::CompositeAlphaMode::PreMultiplied
+                        }
+                        CompositeAlphaMode::PostMultiplied => {
+                            wgpu::CompositeAlphaMode::PostMultiplied
+                        }
+                        CompositeAlphaMode::Inherit => wgpu::CompositeAlphaMode::Inherit,
+                    },
+                    view_formats: if !format.is_srgb() {
+                        vec![format.add_srgb_suffix()]
+                    } else {
+                        vec![]
+                    },
+                };
+
+                render_device.configure_surface(&surface, &configuration);
+
+                SurfaceData {
+                    surface: WgpuWrapper::new(surface),
+                    configuration,
+                }
+            });
+
+        if window.size_changed || window.present_mode_changed {
+            data.configuration.width = window.physical_width;
+            data.configuration.height = window.physical_height;
+            data.configuration.present_mode = match window.present_mode {
+                PresentMode::Fifo => wgpu::PresentMode::Fifo,
+                PresentMode::FifoRelaxed => wgpu::PresentMode::FifoRelaxed,
+                PresentMode::Mailbox => wgpu::PresentMode::Mailbox,
+                PresentMode::Immediate => wgpu::PresentMode::Immediate,
+                PresentMode::AutoVsync => wgpu::PresentMode::AutoVsync,
+                PresentMode::AutoNoVsync => wgpu::PresentMode::AutoNoVsync,
+            };
+            render_device.configure_surface(&data.surface, &data.configuration);
+        }
+
+        window_surfaces.configured_windows.insert(window.entity);
+    }
+}

vendor/bevy_render/src/view/window/screenshot.rs

@@ -0,0 +1,695 @@
+use super::ExtractedWindows;
+use crate::{
+    camera::{ManualTextureViewHandle, ManualTextureViews, NormalizedRenderTarget, RenderTarget},
+    gpu_readback,
+    prelude::Shader,
+    render_asset::{RenderAssetUsages, RenderAssets},
+    render_resource::{
+        binding_types::texture_2d, BindGroup, BindGroupEntries, BindGroupLayout,
+        BindGroupLayoutEntries, Buffer, BufferUsages, CachedRenderPipelineId, FragmentState,
+        PipelineCache, RenderPipelineDescriptor, SpecializedRenderPipeline,
+        SpecializedRenderPipelines, Texture, TextureUsages, TextureView, VertexState,
+    },
+    renderer::RenderDevice,
+    texture::{GpuImage, OutputColorAttachment},
+    view::{prepare_view_attachments, prepare_view_targets, ViewTargetAttachments, WindowSurfaces},
+    ExtractSchedule, MainWorld, Render, RenderApp, RenderSet,
+};
+use alloc::{borrow::Cow, sync::Arc};
+use bevy_app::{First, Plugin, Update};
+use bevy_asset::{load_internal_asset, weak_handle, Handle};
+use bevy_derive::{Deref, DerefMut};
+use bevy_ecs::{
+    entity::EntityHashMap, event::event_update_system, prelude::*, system::SystemState,
+};
+use bevy_image::{Image, TextureFormatPixelInfo};
+use bevy_platform::collections::HashSet;
+use bevy_reflect::Reflect;
+use bevy_tasks::AsyncComputeTaskPool;
+use bevy_utils::default;
+use bevy_window::{PrimaryWindow, WindowRef};
+use core::ops::Deref;
+use std::{
+    path::Path,
+    sync::{
+        mpsc::{Receiver, Sender},
+        Mutex,
+    },
+};
+use tracing::{error, info, warn};
+use wgpu::{CommandEncoder, Extent3d, TextureFormat};
+
+#[derive(Event, Deref, DerefMut, Reflect, Debug)]
+#[reflect(Debug)]
+pub struct ScreenshotCaptured(pub Image);
+
+/// A component that signals to the renderer to capture a screenshot this frame.
+///
+/// This component should be spawned on a new entity with an observer that will trigger
+/// with [`ScreenshotCaptured`] when the screenshot is ready.
+///
+/// Screenshots are captured asynchronously and may not be available immediately after the frame
+/// that the component is spawned on. The observer should be used to handle the screenshot when it
+/// is ready.
+///
+/// Note that the screenshot entity will be despawned after the screenshot is captured and the
+/// observer is triggered.
+///
+/// # Usage
+///
+/// ```
+/// # use bevy_ecs::prelude::*;
+/// # use bevy_render::view::screenshot::{save_to_disk, Screenshot};
+///
+/// fn take_screenshot(mut commands: Commands) {
+///    commands.spawn(Screenshot::primary_window())
+///       .observe(save_to_disk("screenshot.png"));
+/// }
+/// ```
+#[derive(Component, Deref, DerefMut, Reflect, Debug)]
+#[reflect(Component, Debug)]
+pub struct Screenshot(pub RenderTarget);
+
+/// A marker component that indicates that a screenshot is currently being captured.
+#[derive(Component, Default)]
+pub struct Capturing;
+
+/// A marker component that indicates that a screenshot has been captured, the image is ready, and
+/// the screenshot entity can be despawned.
+#[derive(Component, Default)]
+pub struct Captured;
+
+impl Screenshot {
+    /// Capture a screenshot of the provided window entity.
+    pub fn window(window: Entity) -> Self {
+        Self(RenderTarget::Window(WindowRef::Entity(window)))
+    }
+
+    /// Capture a screenshot of the primary window, if one exists.
+    pub fn primary_window() -> Self {
+        Self(RenderTarget::Window(WindowRef::Primary))
+    }
+
+    /// Capture a screenshot of the provided render target image.
+    pub fn image(image: Handle<Image>) -> Self {
+        Self(RenderTarget::Image(image.into()))
+    }
+
+    /// Capture a screenshot of the provided manual texture view.
+    pub fn texture_view(texture_view: ManualTextureViewHandle) -> Self {
+        Self(RenderTarget::TextureView(texture_view))
+    }
+}
+
+struct ScreenshotPreparedState {
+    pub texture: Texture,
+    pub buffer: Buffer,
+    pub bind_group: BindGroup,
+    pub pipeline_id: CachedRenderPipelineId,
+    pub size: Extent3d,
+}
+
+#[derive(Resource, Deref, DerefMut)]
+pub struct CapturedScreenshots(pub Arc<Mutex<Receiver<(Entity, Image)>>>);
+
+#[derive(Resource, Deref, DerefMut, Default)]
+struct RenderScreenshotTargets(EntityHashMap<NormalizedRenderTarget>);
+
+#[derive(Resource, Deref, DerefMut, Default)]
+struct RenderScreenshotsPrepared(EntityHashMap<ScreenshotPreparedState>);
+
+#[derive(Resource, Deref, DerefMut)]
+struct RenderScreenshotsSender(Sender<(Entity, Image)>);
+
+/// Saves the captured screenshot to disk at the provided path.
+pub fn save_to_disk(path: impl AsRef<Path>) -> impl FnMut(Trigger<ScreenshotCaptured>) {
+    let path = path.as_ref().to_owned();
+    move |trigger| {
+        let img = trigger.event().deref().clone();
+        match img.try_into_dynamic() {
+            Ok(dyn_img) => match image::ImageFormat::from_path(&path) {
+                Ok(format) => {
+                    // discard the alpha channel which stores brightness values when HDR is enabled to make sure
+                    // the screenshot looks right
+                    let img = dyn_img.to_rgb8();
+                    #[cfg(not(target_arch = "wasm32"))]
+                    match img.save_with_format(&path, format) {
+                        Ok(_) => info!("Screenshot saved to {}", path.display()),
+                        Err(e) => error!("Cannot save screenshot, IO error: {e}"),
+                    }
+
+                    #[cfg(target_arch = "wasm32")]
+                    {
+                        let save_screenshot = || {
+                            use image::EncodableLayout;
+                            use wasm_bindgen::{JsCast, JsValue};
+
+                            let mut image_buffer = std::io::Cursor::new(Vec::new());
+                            img.write_to(&mut image_buffer, format)
+                                .map_err(|e| JsValue::from_str(&format!("{e}")))?;
+                            // SAFETY: `image_buffer` only exist in this closure, and is not used after this line
+                            let parts = js_sys::Array::of1(&unsafe {
+                                js_sys::Uint8Array::view(image_buffer.into_inner().as_bytes())
+                                    .into()
+                            });
+                            let blob = web_sys::Blob::new_with_u8_array_sequence(&parts)?;
+                            let url = web_sys::Url::create_object_url_with_blob(&blob)?;
+                            let window = web_sys::window().unwrap();
+                            let document = window.document().unwrap();
+                            let link = document.create_element("a")?;
+                            link.set_attribute("href", &url)?;
+                            link.set_attribute(
+                                "download",
+                                path.file_name()
+                                    .and_then(|filename| filename.to_str())
+                                    .ok_or_else(|| JsValue::from_str("Invalid filename"))?,
+                            )?;
+                            let html_element = link.dyn_into::<web_sys::HtmlElement>()?;
+                            html_element.click();
+                            web_sys::Url::revoke_object_url(&url)?;
+                            Ok::<(), JsValue>(())
+                        };
+
+                        match (save_screenshot)() {
+                            Ok(_) => info!("Screenshot saved to {}", path.display()),
+                            Err(e) => error!("Cannot save screenshot, error: {e:?}"),
+                        };
+                    }
+                }
+                Err(e) => error!("Cannot save screenshot, requested format not recognized: {e}"),
+            },
+            Err(e) => error!("Cannot save screenshot, screen format cannot be understood: {e}"),
+        }
+    }
+}
+
+fn clear_screenshots(mut commands: Commands, screenshots: Query<Entity, With<Captured>>) {
+    for entity in screenshots.iter() {
+        commands.entity(entity).despawn();
+    }
+}
+
+pub fn trigger_screenshots(
+    mut commands: Commands,
+    captured_screenshots: ResMut<CapturedScreenshots>,
+) {
+    let captured_screenshots = captured_screenshots.lock().unwrap();
+    while let Ok((entity, image)) = captured_screenshots.try_recv() {
+        commands.entity(entity).insert(Captured);
+        commands.trigger_targets(ScreenshotCaptured(image), entity);
+    }
+}
+
+fn extract_screenshots(
+    mut targets: ResMut<RenderScreenshotTargets>,
+    mut main_world: ResMut<MainWorld>,
+    mut system_state: Local<
+        Option<
+            SystemState<(
+                Commands,
+                Query<Entity, With<PrimaryWindow>>,
+                Query<(Entity, &Screenshot), Without<Capturing>>,
+            )>,
+        >,
+    >,
+    mut seen_targets: Local<HashSet<NormalizedRenderTarget>>,
+) {
+    if system_state.is_none() {
+        *system_state = Some(SystemState::new(&mut main_world));
+    }
+    let system_state = system_state.as_mut().unwrap();
+    let (mut commands, primary_window, screenshots) = system_state.get_mut(&mut main_world);
+
+    targets.clear();
+    seen_targets.clear();
+
+    let primary_window = primary_window.iter().next();
+
+    for (entity, screenshot) in screenshots.iter() {
+        let render_target = screenshot.0.clone();
+        let Some(render_target) = render_target.normalize(primary_window) else {
+            warn!(
+                "Unknown render target for screenshot, skipping: {:?}",
+                render_target
+            );
+            continue;
+        };
+        if seen_targets.contains(&render_target) {
+            warn!(
+                "Duplicate render target for screenshot, skipping entity {}: {:?}",
+                entity, render_target
+            );
+            // If we don't despawn the entity here, it will be captured again in the next frame
+            commands.entity(entity).despawn();
+            continue;
+        }
+        seen_targets.insert(render_target.clone());
+        targets.insert(entity, render_target);
+        commands.entity(entity).insert(Capturing);
+    }
+
+    system_state.apply(&mut main_world);
+}
+
+fn prepare_screenshots(
+    targets: Res<RenderScreenshotTargets>,
+    mut prepared: ResMut<RenderScreenshotsPrepared>,
+    window_surfaces: Res<WindowSurfaces>,
+    render_device: Res<RenderDevice>,
+    screenshot_pipeline: Res<ScreenshotToScreenPipeline>,
+    pipeline_cache: Res<PipelineCache>,
+    mut pipelines: ResMut<SpecializedRenderPipelines<ScreenshotToScreenPipeline>>,
+    images: Res<RenderAssets<GpuImage>>,
+    manual_texture_views: Res<ManualTextureViews>,
+    mut view_target_attachments: ResMut<ViewTargetAttachments>,
+) {
+    prepared.clear();
+    for (entity, target) in targets.iter() {
+        match target {
+            NormalizedRenderTarget::Window(window) => {
+                let window = window.entity();
+                let Some(surface_data) = window_surfaces.surfaces.get(&window) else {
+                    warn!("Unknown window for screenshot, skipping: {}", window);
+                    continue;
+                };
+                let format = surface_data.configuration.format.add_srgb_suffix();
+                let size = Extent3d {
+                    width: surface_data.configuration.width,
+                    height: surface_data.configuration.height,
+                    ..default()
+                };
+                let (texture_view, state) = prepare_screenshot_state(
+                    size,
+                    format,
+                    &render_device,
+                    &screenshot_pipeline,
+                    &pipeline_cache,
+                    &mut pipelines,
+                );
+                prepared.insert(*entity, state);
+                view_target_attachments.insert(
+                    target.clone(),
+                    OutputColorAttachment::new(texture_view.clone(), format.add_srgb_suffix()),
+                );
+            }
+            NormalizedRenderTarget::Image(image) => {
+                let Some(gpu_image) = images.get(&image.handle) else {
+                    warn!("Unknown image for screenshot, skipping: {:?}", image);
+                    continue;
+                };
+                let format = gpu_image.texture_format;
+                let (texture_view, state) = prepare_screenshot_state(
+                    gpu_image.size,
+                    format,
+                    &render_device,
+                    &screenshot_pipeline,
+                    &pipeline_cache,
+                    &mut pipelines,
+                );
+                prepared.insert(*entity, state);
+                view_target_attachments.insert(
+                    target.clone(),
+                    OutputColorAttachment::new(texture_view.clone(), format.add_srgb_suffix()),
+                );
+            }
+            NormalizedRenderTarget::TextureView(texture_view) => {
+                let Some(manual_texture_view) = manual_texture_views.get(texture_view) else {
+                    warn!(
+                        "Unknown manual texture view for screenshot, skipping: {:?}",
+                        texture_view
+                    );
+                    continue;
+                };
+                let format = manual_texture_view.format;
+                let size = Extent3d {
+                    width: manual_texture_view.size.x,
+                    height: manual_texture_view.size.y,
+                    ..default()
+                };
+                let (texture_view, state) = prepare_screenshot_state(
+                    size,
+                    format,
+                    &render_device,
+                    &screenshot_pipeline,
+                    &pipeline_cache,
+                    &mut pipelines,
+                );
+                prepared.insert(*entity, state);
+                view_target_attachments.insert(
+                    target.clone(),
+                    OutputColorAttachment::new(texture_view.clone(), format.add_srgb_suffix()),
+                );
+            }
+        }
+    }
+}
+
+fn prepare_screenshot_state(
+    size: Extent3d,
+    format: TextureFormat,
+    render_device: &RenderDevice,
+    pipeline: &ScreenshotToScreenPipeline,
+    pipeline_cache: &PipelineCache,
+    pipelines: &mut SpecializedRenderPipelines<ScreenshotToScreenPipeline>,
+) -> (TextureView, ScreenshotPreparedState) {
+    let texture = render_device.create_texture(&wgpu::TextureDescriptor {
+        label: Some("screenshot-capture-rendertarget"),
+        size,
+        mip_level_count: 1,
+        sample_count: 1,
+        dimension: wgpu::TextureDimension::D2,
+        format,
+        usage: TextureUsages::RENDER_ATTACHMENT
+            | TextureUsages::COPY_SRC
+            | TextureUsages::TEXTURE_BINDING,
+        view_formats: &[],
+    });
+    let texture_view = texture.create_view(&Default::default());
+    let buffer = render_device.create_buffer(&wgpu::BufferDescriptor {
+        label: Some("screenshot-transfer-buffer"),
+        size: gpu_readback::get_aligned_size(size, format.pixel_size() as u32) as u64,
+        usage: BufferUsages::MAP_READ | BufferUsages::COPY_DST,
+        mapped_at_creation: false,
+    });
+    let bind_group = render_device.create_bind_group(
+        "screenshot-to-screen-bind-group",
+        &pipeline.bind_group_layout,
+        &BindGroupEntries::single(&texture_view),
+    );
+    let pipeline_id = pipelines.specialize(pipeline_cache, pipeline, format);
+
+    (
+        texture_view,
+        ScreenshotPreparedState {
+            texture,
+            buffer,
+            bind_group,
+            pipeline_id,
+            size,
+        },
+    )
+}
+
+pub struct ScreenshotPlugin;
+
+const SCREENSHOT_SHADER_HANDLE: Handle<Shader> =
+    weak_handle!("c31753d6-326a-47cb-a359-65c97a471fda");
+
+impl Plugin for ScreenshotPlugin {
+    fn build(&self, app: &mut bevy_app::App) {
+        app.add_systems(
+            First,
+            clear_screenshots
+                .after(event_update_system)
+                .before(ApplyDeferred),
+        )
+        .register_type::<Screenshot>()
+        .register_type::<ScreenshotCaptured>();
+
+        load_internal_asset!(
+            app,
+            SCREENSHOT_SHADER_HANDLE,
+            "screenshot.wgsl",
+            Shader::from_wgsl
+        );
+    }
+
+    fn finish(&self, app: &mut bevy_app::App) {
+        let (tx, rx) = std::sync::mpsc::channel();
+        app.add_systems(Update, trigger_screenshots)
+            .insert_resource(CapturedScreenshots(Arc::new(Mutex::new(rx))));
+
+        if let Some(render_app) = app.get_sub_app_mut(RenderApp) {
+            render_app
+                .insert_resource(RenderScreenshotsSender(tx))
+                .init_resource::<RenderScreenshotTargets>()
+                .init_resource::<RenderScreenshotsPrepared>()
+                .init_resource::<SpecializedRenderPipelines<ScreenshotToScreenPipeline>>()
+                .add_systems(ExtractSchedule, extract_screenshots.ambiguous_with_all())
+                .add_systems(
+                    Render,
+                    prepare_screenshots
+                        .after(prepare_view_attachments)
+                        .before(prepare_view_targets)
+                        .in_set(RenderSet::ManageViews),
+                );
+        }
+    }
+}
+
+#[derive(Resource)]
+pub struct ScreenshotToScreenPipeline {
+    pub bind_group_layout: BindGroupLayout,
+}
+
+impl FromWorld for ScreenshotToScreenPipeline {
+    fn from_world(render_world: &mut World) -> Self {
+        let device = render_world.resource::<RenderDevice>();
+
+        let bind_group_layout = device.create_bind_group_layout(
+            "screenshot-to-screen-bgl",
+            &BindGroupLayoutEntries::single(
+                wgpu::ShaderStages::FRAGMENT,
+                texture_2d(wgpu::TextureSampleType::Float { filterable: false }),
+            ),
+        );
+
+        Self { bind_group_layout }
+    }
+}
+
+impl SpecializedRenderPipeline for ScreenshotToScreenPipeline {
+    type Key = TextureFormat;
+
+    fn specialize(&self, key: Self::Key) -> RenderPipelineDescriptor {
+        RenderPipelineDescriptor {
+            label: Some(Cow::Borrowed("screenshot-to-screen")),
+            layout: vec![self.bind_group_layout.clone()],
+            vertex: VertexState {
+                buffers: vec![],
+                shader_defs: vec![],
+                entry_point: Cow::Borrowed("vs_main"),
+                shader: SCREENSHOT_SHADER_HANDLE,
+            },
+            primitive: wgpu::PrimitiveState {
+                cull_mode: Some(wgpu::Face::Back),
+                ..Default::default()
+            },
+            depth_stencil: None,
+            multisample: Default::default(),
+            fragment: Some(FragmentState {
+                shader: SCREENSHOT_SHADER_HANDLE,
+                entry_point: Cow::Borrowed("fs_main"),
+                shader_defs: vec![],
+                targets: vec![Some(wgpu::ColorTargetState {
+                    format: key,
+                    blend: None,
+                    write_mask: wgpu::ColorWrites::ALL,
+                })],
+            }),
+            push_constant_ranges: Vec::new(),
+            zero_initialize_workgroup_memory: false,
+        }
+    }
+}
+
+pub(crate) fn submit_screenshot_commands(world: &World, encoder: &mut CommandEncoder) {
+    let targets = world.resource::<RenderScreenshotTargets>();
+    let prepared = world.resource::<RenderScreenshotsPrepared>();
+    let pipelines = world.resource::<PipelineCache>();
+    let gpu_images = world.resource::<RenderAssets<GpuImage>>();
+    let windows = world.resource::<ExtractedWindows>();
+    let manual_texture_views = world.resource::<ManualTextureViews>();
+
+    for (entity, render_target) in targets.iter() {
+        match render_target {
+            NormalizedRenderTarget::Window(window) => {
+                let window = window.entity();
+                let Some(window) = windows.get(&window) else {
+                    continue;
+                };
+                let width = window.physical_width;
+                let height = window.physical_height;
+                let Some(texture_format) = window.swap_chain_texture_format else {
+                    continue;
+                };
+                let Some(swap_chain_texture) = window.swap_chain_texture.as_ref() else {
+                    continue;
+                };
+                let texture_view = swap_chain_texture.texture.create_view(&Default::default());
+                render_screenshot(
+                    encoder,
+                    prepared,
+                    pipelines,
+                    entity,
+                    width,
+                    height,
+                    texture_format,
+                    &texture_view,
+                );
+            }
+            NormalizedRenderTarget::Image(image) => {
+                let Some(gpu_image) = gpu_images.get(&image.handle) else {
+                    warn!("Unknown image for screenshot, skipping: {:?}", image);
+                    continue;
+                };
+                let width = gpu_image.size.width;
+                let height = gpu_image.size.height;
+                let texture_format = gpu_image.texture_format;
+                let texture_view = gpu_image.texture_view.deref();
+                render_screenshot(
+                    encoder,
+                    prepared,
+                    pipelines,
+                    entity,
+                    width,
+                    height,
+                    texture_format,
+                    texture_view,
+                );
+            }
+            NormalizedRenderTarget::TextureView(texture_view) => {
+                let Some(texture_view) = manual_texture_views.get(texture_view) else {
+                    warn!(
+                        "Unknown manual texture view for screenshot, skipping: {:?}",
+                        texture_view
+                    );
+                    continue;
+                };
+                let width = texture_view.size.x;
+                let height = texture_view.size.y;
+                let texture_format = texture_view.format;
+                let texture_view = texture_view.texture_view.deref();
+                render_screenshot(
+                    encoder,
+                    prepared,
+                    pipelines,
+                    entity,
+                    width,
+                    height,
+                    texture_format,
+                    texture_view,
+                );
+            }
+        };
+    }
+}
+
+fn render_screenshot(
+    encoder: &mut CommandEncoder,
+    prepared: &RenderScreenshotsPrepared,
+    pipelines: &PipelineCache,
+    entity: &Entity,
+    width: u32,
+    height: u32,
+    texture_format: TextureFormat,
+    texture_view: &wgpu::TextureView,
+) {
+    if let Some(prepared_state) = &prepared.get(entity) {
+        let extent = Extent3d {
+            width,
+            height,
+            depth_or_array_layers: 1,
+        };
+        encoder.copy_texture_to_buffer(
+            prepared_state.texture.as_image_copy(),
+            wgpu::TexelCopyBufferInfo {
+                buffer: &prepared_state.buffer,
+                layout: gpu_readback::layout_data(extent, texture_format),
+            },
+            extent,
+        );
+
+        if let Some(pipeline) = pipelines.get_render_pipeline(prepared_state.pipeline_id) {
+            let mut pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
+                label: Some("screenshot_to_screen_pass"),
+                color_attachments: &[Some(wgpu::RenderPassColorAttachment {
+                    view: texture_view,
+                    resolve_target: None,
+                    ops: wgpu::Operations {
+                        load: wgpu::LoadOp::Load,
+                        store: wgpu::StoreOp::Store,
+                    },
+                })],
+                depth_stencil_attachment: None,
+                timestamp_writes: None,
+                occlusion_query_set: None,
+            });
+            pass.set_pipeline(pipeline);
+            pass.set_bind_group(0, &prepared_state.bind_group, &[]);
+            pass.draw(0..3, 0..1);
+        }
+    }
+}
+
+pub(crate) fn collect_screenshots(world: &mut World) {
+    #[cfg(feature = "trace")]
+    let _span = tracing::info_span!("collect_screenshots").entered();
+
+    let sender = world.resource::<RenderScreenshotsSender>().deref().clone();
+    let prepared = world.resource::<RenderScreenshotsPrepared>();
+
+    for (entity, prepared) in prepared.iter() {
+        let entity = *entity;
+        let sender = sender.clone();
+        let width = prepared.size.width;
+        let height = prepared.size.height;
+        let texture_format = prepared.texture.format();
+        let pixel_size = texture_format.pixel_size();
+        let buffer = prepared.buffer.clone();
+
+        let finish = async move {
+            let (tx, rx) = async_channel::bounded(1);
+            let buffer_slice = buffer.slice(..);
+            // The polling for this map call is done every frame when the command queue is submitted.
+            buffer_slice.map_async(wgpu::MapMode::Read, move |result| {
+                let err = result.err();
+                if err.is_some() {
+                    panic!("{}", err.unwrap().to_string());
+                }
+                tx.try_send(()).unwrap();
+            });
+            rx.recv().await.unwrap();
+            let data = buffer_slice.get_mapped_range();
+            // we immediately move the data to CPU memory to avoid holding the mapped view for long
+            let mut result = Vec::from(&*data);
+            drop(data);
+
+            if result.len() != ((width * height) as usize * pixel_size) {
+                // Our buffer has been padded because we needed to align to a multiple of 256.
+                // We remove this padding here
+                let initial_row_bytes = width as usize * pixel_size;
+                let buffered_row_bytes =
+                    gpu_readback::align_byte_size(width * pixel_size as u32) as usize;
+
+                let mut take_offset = buffered_row_bytes;
+                let mut place_offset = initial_row_bytes;
+                for _ in 1..height {
+                    result.copy_within(take_offset..take_offset + buffered_row_bytes, place_offset);
+                    take_offset += buffered_row_bytes;
+                    place_offset += initial_row_bytes;
+                }
+                result.truncate(initial_row_bytes * height as usize);
+            }
+
+            if let Err(e) = sender.send((
+                entity,
+                Image::new(
+                    Extent3d {
+                        width,
+                        height,
+                        depth_or_array_layers: 1,
+                    },
+                    wgpu::TextureDimension::D2,
+                    result,
+                    texture_format,
+                    RenderAssetUsages::RENDER_WORLD,
+                ),
+            )) {
+                error!("Failed to send screenshot: {}", e);
+            }
+        };
+
+        AsyncComputeTaskPool::get().spawn(finish).detach();
+    }
+}

vendor/bevy_render/src/view/window/screenshot.wgsl

@@ -0,0 +1,16 @@
+// This vertex shader will create a triangle that will cover the entire screen
+// with minimal effort, avoiding the need for a vertex buffer etc.
+@vertex
+fn vs_main(@builtin(vertex_index) in_vertex_index: u32) -> @builtin(position) vec4<f32> {
+    let x = f32((in_vertex_index & 1u) << 2u);
+    let y = f32((in_vertex_index & 2u) << 1u);
+    return vec4<f32>(x - 1.0, y - 1.0, 0.0, 1.0);
+}
+
+@group(0) @binding(0) var t: texture_2d<f32>;
+
+@fragment
+fn fs_main(@builtin(position) pos: vec4<f32>) -> @location(0) vec4<f32> {
+    let coords = floor(pos.xy);
+    return textureLoad(t, vec2<i32>(coords), 0i);
+}