Render text in 2D scenes

Cargo.toml

@@ -101,6 +101,10 @@ path = "examples/2d/texture_atlas.rs"
 name = "contributors"
 path = "examples/2d/contributors.rs"
 
+[[example]]
+name = "text2d"
+path = "examples/2d/text2d.rs"
+
 [[example]]
 name = "load_gltf"
 path = "examples/3d/load_gltf.rs"

crates/bevy_render/src/render_graph/base.rs

@@ -14,7 +14,7 @@ use bevy_reflect::{Reflect, ReflectComponent};
 use bevy_window::WindowId;
 
 /// A component that indicates that an entity should be drawn in the "main pass"
-#[derive(Default, Reflect)]
+#[derive(Clone, Debug, Default, Reflect)]
 #[reflect(Component)]
 pub struct MainPass;
 

crates/bevy_render/src/render_graph/nodes/pass_node.rs

@@ -37,7 +37,7 @@ pub struct PassNode<Q: WorldQuery> {
 
 impl<Q: WorldQuery> fmt::Debug for PassNode<Q> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        f.debug_struct("PassNose")
+        f.debug_struct("PassNode")
             .field("descriptor", &self.descriptor)
             .field("inputs", &self.inputs)
             .field("cameras", &self.cameras)

crates/bevy_text/Cargo.toml

@@ -22,6 +22,7 @@ bevy_math = { path = "../bevy_math", version = "0.4.0" }
 bevy_reflect = { path = "../bevy_reflect", version = "0.4.0", features = ["bevy"] }
 bevy_render = { path = "../bevy_render", version = "0.4.0" }
 bevy_sprite = { path = "../bevy_sprite", version = "0.4.0" }
+bevy_transform = { path = "../bevy_transform", version = "0.4.0" }
 bevy_utils = { path = "../bevy_utils", version = "0.4.0" }
 
 # other

crates/bevy_text/src/lib.rs

@@ -6,6 +6,8 @@ mod font_atlas_set;
 mod font_loader;
 mod glyph_brush;
 mod pipeline;
+mod text;
+mod text2d;
 
 pub use draw::*;
 pub use error::*;
@@ -15,15 +17,17 @@ pub use font_atlas_set::*;
 pub use font_loader::*;
 pub use glyph_brush::*;
 pub use pipeline::*;
+pub use text::*;
+pub use text2d::*;
 
 pub mod prelude {
-    pub use crate::{Font, TextAlignment, TextError, TextStyle};
+    pub use crate::{Font, Text, Text2dBundle, TextAlignment, TextError, TextStyle};
     pub use glyph_brush_layout::{HorizontalAlign, VerticalAlign};
 }
 
 use bevy_app::prelude::*;
 use bevy_asset::AddAsset;
-use bevy_ecs::Entity;
+use bevy_ecs::{Entity, IntoSystem};
 
 pub type DefaultTextPipeline = TextPipeline<Entity>;
 
@@ -35,6 +39,11 @@ impl Plugin for TextPlugin {
         app.add_asset::<Font>()
             .add_asset::<FontAtlasSet>()
             .init_asset_loader::<FontLoader>()
-            .add_resource(DefaultTextPipeline::default());
+            .add_resource(DefaultTextPipeline::default())
+            .add_system_to_stage(bevy_app::stage::POST_UPDATE, text2d_system.system())
+            .add_system_to_stage(
+                bevy_render::stage::DRAW,
+                text2d::draw_text2d_system.system(),
+            );
     }
 }

crates/bevy_text/src/text.rs

@@ -0,0 +1,16 @@
+use bevy_asset::Handle;
+use bevy_math::Size;
+
+use crate::{Font, TextStyle};
+
+#[derive(Debug, Default, Clone)]
+pub struct Text {
+    pub value: String,
+    pub font: Handle<Font>,
+    pub style: TextStyle,
+}
+
+#[derive(Default, Copy, Clone, Debug)]
+pub struct CalculatedSize {
+    pub size: Size,
+}

crates/bevy_text/src/text2d.rs

@@ -0,0 +1,172 @@
+use bevy_asset::Assets;
+use bevy_ecs::{Bundle, Changed, Entity, Local, Query, QuerySet, Res, ResMut, With};
+use bevy_math::{Size, Vec3};
+use bevy_render::{
+    draw::{DrawContext, Drawable},
+    mesh::Mesh,
+    prelude::{Draw, Msaa, Texture, Visible},
+    render_graph::base::MainPass,
+    renderer::RenderResourceBindings,
+};
+use bevy_sprite::{TextureAtlas, QUAD_HANDLE};
+use bevy_transform::prelude::{GlobalTransform, Transform};
+use glyph_brush_layout::{HorizontalAlign, VerticalAlign};
+
+use crate::{
+    CalculatedSize, DefaultTextPipeline, DrawableText, Font, FontAtlasSet, Text, TextError,
+};
+
+/// The bundle of components needed to draw text in a 2D scene via the Camera2dBundle.
+#[derive(Bundle, Clone, Debug)]
+pub struct Text2dBundle {
+    pub draw: Draw,
+    pub visible: Visible,
+    pub text: Text,
+    pub transform: Transform,
+    pub global_transform: GlobalTransform,
+    pub main_pass: MainPass,
+    pub calculated_size: CalculatedSize,
+}
+
+impl Default for Text2dBundle {
+    fn default() -> Self {
+        Self {
+            draw: Draw {
+                ..Default::default()
+            },
+            visible: Visible {
+                is_transparent: true,
+                ..Default::default()
+            },
+            text: Default::default(),
+            transform: Default::default(),
+            global_transform: Default::default(),
+            main_pass: MainPass {},
+            calculated_size: CalculatedSize {
+                size: Size::default(),
+            },
+        }
+    }
+}
+
+/// System for drawing text in a 2D scene via the Camera2dBundle.  Included in the default
+/// `TextPlugin`. Position is determined by the `Transform`'s translation, though scale and rotation
+/// are ignored.
+pub fn draw_text2d_system(
+    mut context: DrawContext,
+    msaa: Res<Msaa>,
+    meshes: Res<Assets<Mesh>>,
+    mut render_resource_bindings: ResMut<RenderResourceBindings>,
+    text_pipeline: Res<DefaultTextPipeline>,
+    mut query: Query<
+        (
+            Entity,
+            &mut Draw,
+            &Visible,
+            &Text,
+            &GlobalTransform,
+            &CalculatedSize,
+        ),
+        With<MainPass>,
+    >,
+) {
+    let font_quad = meshes.get(&QUAD_HANDLE).unwrap();
+    let vertex_buffer_descriptor = font_quad.get_vertex_buffer_descriptor();
+
+    for (entity, mut draw, visible, text, global_transform, calculated_size) in query.iter_mut() {
+        if !visible.is_visible {
+            continue;
+        }
+
+        let (width, height) = (calculated_size.size.width, calculated_size.size.height);
+
+        if let Some(text_glyphs) = text_pipeline.get_glyphs(&entity) {
+            let position = global_transform.translation
+                + match text.style.alignment.vertical {
+                    VerticalAlign::Top => Vec3::zero(),
+                    VerticalAlign::Center => Vec3::new(0.0, -height * 0.5, 0.0),
+                    VerticalAlign::Bottom => Vec3::new(0.0, -height, 0.0),
+                }
+                + match text.style.alignment.horizontal {
+                    HorizontalAlign::Left => Vec3::new(-width, 0.0, 0.0),
+                    HorizontalAlign::Center => Vec3::new(-width * 0.5, 0.0, 0.0),
+                    HorizontalAlign::Right => Vec3::zero(),
+                };
+
+            let mut drawable_text = DrawableText {
+                render_resource_bindings: &mut render_resource_bindings,
+                position,
+                msaa: &msaa,
+                text_glyphs: &text_glyphs.glyphs,
+                font_quad_vertex_descriptor: &vertex_buffer_descriptor,
+                style: &text.style,
+            };
+
+            drawable_text.draw(&mut draw, &mut context).unwrap();
+        }
+    }
+}
+
+#[derive(Debug, Default)]
+pub struct QueuedText2d {
+    entities: Vec<Entity>,
+}
+
+/// Updates the TextGlyphs with the new computed glyphs from the layout
+pub fn text2d_system(
+    mut queued_text: Local<QueuedText2d>,
+    mut textures: ResMut<Assets<Texture>>,
+    fonts: Res<Assets<Font>>,
+    mut texture_atlases: ResMut<Assets<TextureAtlas>>,
+    mut font_atlas_set_storage: ResMut<Assets<FontAtlasSet>>,
+    mut text_pipeline: ResMut<DefaultTextPipeline>,
+    mut text_queries: QuerySet<(
+        Query<Entity, Changed<Text>>,
+        Query<(&Text, &mut CalculatedSize)>,
+    )>,
+) {
+    // Adds all entities where the text or the style has changed to the local queue
+    for entity in text_queries.q0_mut().iter_mut() {
+        queued_text.entities.push(entity);
+    }
+
+    if queued_text.entities.is_empty() {
+        return;
+    }
+
+    // Computes all text in the local queue
+    let mut new_queue = Vec::new();
+    let query = text_queries.q1_mut();
+    for entity in queued_text.entities.drain(..) {
+        if let Ok((text, mut calculated_size)) = query.get_mut(entity) {
+            match text_pipeline.queue_text(
+                entity,
+                text.font.clone(),
+                &fonts,
+                &text.value,
+                text.style.font_size,
+                text.style.alignment,
+                Size::new(f32::MAX, f32::MAX),
+                &mut *font_atlas_set_storage,
+                &mut *texture_atlases,
+                &mut *textures,
+            ) {
+                Err(TextError::NoSuchFont) => {
+                    // There was an error processing the text layout, let's add this entity to the queue for further processing
+                    new_queue.push(entity);
+                }
+                Err(e @ TextError::FailedToAddGlyph(_)) => {
+                    panic!("Fatal error when processing text: {}.", e);
+                }
+                Ok(()) => {
+                    let text_layout_info = text_pipeline.get_glyphs(&entity).expect(
+                        "Failed to get glyphs from the pipeline that have just been computed",
+                    );
+                    calculated_size.size = text_layout_info.size;
+                }
+            }
+        }
+    }
+
+    queued_text.entities = new_queue;
+}

crates/bevy_ui/src/entity.rs

@@ -1,8 +1,8 @@
 use super::Node;
 use crate::{
     render::UI_PIPELINE_HANDLE,
-    widget::{Button, Image, Text},
-    CalculatedSize, FocusPolicy, Interaction, Style,
+    widget::{Button, Image},
+    FocusPolicy, Interaction, Style,
 };
 use bevy_asset::Handle;
 use bevy_ecs::Bundle;
@@ -15,6 +15,7 @@ use bevy_render::{
     prelude::Visible,
 };
 use bevy_sprite::{ColorMaterial, QUAD_HANDLE};
+use bevy_text::{CalculatedSize, Text};
 use bevy_transform::prelude::{GlobalTransform, Transform};
 
 #[derive(Bundle, Clone, Debug)]

crates/bevy_ui/src/flex/mod.rs

@@ -1,8 +1,9 @@
 mod convert;
 
-use crate::{CalculatedSize, Node, Style};
+use crate::{Node, Style};
 use bevy_ecs::{Changed, Entity, Query, Res, ResMut, With, Without};
 use bevy_math::Vec2;
+use bevy_text::CalculatedSize;
 use bevy_transform::prelude::{Children, Parent, Transform};
 use bevy_utils::HashMap;
 use bevy_window::{Window, WindowId, Windows};

crates/bevy_ui/src/lib.rs

@@ -16,12 +16,7 @@ pub use node::*;
 pub use render::*;
 
 pub mod prelude {
-    pub use crate::{
-        entity::*,
-        node::*,
-        widget::{Button, Text},
-        Anchors, Interaction, Margins,
-    };
+    pub use crate::{entity::*, node::*, widget::Button, Anchors, Interaction, Margins};
 }
 
 use bevy_app::prelude::*;

crates/bevy_ui/src/node.rs

@@ -48,11 +48,6 @@ impl AddAssign<f32> for Val {
     }
 }
 
-#[derive(Default, Copy, Clone, Debug)]
-pub struct CalculatedSize {
-    pub size: Size,
-}
-
 #[derive(Clone, PartialEq, Debug, Reflect)]
 pub struct Style {
     pub display: Display,

crates/bevy_ui/src/widget/image.rs

@@ -1,9 +1,9 @@
-use crate::CalculatedSize;
 use bevy_asset::{Assets, Handle};
 use bevy_ecs::{Query, Res, With};
 use bevy_math::Size;
 use bevy_render::texture::Texture;
 use bevy_sprite::ColorMaterial;
+use bevy_text::CalculatedSize;
 
 #[derive(Debug, Clone)]
 pub enum Image {