Struct Font 

pub struct Font {
    pub inner: Option<Font>,
    pub atlases: HashMap<FontHeight, Atlas, BuildHasherDefault<FxHasher>>,
    pub page_size: usize,
    pub bold: Option<Resource<Font>>,
    pub italic: Option<Resource<Font>>,
    pub bold_italic: Option<Resource<Font>>,
    pub fallbacks: Vec<Option<Resource<Font>>>,
}

A font resource and the associated data required for rendering glyphs from the font.

Fields

inner: Option<Font>

The source font data, such as might come from a ttf file.

atlases: HashMap<FontHeight, Atlas, BuildHasherDefault<FxHasher>>

The atlases containing textures that allow the GPU to render glyphs from this font, or from its fallbacks. Each font size gets its own atlas.

page_size: usize

The size of each atlas page in font pixels. Each page is a square measuring page_size x page_size.

bold: Option<Resource<Font>>

A font representing the bold version of this font.

italic: Option<Resource<Font>>

A font representing the italic version of this font.

bold_italic: Option<Resource<Font>>

A font representing the bold italic version of this font.

fallbacks: Vec<Option<Resource<Font>>>

Fallback fonts are used for rendering special characters that do not have glyphs in this font.

Implementations

impl Font

pub const BOLD: &'static str = "bold"

pub const ITALIC: &'static str = "italic"

pub const BOLD_ITALIC: &'static str = "bold_italic"

pub const FALLBACKS: &'static str = "fallbacks"

impl Font

pub fn name(&self) -> Option<&str>

The name of the font, if available.

pub fn from_memory( data: impl Deref<Target = [u8]>, page_size: usize, styles: FontStyles, fallbacks: Vec<Option<Resource<Font>>>, ) -> Result<Font, &'static str>

Create a font from an u8 array of font data such as one might get from a font file.

pub async fn from_file<P>( path: P, options: FontImportOptions, io: &(dyn ResourceIo + 'static), resource_manager: &ResourceManager, ) -> Result<Font, LoadError>

where P: AsRef<Path>,

Asynchronously read font data from the file at the given path to construct a font.

pub fn glyph(&mut self, unicode: char, height: f32) -> Option<&FontGlyph>

Tries to get a glyph at the given Unicode position of the given height. If there’s no rendered glyph, this method tries to render the glyph and put into a suitable atlas (see Atlas docs for more info). If the given Unicode position has no representation in the font, None will be returned. If the requested size of the glyph is too big to fit into the page size of the font, None will be returned. Keep in mind that this method is free to create as many atlases with any number of pages in them. Each atlas corresponds to a particular glyph size, each glyph in the atlas could be rendered at any page in the atlas.

pub fn ascender(&self, height: f32) -> f32

The highest point of any glyph of this font above the baseline, usually positive.

pub fn descender(&self, height: f32) -> f32

The lowest point of any glyph of this font below the baseline, usually negative.

pub fn horizontal_kerning( &self, height: f32, left: char, right: char, ) -> Option<f32>

The horizontal scaled kerning value for the given two characters, if available, scaled to the given text height. The kerning value is usually negative, and it is added to the advance of the left glyph to bring the right glyph closer when appropriate for some pairs of glyphs.

pub fn page_size(&self) -> usize

The size of each atlas page in font pixels. Each page is a square measuring page_size x page_size.

pub fn glyph_advance(&mut self, unicode: char, height: f32) -> f32

The horizontal distance between the start of the glyph for the given character and the start of the next glyph, when rendered for the given text height.

Trait Implementations

impl Clone for Font

fn clone(&self) -> Font

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Font

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

Formats the value using the given formatter.

impl Default for Font

fn default() -> Font

Returns the “default value” for a type.

impl Reflect for Font

where Font: 'static,

fn source_path() -> &'static str

fn try_clone_box(&self) -> Option<Box<dyn Reflect>>

fn type_name(&self) -> &'static str

fn derived_types() -> &'static [TypeId]

fn query_derived_types(&self) -> &'static [TypeId]

fn doc(&self) -> &'static str

fn assembly_name(&self) -> &'static str

Returns a parent assembly name of the type that implements this trait. WARNING: You should use proc-macro (#[derive(Reflect)]) to ensure that this method will return correct assembly name. In other words - there’s no guarantee, that any implementation other than proc-macro will return a correct name of the assembly. Alternatively, you can use env!("CARGO_PKG_NAME") as an implementation.

fn type_assembly_name() -> &'static str

Returns a parent assembly name of the type that implements this trait. WARNING: You should use proc-macro (#[derive(Reflect)]) to ensure that this method will return correct assembly name. In other words - there’s no guarantee, that any implementation other than proc-macro will return a correct name of the assembly. Alternatively, you can use env!("CARGO_PKG_NAME") as an implementation.

fn fields_ref(&self, func: &mut dyn FnMut(&[FieldRef<'_, '_>]))

fn fields_mut(&mut self, func: &mut dyn FnMut(&mut [FieldMut<'_, '_>]))

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

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

fn as_any(&self, func: &mut dyn FnMut(&(dyn Any + 'static)))

fn as_any_mut(&mut self, func: &mut dyn FnMut(&mut (dyn Any + 'static)))

fn as_reflect(&self, func: &mut dyn FnMut(&(dyn Reflect + 'static)))

fn as_reflect_mut(&mut self, func: &mut dyn FnMut(&mut (dyn Reflect + 'static)))

fn set_field( &mut self, field_name: &str, value: Box<dyn Reflect>, func: &mut dyn FnMut(Result<Box<dyn Reflect>, SetFieldError>), )

Calls user method specified with #[reflect(setter = ..)] or falls back to Reflect::field_mut

fn field( &self, name: &str, func: &mut dyn FnMut(Option<&(dyn Reflect + 'static)>), )

fn field_mut( &mut self, name: &str, func: &mut dyn FnMut(Option<&mut (dyn Reflect + 'static)>), )

fn as_array(&self, func: &mut dyn FnMut(Option<&(dyn ReflectArray + 'static)>))

fn as_array_mut( &mut self, func: &mut dyn FnMut(Option<&mut (dyn ReflectArray + 'static)>), )

fn as_list(&self, func: &mut dyn FnMut(Option<&(dyn ReflectList + 'static)>))

fn as_list_mut( &mut self, func: &mut dyn FnMut(Option<&mut (dyn ReflectList + 'static)>), )

fn as_inheritable_variable( &self, func: &mut dyn FnMut(Option<&(dyn ReflectInheritableVariable + 'static)>), )

fn as_inheritable_variable_mut( &mut self, func: &mut dyn FnMut(Option<&mut (dyn ReflectInheritableVariable + 'static)>), )

fn as_hash_map( &self, func: &mut dyn FnMut(Option<&(dyn ReflectHashMap + 'static)>), )

fn as_hash_map_mut( &mut self, func: &mut dyn FnMut(Option<&mut (dyn ReflectHashMap + 'static)>), )

fn as_handle( &self, func: &mut dyn FnMut(Option<&(dyn ReflectHandle + 'static)>), )

fn as_handle_mut( &mut self, func: &mut dyn FnMut(Option<&mut (dyn ReflectHandle + 'static)>), )

impl ResourceData for Font

fn type_uuid(&self) -> Uuid

Returns unique data type id.

fn save(&mut self, _path: &Path) -> Result<(), Box<dyn Error>>

Saves the resource data a file at the specified path. This method is free to decide how the resource data is saved. This is needed, because there are multiple formats that defines various kinds of resources. For example, a rectangular texture could be saved into a bunch of formats, such as png, bmp, tga, jpg etc., but in the engine it is single Texture resource. In any case, produced file should be compatible with a respective resource loader.

fn can_be_saved(&self) -> bool

Returns true if the resource data can be saved to a file, false - otherwise. Not every resource type supports saving, for example there might be temporary resource type that is used only at runtime which does not need saving at all.

fn try_clone_box(&self) -> Option<Box<dyn ResourceData>>

Tries to clone the resource data. This method can return None if the underlying type is non-cloneable.

impl TypeUuidProvider for Font

fn type_uuid() -> Uuid

Return type UUID.

impl Visit for Font

fn visit(&mut self, name: &str, visitor: &mut Visitor) -> Result<(), VisitError>

Read or write this value, depending on whether Visitor::is_reading() is true or false.