[Merged by Bors] - make TextLayoutInfo a Component

crates/bevy_text/src/lib.rs

@@ -28,13 +28,11 @@ pub mod prelude {
 
 use bevy_app::prelude::*;
 use bevy_asset::AddAsset;
-use bevy_ecs::{entity::Entity, schedule::ParallelSystemDescriptorCoercion};
+use bevy_ecs::schedule::ParallelSystemDescriptorCoercion;
 use bevy_render::{RenderApp, RenderStage};
 use bevy_sprite::SpriteSystem;
 use bevy_window::ModifiesWindows;
 
-pub type DefaultTextPipeline = TextPipeline<Entity>;
-
 #[derive(Default)]
 pub struct TextPlugin;
 
@@ -48,7 +46,7 @@ impl Plugin for TextPlugin {
             .register_type::<VerticalAlign>()
             .register_type::<HorizontalAlign>()
             .init_asset_loader::<FontLoader>()
-            .insert_resource(DefaultTextPipeline::default())
+            .insert_resource(TextPipeline::default())
             .add_system_to_stage(
                 CoreStage::PostUpdate,
                 update_text2d_layout.after(ModifiesWindows),

crates/bevy_text/src/pipeline.rs

@@ -1,7 +1,6 @@
-use std::hash::Hash;
-
 use ab_glyph::{PxScale, ScaleFont};
 use bevy_asset::{Assets, Handle, HandleId};
+use bevy_ecs::component::Component;
 use bevy_ecs::system::Resource;
 use bevy_math::Vec2;
 use bevy_render::texture::Image;
@@ -15,29 +14,22 @@ use crate::{
     TextAlignment, TextSection,
 };
 
-#[derive(Resource)]
-pub struct TextPipeline<ID> {
+#[derive(Default, Resource)]
+pub struct TextPipeline {
     brush: GlyphBrush,
-    glyph_map: HashMap<ID, TextLayoutInfo>,
     map_font_id: HashMap<HandleId, FontId>,
 }
 
-impl<ID> Default for TextPipeline<ID> {
-    fn default() -> Self {
-        TextPipeline {
-            brush: GlyphBrush::default(),
-            glyph_map: Default::default(),
-            map_font_id: Default::default(),
-        }
-    }
-}
-
+/// Render information for a corresponding [`Text`](crate::Text) component.
+///
+///  Contains scaled glyphs and their size. Generated via [`TextPipeline::queue_text`].
+#[derive(Component, Clone, Default, Debug)]
 pub struct TextLayoutInfo {
     pub glyphs: Vec<PositionedGlyph>,
     pub size: Vec2,
 }
 
-impl<ID: Hash + Eq> TextPipeline<ID> {
+impl TextPipeline {
     pub fn get_or_insert_font_id(&mut self, handle: &Handle<Font>, font: &Font) -> FontId {
         let brush = &mut self.brush;
         *self
@@ -46,14 +38,9 @@ impl<ID: Hash + Eq> TextPipeline<ID> {
             .or_insert_with(|| brush.add_font(handle.clone(), font.font.clone()))
     }
 
-    pub fn get_glyphs(&self, id: &ID) -> Option<&TextLayoutInfo> {
-        self.glyph_map.get(id)
-    }
-
     #[allow(clippy::too_many_arguments)]
     pub fn queue_text(
         &mut self,
-        id: ID,
         fonts: &Assets<Font>,
         sections: &[TextSection],
         scale_factor: f64,
@@ -62,7 +49,7 @@ impl<ID: Hash + Eq> TextPipeline<ID> {
         font_atlas_set_storage: &mut Assets<FontAtlasSet>,
         texture_atlases: &mut Assets<TextureAtlas>,
         textures: &mut Assets<Image>,
-    ) -> Result<(), TextError> {
+    ) -> Result<TextLayoutInfo, TextError> {
         let mut scaled_fonts = Vec::new();
         let sections = sections
             .iter()
@@ -90,14 +77,7 @@ impl<ID: Hash + Eq> TextPipeline<ID> {
             .compute_glyphs(&sections, bounds, text_alignment)?;
 
         if section_glyphs.is_empty() {
-            self.glyph_map.insert(
-                id,
-                TextLayoutInfo {
-                    glyphs: Vec::new(),
-                    size: Vec2::ZERO,
-                },
-            );
-            return Ok(());
+            return Ok(TextLayoutInfo::default());
         }
 
         let mut min_x: f32 = std::f32::MAX;
@@ -125,8 +105,6 @@ impl<ID: Hash + Eq> TextPipeline<ID> {
             textures,
         )?;
 
-        self.glyph_map.insert(id, TextLayoutInfo { glyphs, size });
-
-        Ok(())
+        Ok(TextLayoutInfo { glyphs, size })
     }
 }

crates/bevy_text/src/text2d.rs

@@ -6,7 +6,7 @@ use bevy_ecs::{
     event::EventReader,
     query::Changed,
     reflect::ReflectComponent,
-    system::{Local, Query, Res, ResMut},
+    system::{Commands, Local, Query, Res, ResMut},
 };
 use bevy_math::{Vec2, Vec3};
 use bevy_reflect::Reflect;
@@ -22,7 +22,8 @@ use bevy_utils::HashSet;
 use bevy_window::{WindowId, WindowScaleFactorChanged, Windows};
 
 use crate::{
-    DefaultTextPipeline, Font, FontAtlasSet, HorizontalAlign, Text, TextError, VerticalAlign,
+    Font, FontAtlasSet, HorizontalAlign, Text, TextError, TextLayoutInfo, TextPipeline,
+    VerticalAlign,
 };
 
 /// The calculated size of text drawn in 2D scene.
@@ -69,76 +70,75 @@ pub struct Text2dBundle {
 pub fn extract_text2d_sprite(
     mut extracted_sprites: ResMut<ExtractedSprites>,
     texture_atlases: Extract<Res<Assets<TextureAtlas>>>,
-    text_pipeline: Extract<Res<DefaultTextPipeline>>,
     windows: Extract<Res<Windows>>,
     text2d_query: Extract<
         Query<(
             Entity,
             &ComputedVisibility,
             &Text,
+            &TextLayoutInfo,
             &GlobalTransform,
             &Text2dSize,
         )>,
     >,
 ) {
     let scale_factor = windows.scale_factor(WindowId::primary()) as f32;
 
-    for (entity, computed_visibility, text, text_transform, calculated_size) in text2d_query.iter()
+    for (entity, computed_visibility, text, text_layout_info, text_transform, calculated_size) in
+        text2d_query.iter()
     {
         if !computed_visibility.is_visible() {
             continue;
         }
         let (width, height) = (calculated_size.size.x, calculated_size.size.y);
 
-        if let Some(text_layout) = text_pipeline.get_glyphs(&entity) {
-            let text_glyphs = &text_layout.glyphs;
-            let alignment_offset = match text.alignment.vertical {
-                VerticalAlign::Top => Vec3::new(0.0, -height, 0.0),
-                VerticalAlign::Center => Vec3::new(0.0, -height * 0.5, 0.0),
-                VerticalAlign::Bottom => Vec3::ZERO,
-            } + match text.alignment.horizontal {
-                HorizontalAlign::Left => Vec3::ZERO,
-                HorizontalAlign::Center => Vec3::new(-width * 0.5, 0.0, 0.0),
-                HorizontalAlign::Right => Vec3::new(-width, 0.0, 0.0),
-            };
+        let text_glyphs = &text_layout_info.glyphs;
+        let alignment_offset = match text.alignment.vertical {
+            VerticalAlign::Top => Vec3::new(0.0, -height, 0.0),
+            VerticalAlign::Center => Vec3::new(0.0, -height * 0.5, 0.0),
+            VerticalAlign::Bottom => Vec3::ZERO,
+        } + match text.alignment.horizontal {
+            HorizontalAlign::Left => Vec3::ZERO,
+            HorizontalAlign::Center => Vec3::new(-width * 0.5, 0.0, 0.0),
+            HorizontalAlign::Right => Vec3::new(-width, 0.0, 0.0),
+        };
 
-            let mut color = Color::WHITE;
-            let mut current_section = usize::MAX;
-            for text_glyph in text_glyphs {
-                if text_glyph.section_index != current_section {
-                    color = text.sections[text_glyph.section_index]
-                        .style
-                        .color
-                        .as_rgba_linear();
-                    current_section = text_glyph.section_index;
-                }
-                let atlas = texture_atlases
-                    .get(&text_glyph.atlas_info.texture_atlas)
-                    .unwrap();
-                let handle = atlas.texture.clone_weak();
-                let index = text_glyph.atlas_info.glyph_index as usize;
-                let rect = Some(atlas.textures[index]);
+        let mut color = Color::WHITE;
+        let mut current_section = usize::MAX;
+        for text_glyph in text_glyphs {
+            if text_glyph.section_index != current_section {
+                color = text.sections[text_glyph.section_index]
+                    .style
+                    .color
+                    .as_rgba_linear();
+                current_section = text_glyph.section_index;
+            }
+            let atlas = texture_atlases
+                .get(&text_glyph.atlas_info.texture_atlas)
+                .unwrap();
+            let handle = atlas.texture.clone_weak();
+            let index = text_glyph.atlas_info.glyph_index as usize;
+            let rect = Some(atlas.textures[index]);
 
-                let glyph_transform = Transform::from_translation(
-                    alignment_offset * scale_factor + text_glyph.position.extend(0.),
-                );
-                // NOTE: Should match `bevy_ui::render::extract_text_uinodes`
-                let transform = *text_transform
-                    * GlobalTransform::from_scale(Vec3::splat(scale_factor.recip()))
-                    * glyph_transform;
+            let glyph_transform = Transform::from_translation(
+                alignment_offset * scale_factor + text_glyph.position.extend(0.),
+            );
+            // NOTE: Should match `bevy_ui::render::extract_text_uinodes`
+            let transform = *text_transform
+                * GlobalTransform::from_scale(Vec3::splat(scale_factor.recip()))
+                * glyph_transform;
 
-                extracted_sprites.sprites.push(ExtractedSprite {
-                    entity,
-                    transform,
-                    color,
-                    rect,
-                    custom_size: None,
-                    image_handle_id: handle.id,
-                    flip_x: false,
-                    flip_y: false,
-                    anchor: Anchor::Center.as_vec(),
-                });
-            }
+            extracted_sprites.sprites.push(ExtractedSprite {
+                entity,
+                transform,
+                color,
+                rect,
+                custom_size: None,
+                image_handle_id: handle.id,
+                flip_x: false,
+                flip_y: false,
+                anchor: Anchor::Center.as_vec(),
+            });
         }
     }
 }
@@ -147,6 +147,7 @@ pub fn extract_text2d_sprite(
 /// This information is computed by the `TextPipeline` on insertion, then stored.
 #[allow(clippy::too_many_arguments)]
 pub fn update_text2d_layout(
+    mut commands: Commands,
     // Text items which should be reprocessed again, generally when the font hasn't loaded yet.
     mut queue: Local<HashSet<Entity>>,
     mut textures: ResMut<Assets<Image>>,
@@ -155,20 +156,23 @@ pub fn update_text2d_layout(
     mut scale_factor_changed: EventReader<WindowScaleFactorChanged>,
     mut texture_atlases: ResMut<Assets<TextureAtlas>>,
     mut font_atlas_set_storage: ResMut<Assets<FontAtlasSet>>,
-    mut text_pipeline: ResMut<DefaultTextPipeline>,
+    mut text_pipeline: ResMut<TextPipeline>,
     mut text_query: Query<(
         Entity,
         Changed<Text>,
         &Text,
         Option<&Text2dBounds>,
         &mut Text2dSize,
+        Option<&mut TextLayoutInfo>,
     )>,
 ) {
     // We need to consume the entire iterator, hence `last`
     let factor_changed = scale_factor_changed.iter().last().is_some();
     let scale_factor = windows.scale_factor(WindowId::primary());
 
-    for (entity, text_changed, text, maybe_bounds, mut calculated_size) in &mut text_query {
+    for (entity, text_changed, text, maybe_bounds, mut calculated_size, text_layout_info) in
+        &mut text_query
+    {
         if factor_changed || text_changed || queue.remove(&entity) {
             let text_bounds = match maybe_bounds {
                 Some(bounds) => Vec2::new(
@@ -178,7 +182,6 @@ pub fn update_text2d_layout(
                 None => Vec2::new(f32::MAX, f32::MAX),
             };
             match text_pipeline.queue_text(
-                entity,
                 &fonts,
                 &text.sections,
                 scale_factor,
@@ -196,14 +199,17 @@ pub fn update_text2d_layout(
                 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",
-                    );
+                Ok(info) => {
                     calculated_size.size = Vec2::new(
-                        scale_value(text_layout_info.size.x, 1. / scale_factor),
-                        scale_value(text_layout_info.size.y, 1. / scale_factor),
+                        scale_value(info.size.x, 1. / scale_factor),
+                        scale_value(info.size.y, 1. / scale_factor),
                     );
+                    match text_layout_info {
+                        Some(mut t) => *t = info,
+                        None => {
+                            commands.entity(entity).insert(info);
+                        }
+                    }
                 }
             }
         }