Struct FontFeatures 

pub struct FontFeatures { /* private fields */ }

OpenType features for .otf fonts that support them.

Examples features include ligatures, small-caps, and fractional number display. For the complete list of OpenType features, see the spec at <https://learn.microsoft.com/en-us/typography/opentype/spec/featurelist>.

Usage:

use bevy_text::{FontFeatureTag, FontFeatures};

// Create using the builder
let font_features = FontFeatures::builder()
  .enable(FontFeatureTag::STANDARD_LIGATURES)
  .set(FontFeatureTag::WEIGHT, 300)
  .build();

// Create from a list
let more_font_features: FontFeatures = [
  FontFeatureTag::STANDARD_LIGATURES,
  FontFeatureTag::OLDSTYLE_FIGURES,
  FontFeatureTag::TABULAR_FIGURES
].into();

Implementations

impl FontFeatures

pub fn builder() -> FontFeaturesBuilder

Create a new FontFeaturesBuilder.

Examples found in repository

examples/ui/text/text.rs (line 140)

fn setup(mut commands: Commands, asset_server: Res<AssetServer>) {
    // UI camera
    commands.spawn(Camera2d);
    // Text with one section
    commands.spawn((
        // Accepts a `String` or any type that converts into a `String`, such as `&str`
        Text::new("hello\nbevy!"),
        Underline,
        TextFont {
            // This font is loaded and will be used instead of the default font.
            font: asset_server.load("fonts/FiraSans-Bold.ttf").into(),
            // The size of the text will be 20% of the viewport height.
            font_size: FontSize::Vh(20.0),
            ..default()
        },
        TextShadow::default(),
        // Set the justification of the Text
        TextLayout::justify(Justify::Center),
        // Set the style of the Node itself.
        Node {
            position_type: PositionType::Absolute,
            bottom: px(5),
            right: px(5),
            ..default()
        },
        AnimatedText,
    ));

    // Text with multiple sections
    commands
        .spawn((
            // Create a Text with multiple child spans.
            Text::new("FPS: "),
            TextFont {
                // This font is loaded and will be used instead of the default font.
                font: asset_server.load("fonts/FiraSans-Bold.ttf").into(),
                font_size: FontSize::Px(42.0),
                ..default()
            },
        ))
        .with_child((
            TextSpan::default(),
            (
                TextFont {
                    // If the "default_font" feature is unavailable, load a font to use instead.
                    #[cfg(not(feature = "default_font"))]
                    font: asset_server.load("fonts/FiraMono-Medium.ttf").into(),
                    font_size: FontSize::Px(33.0),
                    ..Default::default()
                },
                TextColor(GOLD.into()),
            ),
            FpsText,
        ));

    // Text with OpenType features
    let opentype_font_handle: FontSource =
        asset_server.load("fonts/EBGaramond12-Regular.otf").into();
    commands
        .spawn((
            Node {
                margin: UiRect::all(px(12.0)),
                position_type: PositionType::Absolute,
                top: px(5.0),
                right: px(5.0),
                ..default()
            },
            Text::new("Opentype features:\n"),
            TextFont {
                font: opentype_font_handle.clone(),
                font_size: FontSize::Px(32.0),
                ..default()
            },
        ))
        .with_children(|parent| {
            let text_rows = [
                ("Smallcaps: ", FontFeatureTag::SMALL_CAPS, "Hello World"),
                (
                    "Ligatures: ",
                    FontFeatureTag::STANDARD_LIGATURES,
                    "fi fl ff ffi ffl",
                ),
                ("Fractions: ", FontFeatureTag::FRACTIONS, "12/134"),
                ("Superscript: ", FontFeatureTag::SUPERSCRIPT, "Up here!"),
                ("Subscript: ", FontFeatureTag::SUBSCRIPT, "Down here!"),
                (
                    "Oldstyle figures: ",
                    FontFeatureTag::OLDSTYLE_FIGURES,
                    "1234567890",
                ),
                (
                    "Lining figures: ",
                    FontFeatureTag::LINING_FIGURES,
                    "1234567890",
                ),
            ];

            for (title, feature, text) in text_rows {
                parent.spawn((
                    TextSpan::new(title),
                    TextFont {
                        font: opentype_font_handle.clone(),
                        font_size: FontSize::Px(24.0),
                        ..default()
                    },
                ));
                parent.spawn((
                    TextSpan::new(format!("{text}\n")),
                    TextFont {
                        font: opentype_font_handle.clone(),
                        font_size: FontSize::Px(24.0),
                        font_features: FontFeatures::builder().enable(feature).build(),
                        ..default()
                    },
                ));
            }
        });

    #[cfg(feature = "default_font")]
    commands.spawn((
        // Here we are able to call the `From` method instead of creating a new `TextSection`.
        // This will use the default font (a minimal subset of FiraMono) and apply the default styling.
        Text::new("From an &str into a Text with the default font!"),
        Node {
            position_type: PositionType::Absolute,
            bottom: px(5),
            left: px(15),
            ..default()
        },
    ));

    #[cfg(not(feature = "default_font"))]
    commands.spawn((
        Text::new("Default font disabled"),
        TextFont {
            font: asset_server.load("fonts/FiraMono-Medium.ttf"),
            ..default()
        },
        Node {
            position_type: PositionType::Absolute,
            bottom: px(5),
            left: px(15),
            ..default()
        },
    ));
}

Trait Implementations

impl Clone for FontFeatures

fn clone(&self) -> FontFeatures

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for FontFeatures

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Default for FontFeatures

fn default() -> FontFeatures

Returns the “default value” for a type.

impl<T> From<T> for FontFeatures

where T: IntoIterator<Item = FontFeatureTag>,

Allow FontFeatures to be built from a list. This is suitable for the standard case when each listed feature is a boolean type. If any features require a numeric value (like “wght”), use FontFeaturesBuilder instead.

fn from(value: T) -> FontFeatures

Converts to this type from the input type.

impl FromArg for FontFeatures

type This<'from_arg> = FontFeatures

The type to convert into.

fn from_arg( arg: Arg<'_>, ) -> Result<<FontFeatures as FromArg>::This<'_>, ArgError>

Creates an item from an argument.

impl FromReflect for FontFeatures

fn from_reflect( reflect: &(dyn PartialReflect + 'static), ) -> Option<FontFeatures>

Constructs a concrete instance of Self from a reflected value.

fn take_from_reflect( reflect: Box<dyn PartialReflect>, ) -> Result<Self, Box<dyn PartialReflect>>

Attempts to downcast the given value to Self using, constructing the value using from_reflect if that fails.

impl GetOwnership for FontFeatures

fn ownership() -> Ownership

Returns the ownership of Self.

impl GetTypeRegistration for FontFeatures

fn get_type_registration() -> TypeRegistration

Returns the default TypeRegistration for this type.

fn register_type_dependencies(registry: &mut TypeRegistry)

Registers other types needed by this type.

impl IntoReturn for FontFeatures

fn into_return<'into_return>(self) -> Return<'into_return>

where FontFeatures: 'into_return,

Converts Self into a Return value.

impl PartialEq for FontFeatures

fn eq(&self, other: &FontFeatures) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialReflect for FontFeatures

fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

Returns the TypeInfo of the type represented by this value.

fn try_apply( &mut self, value: &(dyn PartialReflect + 'static), ) -> Result<(), ApplyError>

Tries to apply a reflected value to this value.

fn reflect_kind(&self) -> ReflectKind

Returns a zero-sized enumeration of “kinds” of type.

fn reflect_ref(&self) -> ReflectRef<'_>

Returns an immutable enumeration of “kinds” of type.

fn reflect_mut(&mut self) -> ReflectMut<'_>

Returns a mutable enumeration of “kinds” of type.

fn reflect_owned(self: Box<FontFeatures>) -> ReflectOwned

Returns an owned enumeration of “kinds” of type.

fn try_into_reflect( self: Box<FontFeatures>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

Attempts to cast this type to a boxed, fully-reflected value.

fn try_as_reflect(&self) -> Option<&(dyn Reflect + 'static)>

Attempts to cast this type to a fully-reflected value.

fn try_as_reflect_mut(&mut self) -> Option<&mut (dyn Reflect + 'static)>

Attempts to cast this type to a mutable, fully-reflected value.

fn into_partial_reflect(self: Box<FontFeatures>) -> Box<dyn PartialReflect>

Casts this type to a boxed, reflected value.

fn as_partial_reflect(&self) -> &(dyn PartialReflect + 'static)

Casts this type to a reflected value.

fn as_partial_reflect_mut(&mut self) -> &mut (dyn PartialReflect + 'static)

Casts this type to a mutable, reflected value.

fn reflect_partial_eq( &self, value: &(dyn PartialReflect + 'static), ) -> Option<bool>

Returns a “partial equality” comparison result.

fn reflect_partial_cmp( &self, value: &(dyn PartialReflect + 'static), ) -> Option<Ordering>

Returns a “partial comparison” result.

fn reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>

Attempts to clone Self using reflection.

fn apply(&mut self, value: &(dyn PartialReflect + 'static))

Applies a reflected value to this value.

fn to_dynamic(&self) -> Box<dyn PartialReflect>

Converts this reflected value into its dynamic representation based on its kind.

fn reflect_clone_and_take<T>(&self) -> Result<T, ReflectCloneError>

where T: 'static, Self: Sized + TypePath,

For a type implementing PartialReflect, combines reflect_clone and take in a useful fashion, automatically constructing an appropriate ReflectCloneError if the downcast fails.

fn reflect_hash(&self) -> Option<u64>

Returns a hash of the value (which includes the type).

fn debug(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Debug formatter for the value.

fn is_dynamic(&self) -> bool

Indicates whether or not this type is a dynamic type.

impl Reflect for FontFeatures

fn into_any(self: Box<FontFeatures>) -> Box<dyn Any>

Returns the value as a Box<dyn Any>.

fn as_any(&self) -> &(dyn Any + 'static)

Returns the value as a &dyn Any.

fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

Returns the value as a &mut dyn Any.

fn into_reflect(self: Box<FontFeatures>) -> Box<dyn Reflect>

Casts this type to a boxed, fully-reflected value.

fn as_reflect(&self) -> &(dyn Reflect + 'static)

Casts this type to a fully-reflected value.

fn as_reflect_mut(&mut self) -> &mut (dyn Reflect + 'static)

Casts this type to a mutable, fully-reflected value.

fn set(&mut self, value: Box<dyn Reflect>) -> Result<(), Box<dyn Reflect>>

Performs a type-checked assignment of a reflected value to this value.

impl Struct for FontFeatures

fn field(&self, name: &str) -> Option<&(dyn PartialReflect + 'static)>

Gets a reference to the value of the field named name as a &dyn PartialReflect.

fn field_mut( &mut self, name: &str, ) -> Option<&mut (dyn PartialReflect + 'static)>

Gets a mutable reference to the value of the field named name as a &mut dyn PartialReflect.

fn field_at(&self, index: usize) -> Option<&(dyn PartialReflect + 'static)>

Gets a reference to the value of the field with index index as a &dyn PartialReflect.

fn field_at_mut( &mut self, index: usize, ) -> Option<&mut (dyn PartialReflect + 'static)>

Gets a mutable reference to the value of the field with index index as a &mut dyn PartialReflect.

fn name_at(&self, index: usize) -> Option<&str>

Gets the name of the field with index index.

fn index_of_name(&self, name: &str) -> Option<usize>

Gets the index of the field with the given name.

fn field_len(&self) -> usize

Returns the number of fields in the struct.

fn iter_fields(&self) -> FieldIter<'_>

Returns an iterator over the values of the reflectable fields for this struct.

fn to_dynamic_struct(&self) -> DynamicStruct

Creates a new DynamicStruct from this struct.

fn get_represented_struct_info(&self) -> Option<&'static StructInfo>

Will return None if TypeInfo is not available.

impl StructuralPartialEq for FontFeatures

impl TypePath for FontFeatures

fn type_path() -> &'static str

Returns the fully qualified path of the underlying type.

fn short_type_path() -> &'static str

Returns a short, pretty-print enabled path to the type.

fn type_ident() -> Option<&'static str>

Returns the name of the type, or None if it is anonymous.

fn crate_name() -> Option<&'static str>

Returns the name of the crate the type is in, or None if it is anonymous.

fn module_path() -> Option<&'static str>

Returns the path to the module the type is in, or None if it is anonymous.

impl Typed for FontFeatures

fn type_info() -> &'static TypeInfo

Returns the compile-time info for the underlying type.