[Merged by Bors] - Add 2d meshes and materials

Cargo.toml

@@ -116,6 +116,14 @@ path = "examples/2d/contributors.rs"
 name = "many_sprites"
 path = "examples/2d/many_sprites.rs"
 
+[[example]]
+name = "mesh2d"
+path = "examples/2d/mesh2d.rs"
+
+[[example]]
+name = "mesh2d_manual"
+path = "examples/2d/mesh2d_manual.rs"
+
 [[example]]
 name = "rect"
 path = "examples/2d/rect.rs"

crates/bevy_core_pipeline/src/lib.rs

@@ -15,6 +15,8 @@ pub use main_pass_2d::*;
 pub use main_pass_3d::*;
 pub use main_pass_driver::*;
 
+use std::ops::Range;
+
 use bevy_app::{App, Plugin};
 use bevy_core::FloatOrd;
 use bevy_ecs::prelude::*;
@@ -23,8 +25,8 @@ use bevy_render::{
     color::Color,
     render_graph::{EmptyNode, RenderGraph, SlotInfo, SlotType},
     render_phase::{
-        sort_phase_system, CachedPipelinePhaseItem, DrawFunctionId, DrawFunctions, EntityPhaseItem,
-        PhaseItem, RenderPhase,
+        batch_phase_system, sort_phase_system, BatchedPhaseItem, CachedPipelinePhaseItem,
+        DrawFunctionId, DrawFunctions, EntityPhaseItem, PhaseItem, RenderPhase,
     },
     render_resource::*,
     renderer::RenderDevice,
@@ -84,6 +86,11 @@ pub mod clear_graph {
 #[derive(Default)]
 pub struct CorePipelinePlugin;
 
+#[derive(Debug, Hash, PartialEq, Eq, Clone, SystemLabel)]
+pub enum CorePipelineRenderSystems {
+    SortTransparent2d,
+}
+
 impl Plugin for CorePipelinePlugin {
     fn build(&self, app: &mut App) {
         app.init_resource::<ClearColor>();
@@ -97,7 +104,16 @@ impl Plugin for CorePipelinePlugin {
             .add_system_to_stage(RenderStage::Extract, extract_clear_color)
             .add_system_to_stage(RenderStage::Extract, extract_core_pipeline_camera_phases)
             .add_system_to_stage(RenderStage::Prepare, prepare_core_views_system)
-            .add_system_to_stage(RenderStage::PhaseSort, sort_phase_system::<Transparent2d>)
+            .add_system_to_stage(
+                RenderStage::PhaseSort,
+                sort_phase_system::<Transparent2d>
+                    .label(CorePipelineRenderSystems::SortTransparent2d),
+            )
+            .add_system_to_stage(
+                RenderStage::PhaseSort,
+                batch_phase_system::<Transparent2d>
+                    .after(CorePipelineRenderSystems::SortTransparent2d),
+            )
             .add_system_to_stage(RenderStage::PhaseSort, sort_phase_system::<Opaque3d>)
             .add_system_to_stage(RenderStage::PhaseSort, sort_phase_system::<AlphaMask3d>)
             .add_system_to_stage(RenderStage::PhaseSort, sort_phase_system::<Transparent3d>);
@@ -160,6 +176,8 @@ pub struct Transparent2d {
     pub entity: Entity,
     pub pipeline: CachedPipelineId,
     pub draw_function: DrawFunctionId,
+    /// Range in the vertex buffer of this item
+    pub batch_range: Option<Range<u32>>,
 }
 
 impl PhaseItem for Transparent2d {
@@ -176,6 +194,30 @@ impl PhaseItem for Transparent2d {
     }
 }
 
+impl EntityPhaseItem for Transparent2d {
+    #[inline]
+    fn entity(&self) -> Entity {
+        self.entity
+    }
+}
+
+impl CachedPipelinePhaseItem for Transparent2d {
+    #[inline]
+    fn cached_pipeline(&self) -> CachedPipelineId {
+        self.pipeline
+    }
+}
+
+impl BatchedPhaseItem for Transparent2d {
+    fn batch_range(&self) -> &Option<Range<u32>> {
+        &self.batch_range
+    }
+
+    fn batch_range_mut(&mut self) -> &mut Option<Range<u32>> {
+        &mut self.batch_range
+    }
+}
+
 pub struct Opaque3d {
     pub distance: f32,
     pub pipeline: CachedPipelineId,

crates/bevy_core_pipeline/src/main_pass_2d.rs

@@ -3,7 +3,7 @@ use bevy_ecs::prelude::*;
 use bevy_render::{
     render_graph::{Node, NodeRunError, RenderGraphContext, SlotInfo, SlotType},
     render_phase::{DrawFunctions, RenderPhase, TrackedRenderPass},
-    render_resource::{LoadOp, Operations, RenderPassColorAttachment, RenderPassDescriptor},
+    render_resource::{LoadOp, Operations, RenderPassDescriptor},
     renderer::RenderContext,
     view::{ExtractedView, ViewTarget},
 };
@@ -46,14 +46,10 @@ impl Node for MainPass2dNode {
 
         let pass_descriptor = RenderPassDescriptor {
             label: Some("main_pass_2d"),
-            color_attachments: &[RenderPassColorAttachment {
-                view: &target.view,
-                resolve_target: None,
-                ops: Operations {
-                    load: LoadOp::Load,
-                    store: true,
-                },
-            }],
+            color_attachments: &[target.get_color_attachment(Operations {
+                load: LoadOp::Load,
+                store: true,
+            })],
             depth_stencil_attachment: None,
         };
 

crates/bevy_pbr/src/render/mesh.rs

@@ -8,7 +8,7 @@ use bevy_ecs::{
     prelude::*,
     system::{lifetimeless::*, SystemParamItem},
 };
-use bevy_math::Mat4;
+use bevy_math::{Mat4, Size};
 use bevy_reflect::TypeUuid;
 use bevy_render::{
     mesh::{GpuBufferInfo, Mesh},
@@ -328,6 +328,10 @@ impl FromWorld for MeshPipeline {
                 texture,
                 texture_view,
                 sampler,
+                size: Size::new(
+                    image.texture_descriptor.size.width as f32,
+                    image.texture_descriptor.size.height as f32,
+                ),
             }
         };
         MeshPipeline {

crates/bevy_render/src/render_phase/draw.rs

@@ -13,7 +13,7 @@ use bevy_ecs::{
 };
 use bevy_utils::HashMap;
 use parking_lot::{RwLock, RwLockReadGuard, RwLockWriteGuard};
-use std::{any::TypeId, fmt::Debug, hash::Hash};
+use std::{any::TypeId, fmt::Debug, hash::Hash, ops::Range};
 
 /// A draw function which is used to draw a specific [`PhaseItem`].
 ///
@@ -166,6 +166,44 @@ pub trait CachedPipelinePhaseItem: PhaseItem {
     fn cached_pipeline(&self) -> CachedPipelineId;
 }
 
+/// A [`PhaseItem`] that can be batched dynamically.
+///
+/// Batching is an optimization that regroups multiple items in the same vertex buffer
+/// to render them in a single draw call.
+pub trait BatchedPhaseItem: EntityPhaseItem {
+    /// Range in the vertex buffer of this item
+    fn batch_range(&self) -> &Option<Range<u32>>;
+
+    /// Range in the vertex buffer of this item
+    fn batch_range_mut(&mut self) -> &mut Option<Range<u32>>;
+
+    /// Batches another item within this item if they are compatible.
+    /// Items can be batched together if they have the same entity, and consecutive ranges.
+    /// If batching is successful, the `other` item should be discarded from the render pass.
+    #[inline]
+    fn add_to_batch(&mut self, other: &Self) -> BatchResult {
+        let self_entity = self.entity();
+        if let (Some(self_batch_range), Some(other_batch_range)) = (
+            self.batch_range_mut().as_mut(),
+            other.batch_range().as_ref(),
+        ) {
+            if self_entity == other.entity() && self_batch_range.end == other_batch_range.start {
+                // If the items are compatible, join their range into `self`
+                self_batch_range.end = other_batch_range.end;
+                return BatchResult::Success;
+            }
+        }
+        BatchResult::IncompatibleItems
+    }
+}
+
+pub enum BatchResult {
+    /// The `other` item was batched into `self`
+    Success,
+    /// `self` and `other` cannot be batched together
+    IncompatibleItems,
+}
+
 impl<P: EntityPhaseItem, E: EntityRenderCommand> RenderCommand<P> for E {
     type Param = E::Param;
 

crates/bevy_render/src/render_phase/mod.rs

@@ -31,9 +31,166 @@ impl<I: PhaseItem> RenderPhase<I> {
     }
 }
 
+impl<I: BatchedPhaseItem> RenderPhase<I> {
+    /// Batches the compatible [`BatchedPhaseItem`]s of this render phase
+    pub fn batch(&mut self) {
+        // TODO: this could be done in-place
+        let mut items = std::mem::take(&mut self.items);
+        let mut items = items.drain(..);
+
+        self.items.reserve(items.len());
+
+        // Start the first batch from the first item
+        if let Some(mut current_batch) = items.next() {
+            // Batch following items until we find an incompatible item
+            for next_item in items {
+                if matches!(
+                    current_batch.add_to_batch(&next_item),
+                    BatchResult::IncompatibleItems
+                ) {
+                    // Store the completed batch, and start a new one from the incompatible item
+                    self.items.push(current_batch);
+                    current_batch = next_item;
+                }
+            }
+            // Store the last batch
+            self.items.push(current_batch);
+        }
+    }
+}
+
 /// This system sorts all [`RenderPhases`](RenderPhase) for the [`PhaseItem`] type.
 pub fn sort_phase_system<I: PhaseItem>(mut render_phases: Query<&mut RenderPhase<I>>) {
     for mut phase in render_phases.iter_mut() {
         phase.sort();
     }
 }
+
+/// This system batches the [`PhaseItem`]s of all [`RenderPhase`]s of this type.
+pub fn batch_phase_system<I: BatchedPhaseItem>(mut render_phases: Query<&mut RenderPhase<I>>) {
+    for mut phase in render_phases.iter_mut() {
+        phase.batch();
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::ops::Range;
+
+    use bevy_ecs::entity::Entity;
+
+    use super::*;
+
+    #[test]
+    fn batching() {
+        #[derive(Debug, PartialEq)]
+        struct TestPhaseItem {
+            entity: Entity,
+            batch_range: Option<Range<u32>>,
+        }
+        impl PhaseItem for TestPhaseItem {
+            type SortKey = ();
+
+            fn sort_key(&self) -> Self::SortKey {}
+
+            fn draw_function(&self) -> DrawFunctionId {
+                unimplemented!();
+            }
+        }
+        impl EntityPhaseItem for TestPhaseItem {
+            fn entity(&self) -> bevy_ecs::entity::Entity {
+                self.entity
+            }
+        }
+        impl BatchedPhaseItem for TestPhaseItem {
+            fn batch_range(&self) -> &Option<std::ops::Range<u32>> {
+                &self.batch_range
+            }
+
+            fn batch_range_mut(&mut self) -> &mut Option<std::ops::Range<u32>> {
+                &mut self.batch_range
+            }
+        }
+        let mut render_phase = RenderPhase::<TestPhaseItem>::default();
+        let items = [
+            TestPhaseItem {
+                entity: Entity::from_raw(0),
+                batch_range: Some(0..5),
+            },
+            // This item should be batched
+            TestPhaseItem {
+                entity: Entity::from_raw(0),
+                batch_range: Some(5..10),
+            },
+            TestPhaseItem {
+                entity: Entity::from_raw(1),
+                batch_range: Some(0..5),
+            },
+            TestPhaseItem {
+                entity: Entity::from_raw(0),
+                batch_range: Some(10..15),
+            },
+            TestPhaseItem {
+                entity: Entity::from_raw(1),
+                batch_range: Some(5..10),
+            },
+            TestPhaseItem {
+                entity: Entity::from_raw(1),
+                batch_range: None,
+            },
+            TestPhaseItem {
+                entity: Entity::from_raw(1),
+                batch_range: Some(10..15),
+            },
+            TestPhaseItem {
+                entity: Entity::from_raw(1),
+                batch_range: Some(20..25),
+            },
+            // This item should be batched
+            TestPhaseItem {
+                entity: Entity::from_raw(1),
+                batch_range: Some(25..30),
+            },
+            // This item should be batched
+            TestPhaseItem {
+                entity: Entity::from_raw(1),
+                batch_range: Some(30..35),
+            },
+        ];
+        for item in items {
+            render_phase.add(item);
+        }
+        render_phase.batch();
+        let items_batched = [
+            TestPhaseItem {
+                entity: Entity::from_raw(0),
+                batch_range: Some(0..10),
+            },
+            TestPhaseItem {
+                entity: Entity::from_raw(1),
+                batch_range: Some(0..5),
+            },
+            TestPhaseItem {
+                entity: Entity::from_raw(0),
+                batch_range: Some(10..15),
+            },
+            TestPhaseItem {
+                entity: Entity::from_raw(1),
+                batch_range: Some(5..10),
+            },
+            TestPhaseItem {
+                entity: Entity::from_raw(1),
+                batch_range: None,
+            },
+            TestPhaseItem {
+                entity: Entity::from_raw(1),
+                batch_range: Some(10..15),
+            },
+            TestPhaseItem {
+                entity: Entity::from_raw(1),
+                batch_range: Some(20..35),
+            },
+        ];
+        assert_eq!(&*render_phase.items, items_batched);
+    }
+}