bevy_text 0.20.0

use crate::TextError;
use crate::{FontSmoothing, FontSource, GenericFontFamily};
use bevy_derive::Deref;
use bevy_derive::DerefMut;
use bevy_ecs::resource::Resource;
use bevy_platform::collections::HashMap;
use parley::FontContext;
use parley::LayoutContext;
use swash::scale::ScaleContext;

#[derive(Copy, Clone, PartialEq, Default, Debug)]
/// Per-section metadata attached to shaped text runs.
///
/// This brush is stored in Parley's [`Layout`](`parley::Layout`) so Bevy can identify which text section
/// a glyph run belongs to, and the antialiasing method that should be used during rendering.
pub struct TextBrush {
    /// Index of the text section within its `ComputedTextBlock`.
    pub section_index: u32,
    /// Antialiasing method to use when rendering the text.
    pub font_smoothing: FontSmoothing,
}

impl TextBrush {
    /// Creates a new brush for glyphs from the given text section.
    pub fn new(section_index: u32, font_smoothing: FontSmoothing) -> Self {
        TextBrush {
            section_index,
            font_smoothing,
        }
    }
}

/// A font database and cache, used for font family resolution and text layout.
///
/// This resource is a wrapper around [`parley::FontContext`].
#[derive(Resource, Default, Deref, DerefMut)]
pub struct FontCx {
    /// A font database/cache (wrapper around a Fontique [`Collection`](parley::fontique::Collection) and [`SourceCache`](parley::fontique::SourceCache)).
    #[deref]
    pub context: FontContext,
    /// Backup, used to restore the generic family mappings after the font [`Collection`](parley::fontique::Collection) is cleared.
    generic_families: HashMap<GenericFontFamily, String>,
}

impl FontCx {
    /// Get the family name associated with a [`FontSource`].
    ///
    /// If the `FontSource` is a `Handle`, returns `None`. The family name can be found by using the handle to look
    /// up the `Font` asset instead.
    pub fn get_family<'a>(&'a mut self, source: &'a FontSource) -> Option<&'a str> {
        let generic_family = match source {
            FontSource::Family(family) => return Some(family.as_str()),
            FontSource::Handle(_) | FontSource::Families(_) | FontSource::List(_) => return None,
            FontSource::Generic(generic_family) => *generic_family,
        };

        let family_id = self
            .collection
            .generic_families(generic_family.into())
            .next();
        family_id.and_then(|id| self.collection.family_name(id))
    }

    /// Sets the fallback font for a given generic family.
    ///
    /// In most cases, these methods do not need to called manually,
    /// as [`parley::fontique`] will automatically select appropriate default fonts based on available system fonts.
    ///
    /// Note that the `parley/system` feature must be enabled to allow automatic system font discovery.
    ///
    /// These methods will return an error if the provided family name does not already exist in the font collection.
    pub fn set_generic_family(
        &mut self,
        generic_family: GenericFontFamily,
        family_name: &str,
    ) -> Result<(), TextError> {
        self.collection
            .family_id(family_name)
            .ok_or(TextError::NoSuchFontFamily(family_name.to_string()))
            .map(|id| {
                self.collection
                    .set_generic_families(generic_family.into(), core::iter::once(id));
                self.generic_families
                    .insert(generic_family, family_name.to_string());
            })
    }

    /// Sets the serif generic family mapping.
    pub fn set_serif_family(&mut self, family_name: &str) -> Result<(), TextError> {
        self.set_generic_family(GenericFontFamily::Serif, family_name)
    }

    /// Sets the sans-serif generic family mapping.
    pub fn set_sans_serif_family(&mut self, family_name: &str) -> Result<(), TextError> {
        self.set_generic_family(GenericFontFamily::SansSerif, family_name)
    }

    /// Sets the cursive generic family mapping.
    pub fn set_cursive_family(&mut self, family_name: &str) -> Result<(), TextError> {
        self.set_generic_family(GenericFontFamily::Cursive, family_name)
    }

    /// Sets the fantasy generic family mapping.
    pub fn set_fantasy_family(&mut self, family_name: &str) -> Result<(), TextError> {
        self.set_generic_family(GenericFontFamily::Fantasy, family_name)
    }

    /// Sets the monospace generic family mapping.
    pub fn set_monospace_family(&mut self, family_name: &str) -> Result<(), TextError> {
        self.set_generic_family(GenericFontFamily::Monospace, family_name)
    }

    /// Sets the system-ui generic family mapping.
    pub fn set_system_ui_family(&mut self, family_name: &str) -> Result<(), TextError> {
        self.set_generic_family(GenericFontFamily::SystemUi, family_name)
    }

    /// Sets the ui-serif generic family mapping.
    pub fn set_ui_serif_family(&mut self, family_name: &str) -> Result<(), TextError> {
        self.set_generic_family(GenericFontFamily::UiSerif, family_name)
    }

    /// Sets the ui-sans-serif generic family mapping.
    pub fn set_ui_sans_serif_family(&mut self, family_name: &str) -> Result<(), TextError> {
        self.set_generic_family(GenericFontFamily::UiSansSerif, family_name)
    }

    /// Sets the ui-monospace generic family mapping.
    pub fn set_ui_monospace_family(&mut self, family_name: &str) -> Result<(), TextError> {
        self.set_generic_family(GenericFontFamily::UiMonospace, family_name)
    }

    /// Sets the ui-rounded generic family mapping.
    pub fn set_ui_rounded_family(&mut self, family_name: &str) -> Result<(), TextError> {
        self.set_generic_family(GenericFontFamily::UiRounded, family_name)
    }

    /// Sets the emoji generic family mapping.
    pub fn set_emoji_family(&mut self, family_name: &str) -> Result<(), TextError> {
        self.set_generic_family(GenericFontFamily::Emoji, family_name)
    }

    /// Sets the math generic family mapping.
    pub fn set_math_family(&mut self, family_name: &str) -> Result<(), TextError> {
        self.set_generic_family(GenericFontFamily::Math, family_name)
    }

    /// Sets the fangsong generic family mapping.
    pub fn set_fang_song_family(&mut self, family_name: &str) -> Result<(), TextError> {
        self.set_generic_family(GenericFontFamily::FangSong, family_name)
    }

    /// Call after clearing the font `Collection` to restore the generic family mappings.
    pub fn restore_generic_families(&mut self) {
        for (generic_family, family_name) in core::mem::take(&mut self.generic_families).iter() {
            if let Err(err) = self.set_generic_family(*generic_family, family_name) {
                bevy_log::warn!(
                    "Failed to restore generic font family mapping: {generic_family:?} -> {family_name}, {err}"
                );
            }
        }
    }
}

/// Text layout context
#[derive(Resource, Default, Deref, DerefMut)]
pub struct LayoutCx(pub LayoutContext<TextBrush>);

/// Text scaler context
#[derive(Resource, Default, Deref, DerefMut)]
pub struct ScaleCx(pub ScaleContext);