cleanup WIP

Author: UkoeHB

crates/bevy_text/src/lib.rs

@@ -43,6 +43,7 @@ mod glyph;
 mod pipeline;
 mod text;
 mod text2d;
+mod text_spans;
 
 pub use cosmic_text;
 
@@ -56,13 +57,16 @@ pub use glyph::*;
 pub use pipeline::*;
 pub use text::*;
 pub use text2d::*;
+pub use text_spans::*;
 
 /// The text prelude.
 ///
 /// This includes the most common types in this crate, re-exported for your convenience.
 pub mod prelude {
     #[doc(hidden)]
-    pub use crate::{Font, JustifyText, Text, Text2dBundle, TextError, TextSection, TextStyle};
+    pub use crate::{
+        Font, JustifyText, LineBreak, Text2d, TextBlock, TextError, TextSpan2d, TextStyle,
+    };
 }
 
 use bevy_app::prelude::*;

crates/bevy_text/src/text.rs

@@ -68,7 +68,7 @@ impl ComputedTextBlock {
     /// Can be used to look up [`TextStyle`] components for glyphs in [`TextLayoutInfo`] using the `span_index`
     /// stored there.
     pub fn entities(&self) -> &[TextEntity] {
-        self.entities.iter()
+        &self.entities
     }
 
     /// Indicates if the text needs to be refreshed in [`TextLayoutInfo`].
@@ -112,8 +112,16 @@ pub struct TextBlock {
 
 impl TextBlock {
     /// Makes a new [`TextBlock`].
-    pub const fn new(justify: JustifyText, linebreak: LineBreak, font_smoothing: FontSmoothing) -> Self {
-        Self{ justify, linebreak, font_smoothing }
+    pub const fn new(
+        justify: JustifyText,
+        linebreak: LineBreak,
+        font_smoothing: FontSmoothing,
+    ) -> Self {
+        Self {
+            justify,
+            linebreak,
+            font_smoothing,
+        }
     }
 
     /// Makes a new [`TextBlock`] with the specified [`JustifyText`].
@@ -277,3 +285,71 @@ pub enum FontSmoothing {
     // TODO: Add subpixel antialias support
     // SubpixelAntiAliased,
 }
+
+/// System that detects changes to text blocks and sets `ComputedTextBlock::should_rerender`.
+///
+/// Generic over the root text component and text span component. For example, [`Text2d`]/[`TextSpan2d`] for 2d or
+/// `Text`/`TextSpan` for UI.
+pub fn detect_text_needs_rerender<Root: Component, Span: Component>(
+    changed_roots: Query<
+        Entity,
+        (
+            Or<(
+                Changed<Root>,
+                Changed<TextStyle>,
+                Changed<TextBlock>,
+                Changed<Children>,
+            )>,
+            With<Root>,
+            With<TextStyle>,
+            With<TextBlock>,
+        ),
+    >,
+    changed_spans: Query<
+        &Parent,
+        Or<(Changed<Span>, Changed<TextStyle>, Changed<Children>)>,
+        With<Span>,
+        With<TextStyle>,
+    >,
+    mut computed: Query<(Option<&Parent>, Option<&mut ComputedTextBlock>)>,
+) {
+    // Root entity:
+    // - Root component changed.
+    // - TextStyle on root changed.
+    // - TextBlock changed.
+    // - Root children changed (can include additions and removals).
+    for root in changed_roots.iter() {
+        // TODO: ComputedTextBlock *should* be here. Log a warning?
+        let Ok((_, Some(mut computed))) = computed.get_mut(root) else {
+            continue;
+        };
+        computed.needs_rerender = true;
+    }
+
+    // Span entity:
+    // - Span component changed.
+    // - Span TextStyle changed.
+    // - Span children changed (can include additions and removals).
+    for span_parent in changed_spans.iter() {
+        let mut parent: Entity = **span_parent;
+
+        // Search for the nearest ancestor with ComputedTextBlock.
+        // Note: We assume the perf cost from duplicate visits in the case that multiple spans in a block are visited
+        // is outweighed by the expense of tracking visited spans.
+        loop {
+            // TODO: If this lookup fails then there is a hierarchy error. Log a warning?
+            let Ok((maybe_parent, maybe_computed)) = computed.get_mut(parent) else {
+                break;
+            };
+            if let Some(computed) = maybe_computed {
+                computed.needs_rerender = true;
+                break;
+            }
+            // TODO: If there is no parent then a span is floating without an owning TextBlock. Log a warning?
+            let Some(next_parent) = maybe_parent else {
+                break;
+            };
+            parent = **next_parent;
+        }
+    }
+}

crates/bevy_text/src/text2d.rs

@@ -37,16 +37,31 @@ use bevy_window::{PrimaryWindow, Window, WindowScaleFactorChanged};
 /// With `Text2d` the `justify` field of [`TextBlock`] only affects the internal alignment of a block of text and not its
 /// relative position, which is controlled by the [`Anchor`] component.
 /// This means that for a block of text consisting of only one line that doesn't wrap, the `justify` field will have no effect.
+///
 /*
 ```
+# use bevy_asset::Handle;
+# use bevy_color::Color;
+# use bevy_color::palettes::basic::BLUE;
 # use bevy_ecs::World;
-# use bevy_text::{Text2d, TextBlock, JustifyText};
+# use bevy_text::{Font, JustifyText, Text2d, TextBlock, TextStyle};
 #
+# let font_handle: Handle<Font> = Default::default();
 # let mut world = World::default();
 #
 // Basic usage.
 world.spawn(Text2d::new("hello world!"));
 
+// With non-default style.
+world.spawn((
+    Text2d::new("hello world!"),
+    TextStyle {
+        font: font_handle.clone().into(),
+        font_size: 60.0,
+        color: BLUE.into(),
+    }
+));
+
 // With text justification.
 world.spawn((
     Text2d::new("hello world\nand bevy!"),
@@ -89,6 +104,7 @@ impl From<String> for Text2d {
 /// A span of 2d text in a tree of spans under an entity with [`Text2d`].
 ///
 /// Spans are collected in hierarchy traversal order into a [`ComputedTextBlock`] for layout.
+///
 /*
 ```
 # use bevy_asset::Handle;