Bevy FontMesh

https://docs.rs/bevy_fontmesh/0.3.0
Admin
A Bevy plugin for generating 3D text meshes from TrueType and OpenType fonts with support for...
Tokens:69,208
Snippets:586
Trust Score:9.1
Update:5 months ago
Show doc for...
Tokens:
Raw
### Quick Start: Basic TextMesh Setup

Source: https://docs.rs/bevy_fontmesh/0.3.0/bevy_fontmesh/index.html

Demonstrates the basic setup for using the FontMeshPlugin to display 3D text. Ensure you have a font file (e.g., 'fonts/font.ttf') in your assets.

```rust
use bevy::prelude::*;
use bevy_fontmesh::prelude::*;

fn main() {
    App::new()
        .add_plugins(DefaultPlugins)
        .add_plugins(FontMeshPlugin::<StandardMaterial>::default())
        .add_systems(Startup, setup)
        .run();
}

fn setup(
    mut commands: Commands,
    asset_server: Res<AssetServer>,
    mut materials: ResMut<Assets<StandardMaterial>>,
) {
    commands.spawn(TextMeshBundle {
        text_mesh: TextMesh {
            text: "Hello!".to_string(),
            font: asset_server.load("fonts/font.ttf"),
            ..default()
        },
        material: MeshMaterial3d(materials.add(StandardMaterial::default())),
        ..default()
    });
}
```

--------------------------------

### JustifyText Usage Examples

Source: https://docs.rs/bevy_fontmesh/0.3.0/bevy_fontmesh/prelude/enum.JustifyText.html

Examples demonstrating how to set the JustifyText alignment in TextMeshStyle.

```APIDOC
## §Examples

```rust
// Left-aligned text (default)
let style = TextMeshStyle {
    justify: JustifyText::Left,
    ..default()
};

// Centered text
let style = TextMeshStyle {
    justify: JustifyText::Center,
    ..default()
};

// Right-aligned text
let style = TextMeshStyle {
    justify: JustifyText::Right,
    ..default()
};
```
```

--------------------------------

### Bevy Plugin Setup: SharedFontMeshPlugin

Source: https://docs.rs/bevy_fontmesh/0.3.0/src/bevy_fontmesh/lib.rs.html

Internal plugin for shared setup like asset loader and system registration. It ensures these are only registered once, even if FontMeshPlugin is added multiple times.

```rust
struct SharedFontMeshPlugin;

impl Plugin for SharedFontMeshPlugin {
    fn build(&self, app: &mut App) {
        app.init_asset::<FontMesh>()
            .init_asset_loader::<FontMeshLoader>()
            .register_type::<TextMesh>()
            .register_type::<TextMeshGlyphs>()
            .register_type::<GlyphMesh>()
            .add_systems(Update, update_text_meshes);
    }
}
```

--------------------------------

### TextMeshGlyphsBundle Usage Example

Source: https://docs.rs/bevy_fontmesh/0.3.0/bevy_fontmesh/struct.TextMeshGlyphsBundle.html

This example demonstrates how to spawn 3D text using TextMeshGlyphsBundle, which creates separate entities for each character.

```APIDOC
## TextMeshGlyphsBundle

Convenience bundle for spawning 3D text with per-character entities.
This bundle is similar to `TextMeshBundle` but uses `TextMeshGlyphs` instead, which spawns separate child entities for each character.

### Example
```rust
commands.spawn(TextMeshGlyphsBundle {
    text_glyphs: TextMeshGlyphs {
        text: "Code".to_string(),
        font: asset_server.load("fonts/font.ttf"),
        style: TextMeshStyle {
            depth: 0.1,
            ..default()
        },
    },
    material: MeshMaterial3d(materials.add(StandardMaterial {
        base_color: Color::WHITE,
        ..default()
    })),
    transform: Transform::from_xyz(0.0, 0.0, 0.0),
    ..default()
});
```

### Fields
*   `text_glyphs: TextMeshGlyphs` - The text glyphs component that drives per-character mesh generation.
*   `material: MeshMaterial3d<M>` - Default material for glyph meshes (can be overridden per-glyph).
*   `transform: Transform` - Local transform of the parent entity.
*   `global_transform: GlobalTransform` - Global transform (computed automatically).
*   `visibility: Visibility` - Visibility of the entity.
*   `inherited_visibility: InheritedVisibility` - Inherited visibility (computed automatically).
*   `view_visibility: ViewVisibility` - View visibility (computed automatically).
```

--------------------------------

### Basic TextMesh Usage

Source: https://docs.rs/bevy_fontmesh/0.3.0/bevy_fontmesh/prelude/struct.TextMesh.html

Example of spawning an entity with a TextMesh component to display "Hello, World!".

```APIDOC
```rust
commands.spawn(TextMeshBundle::<StandardMaterial> {
    text_mesh: TextMesh {
        text: "Hello, World!".to_string(),
        font: asset_server.load("fonts/font.ttf"),
        style: TextMeshStyle {
            depth: 0.5,
            subdivision: 25,
            anchor: TextAnchor::Center,
            justify: JustifyText::Center,
        },
    },
    ..default()
});
```
```

--------------------------------

### Spawn TextMesh Bundle

Source: https://docs.rs/bevy_fontmesh/0.3.0/bevy_fontmesh/prelude/struct.TextMesh.html

Example of spawning an entity with a TextMeshBundle, configuring basic text properties and style.

```rust
commands.spawn(TextMeshBundle::<StandardMaterial> {
    text_mesh: TextMesh {
        text: "Hello, World!".to_string(),
        font: asset_server.load("fonts/font.ttf"),
        style: TextMeshStyle {
            depth: 0.5,
            subdivision: 25,
            anchor: TextAnchor::Center,
            justify: JustifyText::Center,
        },
    },
    ..default()
});
```

--------------------------------

### Spawning a TextMeshBundle Entity

Source: https://docs.rs/bevy_fontmesh/0.3.0/bevy_fontmesh/prelude/struct.TextMeshBundle.html

Example demonstrating how to spawn an entity with a TextMeshBundle, configuring text content, font, style, material, and transform.

```rust
commands.spawn(TextMeshBundle {
    text_mesh: TextMesh {
        text: "Hello, Bevy!".to_string(),
        font: asset_server.load("fonts/font.ttf"),
        style: TextMeshStyle {
            depth: 0.5,
            anchor: TextAnchor::Center,
            ..default()
        },
    },
    material: MeshMaterial3d(materials.add(StandardMaterial {
        base_color: Color::srgb(1.0, 0.5, 0.2),
        ..default()
    })),
    transform: Transform::from_xyz(0.0, 1.0, 0.0),
    ..default()
});
```

--------------------------------

### TextMeshStyle with JustifyText Examples

Source: https://docs.rs/bevy_fontmesh/0.3.0/bevy_fontmesh/prelude/enum.JustifyText.html

Demonstrates setting the justify field in TextMeshStyle for different alignment options.

```rust
// Left-aligned text (default)
let style = TextMeshStyle {
    justify: JustifyText::Left,
    ..default()
};

```

```rust
// Centered text
let style = TextMeshStyle {
    justify: JustifyText::Center,
    ..default()
};

```

```rust
// Right-aligned text
let style = TextMeshStyle {
    justify: JustifyText::Right,
    ..default()
};

```

--------------------------------

### Creating TextMeshStyle Instances

Source: https://docs.rs/bevy_fontmesh/0.3.0/bevy_fontmesh/prelude/struct.TextMeshStyle.html

Examples demonstrating how to create TextMeshStyle instances for different visual effects, from flat 2D text to deep 3D text and low-poly styles.

```rust
// Flat 2D-style text
let flat = TextMeshStyle {
    depth: 0.0,
    subdivision: 15,
    ..default()
};

// Deep 3D text with high quality curves
let deep = TextMeshStyle {
    depth: 1.0,
    subdivision: 30,
    anchor: TextAnchor::Center,
    justify: JustifyText::Center,
};

// Low-poly stylized text
let lowpoly = TextMeshStyle {
    depth: 0.2,
    subdivision: 5,
    ..default()
};
```

--------------------------------

### TextAnchor Usage Examples

Source: https://docs.rs/bevy_fontmesh/0.3.0/bevy_fontmesh/prelude/enum.TextAnchor.html

Illustrates how to use different TextAnchor variants when defining a TextMeshStyle.

```APIDOC
## Examples

```rust
// Text centered on its transform
let style = TextMeshStyle {
    anchor: TextAnchor::Center,
    ..default()
};

// Text positioned by its top-left corner
let style = TextMeshStyle {
    anchor: TextAnchor::TopLeft,
    ..default()
};

// Custom pivot point at 25% from left, 75% from bottom
let style = TextMeshStyle {
    anchor: TextAnchor::Custom(Vec2::new(0.25, 0.75)),
    ..default()
};
```
```

--------------------------------

### TextMeshGlyphsBundle Example

Source: https://docs.rs/bevy_fontmesh/0.3.0/src/bevy_fontmesh/component.rs.html

Convenience bundle for spawning 3D text with per-character entities using TextMeshGlyphs. This is an alternative to TextMeshBundle for scenarios requiring individual character control.

```rust
/// Convenience bundle for spawning 3D text with per-character entities.
///
/// This bundle is similar to [`TextMeshBundle`] but uses [`TextMeshGlyphs`] instead,
/// which spawns separate child entities for each character.
///
/// # Examples
///
/// ```no_run
/// # use bevy::prelude::*;
/// # use bevy_fontmesh::prelude::*;
/// # fn example( 
/// #     mut commands: Commands,
/// #     asset_server: Res<AssetServer>,
/// #     mut materials: ResMut<Assets<StandardMaterial>>,
/// # ) {
/// 
/// # }
/// ```

```

--------------------------------

### Spawning TextMeshGlyphsBundle

Source: https://docs.rs/bevy_fontmesh/0.3.0/bevy_fontmesh/prelude/struct.TextMeshGlyphs.html

Example of how to spawn a TextMeshGlyphsBundle in Bevy. This bundle includes the TextMeshGlyphs component and a default material. The font is loaded using the asset server.

```rust
commands.spawn(TextMeshGlyphsBundle {
    text_glyphs: TextMeshGlyphs {
        text: "Hello".to_string(),
        font: asset_server.load("fonts/font.ttf"),
        style: TextMeshStyle::default(),
    },
    // Default material for all glyphs (can be overridden per-glyph)
    material: MeshMaterial3d(materials.add(StandardMaterial::default())),
    ..default()
});
```

--------------------------------

### Multiline TextMesh Usage

Source: https://docs.rs/bevy_fontmesh/0.3.0/bevy_fontmesh/prelude/struct.TextMesh.html

Example demonstrating how to create multiline text using newline characters (`\n`) within the TextMesh component.

```APIDOC
```rust
commands.spawn(TextMeshBundle::<StandardMaterial> {
    text_mesh: TextMesh {
        text: "Line 1\nLine 2\nLine 3".to_string(),
        font: asset_server.load("fonts/font.ttf"),
        ..default()
    },
    ..default()
});
```
```

--------------------------------

### TextMeshStyle for Visual Styling

Source: https://docs.rs/bevy_fontmesh/0.3.0/src/bevy_fontmesh/component.rs.html

Defines visual styling parameters for generated text meshes, including extrusion depth, curve smoothness, and positioning anchors. Provides examples for flat 2D-style and deep 3D text.

```rust
/// Visual styling parameters for generated text meshes.
///
/// Controls the 3D extrusion depth, curve smoothness, positioning, and alignment
/// of the generated mesh geometry.
///
/// # Examples
///
/// ```
/// # use bevy_fontmesh::prelude::*;
/// # use bevy::prelude::default;
/// // Flat 2D-style text
/// let flat = TextMeshStyle {
///     depth: 0.0,
///     subdivision: 15,
///     ..default()
/// };
///
/// // Deep 3D text with high quality curves
/// let deep = TextMeshStyle {
///     depth: 1.0,
///     subdivision: 30,
///     anchor: TextAnchor::Center,

```

--------------------------------

### FontMesh Structure and Loading

Source: https://docs.rs/bevy_fontmesh/0.3.0/src/bevy_fontmesh/asset.rs.html

Defines the FontMesh asset which holds raw font data and provides examples of how to load it using Bevy's AssetServer.

```APIDOC
## FontMesh Asset

### Description
Asset containing font data for 3D text mesh generation. This asset type holds the raw bytes of a TrueType font file. Fonts are automatically loaded from the asset server and used by the `TextMesh` component to generate 3D mesh geometry.

### Supported Formats
- TrueType (`.ttf`)
- Some OpenType fonts (`.otf`) with TrueType outlines.

### Loading Fonts

Fonts are loaded like any other Bevy asset:

```no_run
use bevy::prelude::*;
use bevy_fontmesh::FontMesh;

fn example(asset_server: Res<AssetServer>) {
    let font: Handle<FontMesh> = asset_server.load("fonts/MyFont.ttf");
}
```

Place your font files in the `assets/fonts/` directory (or any subdirectory of `assets/`).

### Asset Structure

```rust
#[derive(Asset, TypePath, Debug)]
pub struct FontMesh {
    /// Raw font file data in TTF or OTF format.
    pub data: Vec<u8>,
}
```
```

--------------------------------

### Using TextAnchor for Text Styling

Source: https://docs.rs/bevy_fontmesh/0.3.0/bevy_fontmesh/prelude/enum.TextAnchor.html

Examples demonstrating how to set the TextAnchor in TextMeshStyle for different text alignments. This controls the pivot point for text rendering.

```rust
// Text centered on its transform
let style = TextMeshStyle {
    anchor: TextAnchor::Center,
    ..default()
};

// Text positioned by its top-left corner
let style = TextMeshStyle {
    anchor: TextAnchor::TopLeft,
    ..default()
};

// Custom pivot point at 25% from left, 75% from bottom
let style = TextMeshStyle {
    anchor: TextAnchor::Custom(Vec2::new(0.25, 0.75)),
    ..default()
};
```

--------------------------------

### GetField Implementations

Source: https://docs.rs/bevy_fontmesh/0.3.0/bevy_fontmesh/prelude/struct.TextMeshStyle.html

Provides methods to get struct fields by name.

```APIDOC
## fn get_field<T>(&self, name: &str) -> Option<&T>

Returns a reference to the value of the field named `name`, downcast to `T`.
```

```APIDOC
## fn get_field_mut<T>(&mut self, name: &str) -> Option<&mut T>

Returns a mutable reference to the value of the field named `name`, downcast to `T`.
```

--------------------------------

### Loading Fonts

Source: https://docs.rs/bevy_fontmesh/0.3.0/bevy_fontmesh/prelude/struct.FontMesh.html

Demonstrates how to load FontMesh assets using Bevy's asset server.

```APIDOC
## Loading Fonts

Fonts are loaded like any other Bevy asset:

```rust
let font: Handle<FontMesh> = asset_server.load("fonts/MyFont.ttf");
```

Place your font files in the `assets/fonts/` directory (or any subdirectory of `assets/`).
```

--------------------------------

### GetField Trait Implementation

Source: https://docs.rs/bevy_fontmesh/0.3.0/bevy_fontmesh/struct.TextMesh.html

Allows getting field values by name from TextMesh.

```APIDOC
### impl<S> GetField for S

#### fn get_field<T>(&self, name: &str) -> Option<&T>
where T: Reflect,
Returns a reference to the value of the field named `name`, downcast to `T`.
```

--------------------------------

### DynamicTyped Trait Implementation

Source: https://docs.rs/bevy_fontmesh/0.3.0/bevy_fontmesh/struct.TextMesh.html

Provides methods for getting type information dynamically.

```APIDOC
### impl<T> DynamicTyped for T

#### fn reflect_type_info(&self) -> &'static TypeInfo
See `Typed::type_info`.
```

--------------------------------

### DynamicTypePath Trait Implementation

Source: https://docs.rs/bevy_fontmesh/0.3.0/bevy_fontmesh/struct.TextMesh.html

Provides methods for getting the type path of TextMesh.

```APIDOC
### impl<T> DynamicTypePath for T

#### fn reflect_type_path(&self) -> &str
See `TypePath::type_path`.
#### fn reflect_short_type_path(&self) -> &str
See `TypePath::short_type_path`.
```

--------------------------------

### Type ID Access

Source: https://docs.rs/bevy_fontmesh/0.3.0/bevy_fontmesh/prelude/struct.GlyphMesh.html

Provides a way to get the TypeId of a GlyphMesh instance.

```APIDOC
## fn type_id(&self) -> TypeId

### Description
Gets the `TypeId` of `self`.

### Method
`type_id`
```

--------------------------------

### Typed for TextAnchor

Source: https://docs.rs/bevy_fontmesh/0.3.0/bevy_fontmesh/prelude/enum.TextAnchor.html

Provides method to get compile-time type information for TextAnchor.

```APIDOC
## impl Typed for TextAnchor

### Methods

- `fn type_info() -> &'static TypeInfo`: Returns the compile-time info for the underlying type.
```

--------------------------------

### CloneToUninit

Source: https://docs.rs/bevy_fontmesh/0.3.0/bevy_fontmesh/prelude/struct.TextMeshStyle.html

Nightly-only experimental API for performing copy-assignment to uninitialized memory.

```APIDOC
## unsafe fn clone_to_uninit(&self, dest: *mut u8)

Performs copy-assignment from `self` to `dest`.
```

--------------------------------

### Bundle Component IDs

Source: https://docs.rs/bevy_fontmesh/0.3.0/bevy_fontmesh/prelude/struct.GlyphMesh.html

Provides methods to get component IDs for bundles containing GlyphMesh.

```APIDOC
## fn component_ids( components: &mut ComponentsRegistrator<'_>, ) -> impl Iterator<Item = ComponentId> + use<C>

### Description
Returns an iterator over this `Bundle`’s component IDs.

### Method
`component_ids`
```

```APIDOC
## fn get_component_ids( components: &Components, ) -> impl Iterator<Item = Option<ComponentId>>

### Description
Return a iterator over this `Bundle`’s component ids. This will be `None` if the component has not been registered.

### Method
`get_component_ids`
```

--------------------------------

### Loading a FontMesh asset

Source: https://docs.rs/bevy_fontmesh/0.3.0/bevy_fontmesh/prelude/struct.FontMesh.html

Demonstrates how to load a FontMesh asset using Bevy's asset server. Ensure font files are placed in the 'assets/fonts/' directory.

```rust
let font: Handle<FontMesh> = asset_server.load("fonts/MyFont.ttf");
```

--------------------------------

### Bundle Creation from Components

Source: https://docs.rs/bevy_fontmesh/0.3.0/bevy_fontmesh/prelude/struct.GlyphMesh.html

Allows creating a GlyphMesh bundle from components.

```APIDOC
## unsafe fn from_components<T, F>(ctx: &mut T, func: &mut F) -> C

### Description
Creates a bundle from components.

### Method
`from_components`
```

--------------------------------

### JustifyText Type Information

Source: https://docs.rs/bevy_fontmesh/0.3.0/bevy_fontmesh/enum.JustifyText.html

This section details how to get compile-time type information for the JustifyText enum.

```APIDOC
## JustifyText Type Info

### `type_info() -> &'static TypeInfo`
Returns the compile-time info for the underlying type.
```

--------------------------------

### Load FontMesh Asset

Source: https://docs.rs/bevy_fontmesh/0.3.0/src/bevy_fontmesh/asset.rs.html

Demonstrates how to load a FontMesh asset using Bevy's AssetServer. Ensure font files are placed in the assets directory.

```rust
use bevy::prelude::*
use bevy_fontmesh::FontMesh

fn example(asset_server: Res<AssetServer>) {
    let font: Handle<FontMesh> = asset_server.load("fonts/MyFont.ttf");
}
```

--------------------------------

### Field Access

Source: https://docs.rs/bevy_fontmesh/0.3.0/bevy_fontmesh/struct.TextMeshGlyphs.html

Provides methods to get and set fields of TextMeshGlyphs by name, with optional downcasting to specific types.

```APIDOC
## fn get_field<T>(&self, name: &str) -> Option<&T>

Returns a reference to the value of the field named `name`, downcast to `T`.

### Parameters
- `name` (str): The name of the field to retrieve.

### Returns
- `Option<&T>`: A reference to the field if found and downcastable, otherwise `None`.
```

```APIDOC
## fn get_field_mut<T>(&mut self, name: &str) -> Option<&mut T>

Returns a mutable reference to the value of the field named `name`, downcast to `T`.

### Parameters
- `name` (str): The name of the field to retrieve.

### Returns
- `Option<&mut T>`: A mutable reference to the field if found and downcastable, otherwise `None`.
```

--------------------------------

### Spawn TextMeshGlyphsBundle

Source: https://docs.rs/bevy_fontmesh/0.3.0/bevy_fontmesh/prelude/struct.TextMeshGlyphsBundle.html

Use this bundle to spawn 3D text with per-character entities. Ensure you have loaded a font and have access to the asset server and materials.

```rust
commands.spawn(TextMeshGlyphsBundle {
    text_glyphs: TextMeshGlyphs {
        text: "Code".to_string(),
        font: asset_server.load("fonts/font.ttf"),
        style: TextMeshStyle {
            depth: 0.1,
            ..default()
        },
    },
    material: MeshMaterial3d(materials.add(StandardMaterial {
        base_color: Color::WHITE,
        ..default()
    })),
    transform: Transform::from_xyz(0.0, 0.0, 0.0),
    ..default()
});
```

--------------------------------

### Into Implementation

Source: https://docs.rs/bevy_fontmesh/0.3.0/bevy_fontmesh/prelude/struct.TextMeshStyle.html

Provides a conversion from one type to another using `From` trait.

```APIDOC
## fn into(self) -> U

Calls `U::from(self)`.
```

--------------------------------

### GlyphMesh Get Represented Type Info

Source: https://docs.rs/bevy_fontmesh/0.3.0/bevy_fontmesh/struct.GlyphMesh.html

Illustrates the `get_represented_type_info` method, which returns the `TypeInfo` of the type represented by a GlyphMesh instance.

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

--------------------------------

### GlyphMesh Get Type Registration

Source: https://docs.rs/bevy_fontmesh/0.3.0/bevy_fontmesh/struct.GlyphMesh.html

Shows the `get_type_registration` method, which provides the default type registration information for the GlyphMesh struct.

```rust
fn get_type_registration() -> TypeRegistration
```

--------------------------------

### Generic Type Implementation: CloneToUninit (Nightly)

Source: https://docs.rs/bevy_fontmesh/0.3.0/bevy_fontmesh/struct.GlyphMetrics.html

Nightly experimental API for cloning into uninitialized memory.

```rust
unsafe fn clone_to_uninit(&self, dest: *mut u8)
```

--------------------------------

### TryFrom and TryInto Conversions

Source: https://docs.rs/bevy_fontmesh/0.3.0/bevy_fontmesh/struct.FontMetrics.html

Methods for attempting conversions between types, returning a Result.

```APIDOC
## fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.

## fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
```

--------------------------------

### Get Type ID

Source: https://docs.rs/bevy_fontmesh/0.3.0/bevy_fontmesh/prelude/struct.TextMeshGlyphsComputed.html

This method, part of the Any trait implementation, returns the `TypeId` of the TextMeshGlyphsComputed component. This is useful for runtime type identification.

```rust
fn type_id(&self) -> TypeId
```

--------------------------------

### FontMeshPlugin Usage

Source: https://docs.rs/bevy_fontmesh/0.3.0/bevy_fontmesh/struct.FontMeshPlugin.html

Demonstrates how to add the FontMeshPlugin to a Bevy application. It shows the default usage with StandardMaterial and how to add it with a custom material.

```APIDOC
## FontMeshPlugin Usage

### Description
This section provides examples of how to integrate the `FontMeshPlugin` into your Bevy application. It covers both the default usage with `StandardMaterial` and the scenario where you need to use a custom material.

### Default Usage
```rust
use bevy::prelude::*;
use bevy_fontmesh::FontMeshPlugin;

App::new()
    .add_plugins(DefaultPlugins)
    .add_plugins(FontMeshPlugin::<StandardMaterial>::default())
    .run();
```

### Custom Material Usage
For custom materials, add the plugin again with your material type:

```rust
use bevy::prelude::*;
use bevy_fontmesh::FontMeshPlugin;

App::new()
    .add_plugins(DefaultPlugins)
    .add_plugins(FontMeshPlugin::<StandardMaterial>::default())
    .add_plugins(FontMeshPlugin::<MyCustomMaterial>::default())
    .run();
```

### Plugin Functionality
The plugin automatically handles the following:

*   Registers the `FontMesh` asset type for loading TTF/OTF fonts (once, on first add).
*   Adds a system that generates meshes when `TextMesh` components are added or changed.
*   Adds a system that generates per-glyph meshes for `TextMeshGlyphs` using the specified material `M`.
*   Enables reflection for `TextMesh` components for editor integration.
```

--------------------------------

### Registering Required Components for GlyphMesh

Source: https://docs.rs/bevy_fontmesh/0.3.0/bevy_fontmesh/struct.GlyphMesh.html

Shows the method signature for registering components required by GlyphMesh during Bevy's type registration process.

```rust
fn register_required_components(
        _requiree: ComponentId,
        required_components: &mut RequiredComponentsRegistrator<'_, '_>,
    )
```

--------------------------------

### Get Glyph Metrics

Source: https://docs.rs/bevy_fontmesh/0.3.0/src/bevy_fontmesh/asset.rs.html

Retrieves metrics for a specific character from a loaded FontMesh. Returns None if the character is not found or the font data is invalid.

```rust
use bevy::prelude::*
use bevy_fontmesh::FontMesh

fn example(font_assets: Res<Assets<FontMesh>>, font_handle: Handle<FontMesh>) {
    if let Some(font) = font_assets.get(&font_handle) {
        if let Some(metrics) = font.glyph_metrics('A') {
            println!("Advance width of 'A': {}", metrics.advance);
        }
    }
}
```

--------------------------------

### Subscriber and Settings

Source: https://docs.rs/bevy_fontmesh/0.3.0/bevy_fontmesh/struct.TextMesh.html

Methods for attaching subscribers and managing settings.

```APIDOC
## `with_subscriber`

### Description
Attaches the provided `Subscriber` to this type, returning a `WithDispatch` wrapper.

### Signature
```rust
fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where S: Into<Dispatch>
```
```

```APIDOC
## `with_current_subscriber`

### Description
Attaches the current default `Subscriber` to this type, returning a `WithDispatch` wrapper.

### Signature
```rust
fn with_current_subscriber(self) -> WithDispatch<Self>
```
```

```APIDOC
## `Settings` Trait

### Description
Trait for types that can be configured with specific settings.

### Constraints
`T: 'static + Send + Sync`
```

--------------------------------

### Type Witness and Equality

Source: https://docs.rs/bevy_fontmesh/0.3.0/bevy_fontmesh/prelude/struct.TextMeshGlyphs.html

Utilities for working with type information and proving type equality.

```APIDOC
## const WITNESS: W = W::MAKE

A constant of the type witness.

## const TYPE_EQ: TypeEq<T, <T as Identity>::Type> = TypeEq::NEW

Proof that `Self` is the same type as `Self::Type`, provides methods for casting between `Self` and `Self::Type`.

#### type Type = T

The same type as `Self`, used to emulate type equality bounds (`T == U`) with associated type equality constraints (`T: Identity<Type = U>`).
```

--------------------------------

### TryFrom

Source: https://docs.rs/bevy_fontmesh/0.3.0/bevy_fontmesh/struct.GlyphMetrics.html

Provides a fallible conversion from one type to another.

```APIDOC
## type Error = Infallible
The type returned in the event of a conversion error.
```

```APIDOC
## fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
Performs the conversion.
```

--------------------------------

### TryFrom and TryInto Implementations

Source: https://docs.rs/bevy_fontmesh/0.3.0/bevy_fontmesh/prelude/struct.TextMeshComputed.html

Enables fallible type conversions between types.

```APIDOC
## type Error = Infallible

The type returned in the event of a conversion error.
```

```APIDOC
## fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
```

```APIDOC
## type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
```

```APIDOC
## fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
```

--------------------------------

### Get character positions in text

Source: https://docs.rs/bevy_fontmesh/0.3.0/bevy_fontmesh/prelude/struct.FontMesh.html

Generates a vector of (character_index, x_position) pairs for each character in a line of text. This is useful for tasks like cursor positioning.

```rust
if let Some(font) = font_assets.get(&font_handle) {
    let positions = font.char_positions("Hello");
    for (idx, x) in positions {
        println!("Char {} at x={}", idx, x);
    }
}
```

--------------------------------

### Get font-level metrics

Source: https://docs.rs/bevy_fontmesh/0.3.0/bevy_fontmesh/prelude/struct.FontMesh.html

Retrieves overall font metrics such as line height, ascender, and descender from a FontMesh. Returns None if the font data is invalid.

```rust
if let Some(font) = font_assets.get(&font_handle) {
    if let Some(metrics) = font.font_metrics() {
        println!("Line height: {}", metrics.line_height);
    }
}
```

--------------------------------

### Into Conversions

Source: https://docs.rs/bevy_fontmesh/0.3.0/bevy_fontmesh/struct.FontMesh.html

Methods for converting between types using `From` trait.

```APIDOC
## fn into(self) -> U

Calls `U::from(self)`. That is, this conversion is whatever the implementation of `From<T> for U` chooses to do.
```

--------------------------------

### GlyphMesh Blanket Implementations

Source: https://docs.rs/bevy_fontmesh/0.3.0/bevy_fontmesh/struct.GlyphMesh.html

Details blanket implementations for GlyphMesh, showing how it integrates with other Bevy and Rust features.

```APIDOC
## Blanket Implementations

### impl<T> Any for T

#### fn type_id(&self) -> TypeId
Gets the `TypeId` of `self`.

### impl<T, U> AsBindGroupShaderType<U> for T

#### fn as_bind_group_shader_type(&self, _images: &RenderAssets<GpuImage>) -> U
Return the `T` `ShaderType` for `self`. When used in `AsBindGroup` derives, it is safe to assume that all images in `self` exist.

### impl<T> Borrow<T> for T

#### fn borrow(&self) -> &T
Immutably borrows from an owned value.

### impl<T> BorrowMut<T> for T

#### fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value.

### impl<C> Bundle for C

#### fn component_ids( components: &mut ComponentsRegistrator<'_>, ) -> impl Iterator<Item = ComponentId>
#### fn get_component_ids( components: &Components, ) -> impl Iterator<Item = Option<ComponentId>>
Return a iterator over this `Bundle`’s component ids. This will be `None` if the component has not been registered.

### impl<C> BundleFromComponents for C

#### unsafe fn from_components<T, F>(ctx: &mut T, func: &mut F) -> C

### impl<T> CloneToUninit for T

#### unsafe fn clone_to_uninit(&self, dest: *mut u8)
Performs copy-assignment from `self` to `dest`.

### impl<T> Downcast for T

#### fn into_any(self: Box<T>) -> Box<dyn Any>
Converts `Box<dyn Trait>` (where `Trait: Downcast`) to `Box<dyn Any>`, which can then be `downcast` into `Box<dyn ConcreteType>` where `ConcreteType` implements `Trait`.
#### fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>
Converts `Rc<Trait>` (where `Trait: Downcast`) to `Rc<Any>`, which can then be further `downcast` into `Rc<ConcreteType>` where `ConcreteType` implements `Trait`.
#### fn as_any(&self) -> &(dyn Any + 'static)
Converts `&Trait` (where `Trait: Downcast`) to `&Any`. This is needed since Rust cannot generate `&Any`’s vtable from `&Trait`’s.
#### fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)
Converts `&mut Trait` (where `Trait: Downcast`) to `&Any`. This is needed since Rust cannot generate `&mut Any`’s vtable from `&mut Trait`’s.

### impl<T> DowncastSend for T

#### fn into_any_send(self: Box<T>) -> Box<dyn Any + Send>
Converts `Box<Trait>` (where `Trait: DowncastSend`) to `Box<dyn Any + Send>`, which can then be `downcast` into `Box<ConcreteType>` where `ConcreteType` implements `Trait`.

### impl<C> DynamicBundle for C

#### type Effect = ()
#### unsafe fn get_components( ptr: MovingPtr<'_, C>, func: &mut impl FnMut(StorageType, OwningPtr<'_>), ) -> <C as DynamicBundle>::Effect
Moves the components out of the bundle.
#### unsafe fn apply_effect( _ptr: MovingPtr<'_, MaybeUninit<C>>, _entity: &mut EntityWorldMut<'_>, )
Applies the after-effects of spawning this bundle.

### impl<T> DynamicTypePath for T

#### fn reflect_type_path(&self) -> &str
See `TypePath::type_path`.
#### fn reflect_short_type_path(&self) -> &str
See `TypePath::short_type_path`.
#### fn reflect_type_ident(&self) -> Option<&str>
See `TypePath::type_ident`.
#### fn reflect_crate_name(&self) -> Option<&str>
See `TypePath::crate_name`.
#### fn reflect_module_path(&self) -> Option<&str>
See `TypePath::module_path`.

### impl<T> DynamicTyped for T

#### fn reflect_type_info(&self) -> &'static TypeInfo
See `Typed::type_info`.

### impl<T> From<T> for T

#### fn from(t: T) -> T
Returns the argument unchanged.

### impl<S> GetField for S

#### fn get_field<T>(&self, name: &str) -> Option<&T>
Returns a reference to the value of the field named `name`, downcast to `T`.
#### fn get_field_mut<T>(&mut self, name: &str) -> Option<&mut T>
Returns a mutable reference to the value of the field named `name`, downcast to `T`.
```

--------------------------------

### Bundle Get Component IDs

Source: https://docs.rs/bevy_fontmesh/0.3.0/bevy_fontmesh/prelude/struct.TextMeshGlyphsComputed.html

This method, also from the Bundle trait, returns an iterator over `Option<ComponentId>` for each component in the bundle. It returns `None` if a component has not been registered.

```rust
fn get_component_ids( components: &Components, ) -> impl Iterator<Item = Option<ComponentId>>
```

--------------------------------

### FromWorld Trait Implementation

Source: https://docs.rs/bevy_fontmesh/0.3.0/bevy_fontmesh/struct.TextMesh.html

Allows creating TextMesh from the Bevy world.

```APIDOC
### impl<T> FromWorld for T

#### fn from_world(_world: &mut World) -> T
Creates `Self` using `default()`.
```

--------------------------------

### Get glyph metrics for a character

Source: https://docs.rs/bevy_fontmesh/0.3.0/bevy_fontmesh/prelude/struct.FontMesh.html

Retrieves the metrics (like advance width) for a specific character from a loaded FontMesh. Returns None if the character is not found in the font.

```rust
if let Some(font) = font_assets.get(&font_handle) {
    if let Some(metrics) = font.glyph_metrics('A') {
        println!("Advance width of 'A': {}", metrics.advance);
    }
}
```

--------------------------------

### Reference to Any Conversions

Source: https://docs.rs/bevy_fontmesh/0.3.0/bevy_fontmesh/prelude/struct.FontMesh.html

Provides methods to convert references to trait objects into references to dyn Any.

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

Converts `&Trait` (where `Trait: Downcast`) to `&Any`. This is needed since Rust cannot generate `&Any`’s vtable from `&Trait`’s.
```

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

Converts `&mut Trait` (where `Trait: Downcast`) to `&Any`. This is needed since Rust cannot generate `&mut Any`’s vtable from `&mut Trait`’s.
```

--------------------------------

### TextMesh General Trait Implementations

Source: https://docs.rs/bevy_fontmesh/0.3.0/bevy_fontmesh/prelude/struct.TextMesh.html

Covers general trait implementations for TextMesh, such as `From`, `FromWorld`, and `GetField`, which facilitate its creation, initialization, and field access.

```APIDOC
## TextMesh General Implementations

### `From<T>`

- `from(t: T) -> T`: Returns the argument unchanged.

### `FromWorld`

- `from_world(_world: &mut World) -> T`: Creates `Self` using `default()`.

### `GetField`

- `get_field<T>(&self, name: &str) -> Option<&T>`: Returns a reference to the value of the field named `name`, downcast to `T`.
```

--------------------------------

### Borrow Implementations

Source: https://docs.rs/bevy_fontmesh/0.3.0/bevy_fontmesh/prelude/struct.TextMeshStyle.html

Provides methods for immutably and mutably borrowing values.

```APIDOC
## fn borrow(&self) -> &T

Immutably borrows from an owned value.
```

```APIDOC
## fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value.
```

--------------------------------

### Get character positions for a line of text

Source: https://docs.rs/bevy_fontmesh/0.3.0/src/bevy_fontmesh/asset.rs.html

Returns a vector of (char_index, x_position) pairs for each character in a string. Useful for cursor positioning in text editors. Handles potential font parsing errors by returning an empty vector.

```rust
/// Get character positions for a line of text.
///
/// Returns a vector of (char_index, x_position) pairs for each character.
/// Useful for cursor positioning in text editors.
///
/// # Example
///
/// ```no_run
/// # use bevy::prelude::*
/// # use bevy_fontmesh::FontMesh;
/// # fn example(font_assets: Res<Assets<FontMesh>>, font_handle: Handle<FontMesh>) {
/// if let Some(font) = font_assets.get(&font_handle) {
///     let positions = font.char_positions("Hello");
///     for (idx, x) in positions {
///         println!("Char {} at x={}", idx, x);
///     }
/// }
/// # }
/// ```
pub fn char_positions(&self, text: &str) -> Vec<(usize, f32)> {
        let face = match fontmesh::parse_font(&self.data) {
            Ok(f) => f,
            Err(_) => return Vec::new(),
        };

        text.chars()
            .enumerate()
            .scan(0.0, |x, (idx, ch)| {
                let current_x = *x;
                *x += fontmesh::glyph_advance(&face, ch).unwrap_or_else(|| {
                    if ch.is_whitespace() {
                        // Use font metrics for a proportional fallback space width
                        (fontmesh::ascender(&face) - fontmesh::descender(&face)) * 0.25
                    } else {
                        0.0
                    }
                });
                Some((idx, current_x))
            })
            .collect()
    }
```

--------------------------------

### Custom Materials with FontMeshPlugin

Source: https://docs.rs/bevy_fontmesh/0.3.0/bevy_fontmesh/index.html

Shows how to add the FontMeshPlugin multiple times to support different custom material types for text meshes. This is useful when you need distinct material properties for different text elements.

```rust
use bevy::prelude::*;
use bevy_fontmesh::FontMeshPlugin;

App::new()
    .add_plugins(DefaultPlugins)
    .add_plugins(FontMeshPlugin::<StandardMaterial>::default())
    .add_plugins(FontMeshPlugin::<MyCustomMaterial>::default())
    .run();
```

--------------------------------

### Bevy Plugin: FontMeshPlugin for 3D Text

Source: https://docs.rs/bevy_fontmesh/0.3.0/src/bevy_fontmesh/lib.rs.html

Plugin to enable 3D text mesh generation. It's generic over the material type and defaults to StandardMaterial. Add it again for custom material types.

```rust
use bevy::prelude::*;
use bevy_fontmesh::FontMeshPlugin;

App::new()
    .add_plugins(DefaultPlugins)
    .add_plugins(FontMeshPlugin::<StandardMaterial>::default())
    .run();
```

```rust
use bevy::prelude::*;
use bevy_fontmesh::FontMeshPlugin;

# use bevy::render::render_resource::AsBindGroup;
# #[derive(Asset, TypePath, AsBindGroup, Clone)]
# struct MyCustomMaterial {}
# impl Material for MyCustomMaterial {}
App::new()
    .add_plugins(DefaultPlugins)
    .add_plugins(FontMeshPlugin::<StandardMaterial>::default())
    .add_plugins(FontMeshPlugin::<MyCustomMaterial>::default())
    .run();
```

--------------------------------

### Instrument Implementations

Source: https://docs.rs/bevy_fontmesh/0.3.0/bevy_fontmesh/prelude/struct.TextMeshStyle.html

Provides methods for instrumenting types with spans for tracing.

```APIDOC
## fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided `Span`.
```

```APIDOC
## fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current `Span`.
```

--------------------------------

### Default Implementation for TextMeshGlyphsBundle

Source: https://docs.rs/bevy_fontmesh/0.3.0/src/bevy_fontmesh/component.rs.html

Provides a default implementation for TextMeshGlyphsBundle, initializing all its fields to their default values.

```rust
impl<M: Material + Default> Default for TextMeshGlyphsBundle<M> {
    fn default() -> Self {
        Self {
            text_glyphs: Default::default(),
            material: Default::default(),
            transform: Default::default(),
            global_transform: Default::default(),
            visibility: Default::default(),
            inherited_visibility: Default::default(),
            view_visibility: Default::default(),
        }
    }
}
```

--------------------------------

### From Conversion

Source: https://docs.rs/bevy_fontmesh/0.3.0/bevy_fontmesh/prelude/struct.GlyphMesh.html

Allows conversion into GlyphMesh from itself.

```APIDOC
## fn from(t: T) -> T

### Description
Returns the argument unchanged.

### Method
`from`
```

--------------------------------

### IntoResult

Source: https://docs.rs/bevy_fontmesh/0.3.0/bevy_fontmesh/prelude/struct.FontMetrics.html

Converts a type into the system output type `Result<T, RunSystemError>`.

```APIDOC
## fn into_result(self) -> Result<T, RunSystemError>

Converts this type into the system output type.
```

--------------------------------

### Plugin Trait Implementation for FontMeshPlugin

Source: https://docs.rs/bevy_fontmesh/0.3.0/bevy_fontmesh/struct.FontMeshPlugin.html

Details the implementation of the Plugin trait for FontMeshPlugin, outlining its configuration and lifecycle methods.

```APIDOC
## Plugin for FontMeshPlugin

### Description
This section details the implementation of the `Plugin` trait for `FontMeshPlugin`. It covers the core methods used to configure and manage the plugin within a Bevy application's lifecycle.

### Methods

#### `build(&self, app: &mut App)`

*   **Description**: Configures the `App` to which this plugin is added. This is where the plugin sets up its systems and resources.

#### `ready(&self, _app: &App) -> bool`

*   **Description**: Checks if the plugin has finished its setup. Useful for plugins that have asynchronous initialization steps.
*   **Returns**: `true` if the plugin is ready, `false` otherwise.

#### `finish(&self, _app: &mut App)`

*   **Description**: Completes the plugin's setup after all other registered plugins are ready. Useful for plugins that depend on the asynchronous setup of other plugins.

#### `cleanup(&self, _app: &mut App)`

*   **Description**: Runs after all plugins have been built and finished, but before the app schedule executes. Useful for cleanup tasks or transferring resources.

#### `name(&self) -> &str`

*   **Description**: Returns a string slice representing the name of the plugin. Primarily used for checking plugin uniqueness and debugging.

#### `is_unique(&self) -> bool`

*   **Description**: Indicates whether the plugin can be meaningfully instantiated multiple times in an `App`. If it can, this method should return `false`.
*   **Returns**: `true` if the plugin is unique, `false` otherwise.
```

--------------------------------

### IntoResult

Source: https://docs.rs/bevy_fontmesh/0.3.0/bevy_fontmesh/struct.GlyphMetrics.html

Converts a type into the system output type, which is a Result.

```APIDOC
## fn into_result(self) -> Result<T, RunSystemError>
Converts this type into the system output type.
```

--------------------------------

### TextMeshStyle Reflection Methods

Source: https://docs.rs/bevy_fontmesh/0.3.0/bevy_fontmesh/prelude/struct.TextMeshStyle.html

Provides methods for reflecting on the TextMeshStyle, allowing for partial equality checks, cloning, hashing, and dynamic conversion.

```APIDOC
## TextMeshStyle Reflection

### Methods

- `reflect_partial_eq(&self, value: &dyn PartialReflect) -> Option<bool>`: Returns a partial equality comparison result.
- `reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>`: Attempts to clone `Self` using reflection.
- `apply(&mut self, value: &(dyn PartialReflect + 'static))`: Applies a reflected value to this value.
- `to_dynamic(&self) -> Box<dyn PartialReflect>`: Converts this reflected value into its dynamic representation.
- `reflect_clone_and_take<T>(&self) -> Result<T, ReflectCloneError>`: Combines `reflect_clone` and `take` for reflected types.
- `reflect_hash(&self) -> Option<u64>`: Returns a hash of the value, including the type.
- `debug(&self, f: &mut Formatter<'_>) -> Result<(), Error>`: Debug formatter for the value.
- `is_dynamic(&self) -> bool`: Indicates whether this type is a dynamic type.
```

--------------------------------

### Into Result

Source: https://docs.rs/bevy_fontmesh/0.3.0/bevy_fontmesh/struct.TextMeshGlyphs.html

Converts the type into a `Result` with the system output type.

```APIDOC
## fn into_result(self) -> Result<T, RunSystemError>

Converts this type into the system output type.

### Returns
- `Result<T, RunSystemError>`: The converted result.
```

--------------------------------

### TextMeshStyle Any and Reflect Conversions

Source: https://docs.rs/bevy_fontmesh/0.3.0/bevy_fontmesh/struct.TextMeshStyle.html

Methods for converting TextMeshStyle to and from `Any` and `Reflect` trait objects.

```APIDOC
## TextMeshStyle Any and Reflect Conversions

### `into_any`

- **Description**: Returns the value as a `Box<dyn Any>`.
- **Signature**: `fn into_any(self: Box<Self>) -> Box<dyn Any>`

### `as_any`

- **Description**: Returns the value as a `&dyn Any`.
- **Signature**: `fn as_any(&self) -> &dyn Any`

### `as_any_mut`

- **Description**: Returns the value as a `&mut dyn Any`.
- **Signature**: `fn as_any_mut(&mut self) -> &mut dyn Any`

### `into_reflect`

- **Description**: Casts this type to a boxed, fully-reflected value.
- **Signature**: `fn into_reflect(self: Box<Self>) -> Box<dyn Reflect>`

### `as_reflect`

- **Description**: Casts this type to a fully-reflected value.
- **Signature**: `fn as_reflect(&self) -> &dyn Reflect`

### `as_reflect_mut`

- **Description**: Casts this type to a mutable, fully-reflected value.
- **Signature**: `fn as_reflect_mut(&mut self) -> &mut dyn Reflect`

### `set`

- **Description**: Performs a type-checked assignment of a reflected value to this value.
- **Signature**: `fn set(&mut self, value: Box<dyn Reflect>) -> Result<(), Box<dyn Reflect>>`
```

--------------------------------

### TextMeshStyle Reflection Methods

Source: https://docs.rs/bevy_fontmesh/0.3.0/bevy_fontmesh/struct.TextMeshStyle.html

Provides methods for reflecting on the TextMeshStyle, allowing for partial equality checks, cloning, applying reflected values, converting to dynamic representations, and hashing.

```APIDOC
## TextMeshStyle Reflection

### `reflect_partial_eq`

- **Description**: Returns a “partial equality” comparison result.
- **Signature**: `fn reflect_partial_eq(&self, value: &dyn PartialReflect) -> Option<bool>`

### `reflect_clone`

- **Description**: Attempts to clone `Self` using reflection.
- **Signature**: `fn reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>`

### `apply`

- **Description**: Applies a reflected value to this value.
- **Signature**: `fn apply(&mut self, value: &(dyn PartialReflect + 'static))`

### `to_dynamic`

- **Description**: Converts this reflected value into its dynamic representation based on its kind.
- **Signature**: `fn to_dynamic(&self) -> Box<dyn PartialReflect>`

### `reflect_clone_and_take`

- **Description**: Combines `reflect_clone` and `take` for types implementing `PartialReflect`, automatically constructing an appropriate `ReflectCloneError` if the downcast fails.
- **Signature**: `fn reflect_clone_and_take<T>(&self) -> Result<T, ReflectCloneError> where T: 'static, Self: Sized + TypePath`

### `reflect_hash`

- **Description**: Returns a hash of the value (which includes the type).
- **Signature**: `fn reflect_hash(&self) -> Option<u64>`

### `debug`

- **Description**: Debug formatter for the value.
- **Signature**: `fn debug(&self, f: &mut Formatter<'_>) -> Result<(), Error>`

### `is_dynamic`

- **Description**: Indicates whether or not this type is a _dynamic_ type.
- **Signature**: `fn is_dynamic(&self) -> bool`
```

--------------------------------

### Bevy FontMesh Prelude

Source: https://docs.rs/bevy_fontmesh/0.3.0/src/bevy_fontmesh/prelude.rs.html

Re-exports common types and functions from the bevy_fontmesh crate for easy access.

```APIDOC
pub use crate::asset::{FontMesh, FontMetrics, GlyphMetrics};
pub use crate::component::{
    GlyphMesh, JustifyText, TextAnchor, TextMesh, TextMeshBundle, TextMeshGlyphs,
    TextMeshGlyphsBundle, TextMeshStyle,
};
pub use crate::system::{generate_glyph_mesh, TextMeshComputed, TextMeshGlyphsComputed};
pub use crate::FontMeshPlugin;
```

--------------------------------

### Default Implementation for TextMeshBundle

Source: https://docs.rs/bevy_fontmesh/0.3.0/src/bevy_fontmesh/component.rs.html

Provides a default implementation for TextMeshBundle, initializing all its fields to their default values.

```rust
impl<M: Material + Default> Default for TextMeshBundle<M> {
    fn default() -> Self {
        Self {
            text_mesh: Default::default(),
            mesh: Default::default(),
            material: Default::default(),
            transform: Default::default(),
            global_transform: Default::default(),
            visibility: Default::default(),
            inherited_visibility: Default::default(),
            view_visibility: Default::default(),
        }
    }
}
```
Tokens:
Raw