More flexible X/"extra" type handling

glyph-brush/CHANGELOG.md

@@ -1,4 +1,8 @@
 # Unreleased (v0.7.7)
+* Allow `Text::new` to work with any `X` type. **This may break usage**, however it will hopefully be non-breaking in practice as the compiler should always be able to infer this.
+* Add `Section::builder` for more flexible `X`/"extra" type usage than `Section::default`.
+* Add more flexible `X` type usage to `GlyphBrush::keep_cached`.
+* Add `Section::from(text)` & `Section::from(vec![text])` conversions.
 * Update `GlyphCruncher::glyphs`, `GlyphCruncher::glyph_bounds` docs.
 
 # v0.7.6

glyph-brush/src/glyph_brush.rs

@@ -371,8 +371,9 @@ where
     /// Should not generally be necessary, see [caching behaviour](#caching-behaviour).
     pub fn keep_cached_custom_layout<'a, S, G>(&mut self, section: S, custom_layout: &G)
     where
-        S: Into<Cow<'a, Section<'a>>>,
+        S: Into<Cow<'a, Section<'a, X>>>,
         G: GlyphPositioner,
+        X: 'a,
     {
         if !self.cache_glyph_positioning {
             return;
@@ -393,7 +394,8 @@ where
     /// Should not generally be necessary, see [caching behaviour](#caching-behaviour).
     pub fn keep_cached<'a, S>(&mut self, section: S)
     where
-        S: Into<Cow<'a, Section<'a>>>,
+        S: Into<Cow<'a, Section<'a, X>>>,
+        X: 'a,
     {
         let section = section.into();
         let layout = section.layout;

glyph-brush/src/glyph_calculator.rs

@@ -354,7 +354,7 @@ impl<F: Font, H: BuildHasher> GlyphCalculatorBuilder<F, H> {
 }
 
 #[derive(Debug, Clone, PartialEq)]
-pub(crate) struct GlyphedSection<X = Extra> {
+pub(crate) struct GlyphedSection<X> {
     pub bounds: Rect,
     pub glyphs: Vec<SectionGlyph>,
     pub extra: Vec<X>,

glyph-brush/src/legacy.rs

@@ -229,7 +229,7 @@ impl From<&VariedSection<'_>> for SectionGeometry {
 impl<'a> From<&VariedSection<'a>> for crate::Section<'a> {
     #[inline]
     fn from(s: &VariedSection<'a>) -> Self {
-        crate::Section::default()
+        crate::Section::builder()
             .with_layout(s.layout)
             .with_bounds(s.bounds)
             .with_screen_position(s.screen_position)

glyph-brush/src/section.rs

@@ -1,7 +1,10 @@
+mod builder;
+
 use super::{owned_section::*, *};
 use ordered_float::OrderedFloat;
 use std::{borrow::Cow, f32, hash::*};
 
+pub use builder::SectionBuilder;
 pub type Color = [f32; 4];
 
 /// An object that contains all the info to render a varied section of text. That is one including
@@ -41,6 +44,7 @@ impl<X: Clone> Section<'_, X> {
 }
 
 impl Default for Section<'static, Extra> {
+    /// Note this only works for `X=Extra` for more flexible use see [`Section::builder`].
     #[inline]
     fn default() -> Self {
         Section::new()
@@ -50,12 +54,29 @@ impl Default for Section<'static, Extra> {
 impl<'a, X> Section<'a, X> {
     #[inline]
     pub fn new() -> Self {
-        Self {
-            screen_position: (0.0, 0.0),
-            bounds: (f32::INFINITY, f32::INFINITY),
-            layout: Layout::default(),
-            text: vec![],
-        }
+        Section::builder().with_text(vec![])
+    }
+}
+
+impl Section<'_, ()> {
+    /// Return a `SectionBuilder` to fluently build up a `Section`.
+    #[inline]
+    pub fn builder() -> SectionBuilder {
+        <_>::default()
+    }
+}
+
+impl<'a, X> From<Text<'a, X>> for Section<'a, X> {
+    #[inline]
+    fn from(text: Text<'a, X>) -> Self {
+        Section::builder().add_text(text)
+    }
+}
+
+impl<'a, X> From<Vec<Text<'a, X>>> for Section<'a, X> {
+    #[inline]
+    fn from(text: Vec<Text<'a, X>>) -> Self {
+        Section::builder().with_text(text)
     }
 }
 
@@ -196,12 +217,14 @@ impl<'a, X> Text<'a, X> {
     }
 }
 
-impl<'a> Text<'a, Extra> {
+impl<'a, X: Default> Text<'a, X> {
     #[inline]
     pub fn new(text: &'a str) -> Self {
         Text::default().with_text(text)
     }
+}
 
+impl<'a> Text<'a, Extra> {
     #[inline]
     pub fn with_color<C: Into<Color>>(mut self, color: C) -> Self {
         self.extra.color = color.into();

glyph-brush/src/section/builder.rs

@@ -0,0 +1,61 @@
+use crate::{Section, Text};
+use glyph_brush_layout::{BuiltInLineBreaker, Layout};
+
+/// [`Section`] builder.
+///
+/// Usage can avoid generic `X` type issues as it's not mentioned until text is involved.
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub struct SectionBuilder {
+    /// Position on screen to render text, in pixels from top-left. Defaults to (0, 0).
+    pub screen_position: (f32, f32),
+    /// Max (width, height) bounds, in pixels from top-left. Defaults to unbounded.
+    pub bounds: (f32, f32),
+    /// Built in layout, can be overridden with custom layout logic
+    /// see [`queue_custom_layout`](struct.GlyphBrush.html#method.queue_custom_layout)
+    pub layout: Layout<BuiltInLineBreaker>,
+}
+
+impl Default for SectionBuilder {
+    fn default() -> Self {
+        Self {
+            screen_position: (0.0, 0.0),
+            bounds: (f32::INFINITY, f32::INFINITY),
+            layout: Layout::default(),
+        }
+    }
+}
+
+impl SectionBuilder {
+    #[inline]
+    pub fn with_screen_position<P: Into<(f32, f32)>>(mut self, position: P) -> Self {
+        self.screen_position = position.into();
+        self
+    }
+
+    #[inline]
+    pub fn with_bounds<P: Into<(f32, f32)>>(mut self, bounds: P) -> Self {
+        self.bounds = bounds.into();
+        self
+    }
+
+    #[inline]
+    pub fn with_layout<L: Into<Layout<BuiltInLineBreaker>>>(mut self, layout: L) -> Self {
+        self.layout = layout.into();
+        self
+    }
+
+    #[inline]
+    pub fn add_text<X>(self, text: Text<'_, X>) -> Section<'_, X> {
+        self.with_text(vec![text])
+    }
+
+    #[inline]
+    pub fn with_text<X>(self, text: Vec<Text<'_, X>>) -> Section<'_, X> {
+        Section {
+            text,
+            screen_position: self.screen_position,
+            bounds: self.bounds,
+            layout: self.layout,
+        }
+    }
+}