RustType

https://docs.rs/rusttype/0.9.3
Admin
RustType is a pure Rust alternative to FreeType that provides TrueType font parsing, glyph rendering...
Tokens:50,284
Snippets:382
Trust Score:9.1
Update:6 months ago
Show doc for...
Tokens:
Raw
### Get Default Cache Builder

Source: https://docs.rs/rusttype/0.9.3/src/rusttype/gpu_cache.rs.html

Initializes a new `CacheBuilder` with default settings. Use this to start configuring a new cache.

```rust
pub fn builder() -> CacheBuilder {
    CacheBuilder::default()
}
```

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

### Example of Point Interpolation

Source: https://docs.rs/rusttype/0.9.3/src/rusttype/geometry.rs.html

Demonstrates how to interpolate between two points using vector arithmetic. Requires the point coordinates to support addition, subtraction, and multiplication by a scalar.

```rust
# use rusttype::*
# let t = 0.5; let p0 = point(0.0, 0.0); let p1 = point(0.0, 0.0);
let interpolated_point = p0 + (p1 - p0) * t;
```

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

### Interpolate between two points

Source: https://docs.rs/rusttype/0.9.3/rusttype/struct.Point.html

Example showing how to perform linear interpolation between two points using vector arithmetic.

```rust
let interpolated_point = p0 + (p1 - p0) * t;
```

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

### IntoGlyphId Implementation for char

Source: https://docs.rs/rusttype/0.9.3/rusttype/trait.IntoGlyphId.html

An example implementation of the IntoGlyphId trait for the `char` type. This allows characters to be directly converted into GlyphIds.

```rust
impl IntoGlyphId for char

    fn into_glyph_id(self, font: &Font<'_>) -> GlyphId;
```

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

### Clone Implementation for GlyphIter

Source: https://docs.rs/rusttype/0.9.3/rusttype/struct.GlyphIter.html

Provides the ability to clone a GlyphIter instance. This is useful for creating multiple independent iterators from the same starting point.

```APIDOC
### impl<'a, 'font, I: Clone + Iterator> Clone for GlyphIter<'a, 'font, I>
where I::Item: IntoGlyphId,

#### fn clone(&self) -> GlyphIter<'a, 'font, I>
Returns a duplicate of the value.

#### fn clone_from(&mut self, source: &Self)
Performs copy-assignment from `source`.
```

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

### Get Pixel Bounding Box

Source: https://docs.rs/rusttype/0.9.3/rusttype/struct.PositionedGlyph.html

Calculates the smallest rectangle aligned to pixel boundaries that encloses the glyph's shape at its current position and scale. The origin (0,0) is at the top-left of this box.

```rust
pub fn pixel_bounding_box(&self) -> Option<Rect<i32>>
```

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

### Initialize Cache with CacheBuilder

Source: https://docs.rs/rusttype/0.9.3/rusttype/gpu_cache/struct.CacheBuilder.html

Demonstrates creating a cache with custom configurations or default values.

```rust
use rusttype::gpu_cache::Cache;

// Create a cache with all default values set explicitly
// equivalent to `Cache::builder().build()`
let default_cache = Cache::builder()
    .dimensions(256, 256)
    .scale_tolerance(0.1)
    .position_tolerance(0.1)
    .pad_glyphs(true)
    .align_4x4(false)
    .multithread(true)
    .build();

// Create a cache with all default values, except with a dimension of 1024x1024
let bigger_cache = Cache::builder().dimensions(1024, 1024).build();
```

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

### Generic TypeId Implementation

Source: https://docs.rs/rusttype/0.9.3/rusttype/struct.VMetrics.html

Gets the `TypeId` of a generic type `T`. This is a blanket implementation.

```rust
impl<T> Any for T where T: 'static + ?Sized {
    fn type_id(&self) -> TypeId {
        // Implementation details omitted for brevity
        unimplemented!()
    }
}
```

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

### Create a Cache with Default Values

Source: https://docs.rs/rusttype/0.9.3/src/rusttype/gpu_cache.rs.html

Demonstrates how to create a `Cache` instance using the builder pattern with all default settings explicitly defined. This is equivalent to calling `Cache::builder().build()`.

```rust
use rusttype::gpu_cache::Cache;

// Create a cache with all default values set explicitly
// equivalent to `Cache::builder().build()`
let default_cache = Cache::builder()
    .dimensions(256, 256)
    .scale_tolerance(0.1)
    .position_tolerance(0.1)
    .pad_glyphs(true)
    .align_4x4(false)
    .multithread(true)
    .build();
```

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

### Get Glyph Position

Source: https://docs.rs/rusttype/0.9.3/rusttype/struct.PositionedGlyph.html

Returns the position of the glyph. This is a 2D point indicating where the glyph is placed.

```rust
pub fn position(&self) -> Point<f32>
```

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

### Initialize Font from Data

Source: https://docs.rs/rusttype/0.9.3/rusttype/enum.Font.html

Demonstrates creating a Font instance from byte slices or owned vectors.

```rust
let font_data: &[u8] = include_bytes!("../dev/fonts/dejavu/DejaVuSansMono.ttf");
let font: Font<'static> = Font::try_from_bytes(font_data)?;

let owned_font_data: Vec<u8> = font_data.to_vec();
let from_owned_font: Font<'static> = Font::try_from_vec(owned_font_data)?;
```

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

### fn try_into

Source: https://docs.rs/rusttype/0.9.3/rusttype/struct.HMetrics.html

Documentation for the try_into conversion method.

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

### Description
Performs the conversion from the current type into the target type U.

### Parameters
- **self** - Required - The instance to be converted.

### Response
- **Result<U, <U as TryFrom<T>>::Error>** - Returns the converted type U or an error if the conversion fails.
```

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

### Get Glyph Identifier

Source: https://docs.rs/rusttype/0.9.3/rusttype/struct.PositionedGlyph.html

Retrieves the unique identifier for the glyph. This is useful for tracking specific glyphs.

```rust
pub fn id(&self) -> GlyphId
```

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

### Test Glyph Cache Functionality

Source: https://docs.rs/rusttype/0.9.3/src/rusttype/gpu_cache.rs.html

Demonstrates basic cache initialization and queueing of glyphs for rendering.

```rust
#[test]
    fn cache_test() {
        let font_data = include_bytes!("../dev/fonts/wqy-microhei/WenQuanYiMicroHei.ttf");
        let font = Font::try_from_bytes(font_data as &[u8]).unwrap();

        let mut cache: Cache<'static> = Cache::builder()
            .dimensions(32, 32)
            .scale_tolerance(0.1)
            .position_tolerance(0.1)
            .pad_glyphs(false)
            .build();
        let strings = [
            ("Hello World!", 15.0),
            ("Hello World!", 14.0),
            ("Hello World!", 10.0),
            ("Hello World!", 15.0),
            ("Hello World!", 14.0),
            ("Hello World!", 10.0),
        ];
        for &(string, scale) in &strings {
            println!("Caching {:?}", (string, scale));
            for glyph in font.layout(string, Scale::uniform(scale), point(0.0, 0.0)) {
                cache.queue_glyph(0, glyph);
            }
            cache.cache_queued(|_, _| {}).unwrap();
        }
    }
```

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

### Get Glyph Scale

Source: https://docs.rs/rusttype/0.9.3/rusttype/struct.PositionedGlyph.html

Returns the scale applied to the glyph. This indicates how much the glyph has been enlarged or shrunk.

```rust
pub fn scale(&self) -> Scale
```

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

### POST /build

Source: https://docs.rs/rusttype/0.9.3/rusttype/gpu_cache/struct.CacheBuilder.html

Constructs the Cache instance based on the configured builder parameters.

```APIDOC
## build

### Description
Constructs a new Cache instance. Note that this is the CPU-side representation; the GPU texture must be managed by the user.

### Parameters
- None

### Response
- **Cache**: The constructed cache instance.

### Errors
- Panics if scale_tolerance or position_tolerance are less than or equal to zero.
```

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

### Get Font Reference

Source: https://docs.rs/rusttype/0.9.3/rusttype/struct.PositionedGlyph.html

Returns a reference to the font to which this glyph belongs. This allows access to font-level properties.

```rust
pub fn font(&self) -> &Font<'font>
```

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

### CloneToUninit Implementation (Nightly)

Source: https://docs.rs/rusttype/0.9.3/rusttype/struct.HMetrics.html

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

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

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

### Get Pointer Alignment

Source: https://docs.rs/rusttype/0.9.3/rusttype/struct.LayoutIter.html

The `ALIGN` constant specifies the required alignment in bytes for pointers related to the `Pointable` trait.

```rust
const ALIGN: usize
```

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

### Build and Use GPU Cache

Source: https://docs.rs/rusttype/0.9.3/src/rusttype/gpu_cache.rs.html

Demonstrates building a default cache, queuing glyphs, updating the GPU texture with new glyph data, and retrieving texture coordinates for rendering. The `update_gpu_texture` closure is called when new glyph data needs to be uploaded to the GPU.

```rust
use rusttype::{Font, gpu_cache::Cache, point, Scale};
use std::error::Error;

fn example() -> Result<(), Box<dyn Error>> {
    let font_data: &[u8] = include_bytes!("../dev/fonts/dejavu/DejaVuSansMono.ttf");
    let font: Font<'static> = Font::try_from_bytes(font_data).unwrap();
    let glyph = font.glyph('a').scaled(Scale::uniform(25.0)).positioned(point(0.0, 0.0));
    let glyph2 = glyph.clone();

    fn update_gpu_texture(_: rusttype::Rect<u32>, _: &[u8]) {};

    // Build a default Cache.
    let mut cache = Cache::builder().build();

    // Queue some positioned glyphs needed for the next frame.
    cache.queue_glyph(0, glyph);

    // Cache all queued glyphs somewhere in the cache texture.
    // If new glyph data has been drawn the closure is called to upload
    // the pixel data to GPU memory.
    cache.cache_queued(|region, data| update_gpu_texture(region, data)?);

    let glyph = glyph2;
    // Lookup a positioned glyph's texture location
    if let Ok(Some((uv_rect, screen_rect))) = cache.rect_for(0, &glyph) {
        // Generate vertex data, etc
    }
    Ok(())
}
```

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

### Get Cache Position Tolerance

Source: https://docs.rs/rusttype/0.9.3/src/rusttype/gpu_cache.rs.html

Retrieves the current subpixel position tolerance for the cache. This determines the sensitivity to small positional variations.

```rust
pub fn position_tolerance(&self) -> f32 {
    self.position_tolerance
}
```

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

### Build and Use GPU Glyph Cache

Source: https://docs.rs/rusttype/0.9.3/rusttype/gpu_cache/index.html

Demonstrates building a default Cache, queuing glyphs, updating the cache with pixel data, and retrieving texture coordinates for rendering. Ensure the `gpu_cache` feature is enabled in Cargo.toml.

```rust
use rusttype::{Cache, CacheBuilder, Glyph, gpu_cache::TextureCoords};
use std::error::Error;

fn main() -> Result<(), Box<dyn Error>> {
    // Build a default Cache.
    let mut cache: Cache = CacheBuilder::new().build();

    // Placeholder for a Glyph object (replace with actual glyph data)
    let glyph: Glyph = unsafe {
        std::mem::zeroed()
    };

    // Queue some positioned glyphs needed for the next frame.
    cache.queue_glyph(0, glyph);

    // Placeholder for the update_gpu_texture function
    let update_gpu_texture = |region: rusttype::gpu_cache::TexelRegion, data: &[u8]| -> Result<(), rusttype::gpu_cache::CacheWriteErr> {
        // Implement GPU texture update logic here
        println!("Updating GPU texture for region: {:?}", region);
        Ok(())
    };

    // Cache all queued glyphs somewhere in the cache texture.
    // If new glyph data has been drawn the closure is called to upload
    // the pixel data to GPU memory.
    cache.cache_queued(update_gpu_texture)?;

    // Lookup a positioned glyph's texture location
    if let Ok(Some((uv_rect, screen_rect))):
        Result<Option<(TextureCoords, rusttype::Rect<i32>)>, rusttype::gpu_cache::CacheReadErr> = cache.rect_for(0, &glyph) {
        // Generate vertex data, etc
        println!("Glyph found in cache: UV Rect = {:?}, Screen Rect = {:?}", uv_rect, screen_rect);
    } else {
        println!("Glyph not found in cache or error occurred.");
    }

    Ok(())
}
```

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

### Create a Larger Cache

Source: https://docs.rs/rusttype/0.9.3/src/rusttype/gpu_cache.rs.html

Shows how to create a `Cache` with custom dimensions, specifically a larger 1024x1024 texture size, while using all other default settings.

```rust
use rusttype::gpu_cache::Cache;

// Create a cache with all default values, except with a dimension of 1024x1024
let bigger_cache = Cache::builder().dimensions(1024, 1024).build();
```

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

### Get Unpositioned Glyph

Source: https://docs.rs/rusttype/0.9.3/rusttype/struct.PositionedGlyph.html

Returns a reference to the glyph without its positioning information. This is useful for operations that only depend on the glyph's shape.

```rust
pub fn unpositioned(&self) -> &ScaledGlyph<'font>
```

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

### CloneToUninit for T

Source: https://docs.rs/rusttype/0.9.3/rusttype/struct.Point.html

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

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

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

### Method
POST

### Endpoint
N/A (Method implementation)

### Parameters
#### Path Parameters
N/A

#### Query Parameters
N/A

#### Request Body
- **dest** (*mut u8) - Required - Pointer to the destination memory location.
```

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

### Get Cache Scale Tolerance

Source: https://docs.rs/rusttype/0.9.3/src/rusttype/gpu_cache.rs.html

Retrieves the current scale tolerance setting for the cache. This value affects how glyphs are considered for caching at different scales.

```rust
pub fn scale_tolerance(&self) -> f32 {
    self.scale_tolerance
}
```

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

### Get Cache Texture Dimensions

Source: https://docs.rs/rusttype/0.9.3/src/rusttype/gpu_cache.rs.html

Returns the expected dimensions (width and height) of the GPU texture used by the cache. Ensure this matches your actual texture size.

```rust
pub fn dimensions(&self) -> (u32, u32) {
    (self.width, self.height)
}
```

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

### Font Initialization

Source: https://docs.rs/rusttype/0.9.3/rusttype/enum.Font.html

Methods for creating a Font instance from raw byte data or vectors.

```APIDOC
## Font Initialization

### Description
Methods to instantiate a Font from various data sources.

### Methods
- `try_from_bytes(bytes: &[u8]) -> Option<Font<'_>>`
- `try_from_bytes_and_index(bytes: &[u8], index: u32) -> Option<Font<'_>>`
- `try_from_vec(data: Vec<u8>) -> Option<Font<'static>>`
- `try_from_vec_and_index(data: Vec<u8>, index: u32) -> Option<Font<'static>>`
```

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

### Load a Font from bytes or a vector

Source: https://docs.rs/rusttype/0.9.3/src/rusttype/font.rs.html

Demonstrates initializing a Font instance using either a byte slice or an owned vector of font data.

```rust
# use rusttype::Font;
# fn example() -> Option<()> {
let font_data: &[u8] = include_bytes!("../dev/fonts/dejavu/DejaVuSansMono.ttf");
let font: Font<'static> = Font::try_from_bytes(font_data)?;

let owned_font_data: Vec<u8> = font_data.to_vec();
let from_owned_font: Font<'static> = Font::try_from_vec(owned_font_data)?;
# Some(())
# }
```

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

### Create a Point Instance

Source: https://docs.rs/rusttype/0.9.3/src/rusttype/geometry.rs.html

A convenience function for creating new Point instances. Useful for initializing points with specific coordinates.

```rust
pub fn point<N>(x: N, y: N) -> Point<N> {
    Point { x, y }
}
```

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

### Nightly-Only CloneToUninit

Source: https://docs.rs/rusttype/0.9.3/rusttype/struct.VMetrics.html

Nightly-only experimental API for performing copy-assignment from `self` to `dest`. Requires `T: Clone`.

```rust
unsafe fn clone_to_uninit(&self, dest: *mut u8) {
    // Implementation details omitted for brevity
    unimplemented!()
}
```

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

### CacheBuilder Configuration Methods

Source: https://docs.rs/rusttype/0.9.3/rusttype/gpu_cache/struct.CacheBuilder.html

Methods for configuring the CacheBuilder instance before calling build().

```APIDOC
## CacheBuilder Configuration

### Description
Methods to configure the properties of the GPU cache before instantiation.

### Methods
- **dimensions(width: u32, height: u32)**: Sets the 2D texture dimensions.
- **scale_tolerance(scale_tolerance: f32)**: Sets the maximum allowed scale difference for glyph reuse.
- **position_tolerance(position_tolerance: f32)**: Sets the maximum allowed subpixel offset difference for glyph reuse.
- **pad_glyphs(pad_glyphs: bool)**: Enables or disables 1-pixel padding around glyphs.
- **align_4x4(align_4x4: bool)**: Aligns glyphs to 4x4 texel boundaries.
- **multithread(multithread: bool)**: Enables or disables multi-core rasterization.

### Request Example
let cache = Cache::builder()
    .dimensions(256, 256)
    .scale_tolerance(0.1)
    .build();
```

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

### Test Cache Rebuilding with New Parameters

Source: https://docs.rs/rusttype/0.9.3/src/rusttype/gpu_cache.rs.html

Demonstrates rebuilding an existing cache with updated dimensions and tolerances, clearing its contents.

```rust
let mut cache = Cache::builder()
            .dimensions(32, 64)
            .scale_tolerance(0.2)
            .position_tolerance(0.3)
            .pad_glyphs(false)
            .align_4x4(true)
            .multithread(true)
            .build();

        let font = Font::try_from_bytes(include_bytes!(
            "../dev/fonts/wqy-microhei/WenQuanYiMicroHei.ttf"
        ) as &[u8])
        .unwrap();
        cache.queue_glyph(
            0,
            font.glyph('l')
                .scaled(Scale::uniform(25.0))
                .positioned(point(0.0, 0.0)),
        );
        cache.cache_queued(|_, _| {}).unwrap();

        cache.queue_glyph(
            0,
            font.glyph('a')
                .scaled(Scale::uniform(25.0))
                .positioned(point(0.0, 0.0)),
        );

        Cache::builder()
            .dimensions(64, 128)
            .scale_tolerance(0.05)
            .position_tolerance(0.15)
            .pad_glyphs(true)
            .align_4x4(false)
            .multithread(false)
            .rebuild(&mut cache);

        assert_eq!(cache.width, 64);
        assert_eq!(cache.height, 128);
        assert_relative_eq!(cache.scale_tolerance, 0.05);
        assert_relative_eq!(cache.position_tolerance, 0.15);
        assert_eq!(cache.pad_glyphs, true);
        assert_eq!(cache.align_4x4, false);
        assert_eq!(cache.multithread, false);

        assert!( 
            cache.all_glyphs.is_empty(),
            "cache should have been cleared"
        );

        assert_eq!(cache.queue.len(), 1, "cache should have an unchanged queue");
```

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

### Iterator Adapters for Testing Conditions

Source: https://docs.rs/rusttype/0.9.3/rusttype/struct.GlyphIter.html

This section covers iterator adapters used for testing conditions across elements, including `all`, `any`, `find`, and `is_partitioned`.

```APIDOC
## fn all<F>(&mut self, f: F) -> bool

### Description
Tests if every element of the iterator matches a predicate.

### Method
`all`

### Parameters
- `f` (F): A closure that takes an item and returns a boolean.

### Response
- `bool`: `true` if all elements match the predicate, `false` otherwise.

## fn any<F>(&mut self, f: F) -> bool

### Description
Tests if any element of the iterator matches a predicate.

### Method
`any`

### Parameters
- `f` (F): A closure that takes an item and returns a boolean.

### Response
- `bool`: `true` if at least one element matches the predicate, `false` otherwise.

## fn find<P>(&mut self, predicate: P) -> Option<Self::Item>

### Description
Searches for an element of an iterator that satisfies a predicate.

### Method
`find`

### Parameters
- `predicate` (P): A closure that takes a reference to an item and returns a boolean.

### Response
- `Option<Self::Item>`: An `Option` containing the first element that satisfies the predicate, or `None` if no such element is found.

## fn is_partitioned<P>(self, predicate: P) -> bool

### Description
Checks if the elements of this iterator are partitioned according to the given predicate, such that all those that return `true` precede all those that return `false`.

### Method
`is_partitioned`

### Parameters
- `predicate` (P): A closure that takes an item and returns a boolean.

### Note
This is a nightly-only experimental API.

### Response
- `bool`: `true` if the iterator is partitioned according to the predicate, `false` otherwise.
```

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

### Scale Configuration

Source: https://docs.rs/rusttype/0.9.3/src/rusttype/lib.rs.html

Struct defining font scaling and a helper for uniform scaling.

```rust
pub struct Scale {
    pub x: f32,
    pub y: f32,
}

impl Scale {
    #[inline]
    pub fn uniform(s: f32) -> Scale {
        Scale { x: s, y: s }
    }
}
```

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

### Cache Builder Configuration Methods

Source: https://docs.rs/rusttype/0.9.3/src/rusttype/gpu_cache.rs.html

Methods used to configure the Cache builder before building the final Cache instance.

```APIDOC
## Cache Builder Configuration

### Description
Methods to configure the GPU cache settings such as dimensions, tolerances, and performance options.

### Parameters
- **dimensions(width: u32, height: u32)** - Sets the cache texture dimensions.
- **scale_tolerance(scale_tolerance: V)** - Sets the maximum allowed difference for scale matching (min 0.001).
- **position_tolerance(position_tolerance: V)** - Sets the maximum allowed difference for subpixel offset matching (min 0.001).
- **pad_glyphs(pad_glyphs: bool)** - Enables/disables padding of a single zero alpha pixel around glyphs.
- **align_4x4(align_4x4: bool)** - Aligns glyphs to 4x4 texel boundaries.
- **multithread(multithread: bool)** - Enables/disables multithreaded rasterization.

### Request Example
```rust
let cache = Cache::builder()
    .dimensions(1024, 1024)
    .scale_tolerance(0.1)
    .position_tolerance(0.1)
    .pad_glyphs(true)
    .align_4x4(false)
    .multithread(true)
    .build();
```
```

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

### Build Cache Instance

Source: https://docs.rs/rusttype/0.9.3/rusttype/gpu_cache/struct.CacheBuilder.html

Constructs the final Cache instance after configuration.

```rust
let cache = Cache::builder().build();
```

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

### POST /rebuild

Source: https://docs.rs/rusttype/0.9.3/rusttype/gpu_cache/struct.CacheBuilder.html

Rebuilds an existing Cache instance with new attributes.

```APIDOC
## rebuild

### Description
Rebuilds a Cache with new attributes. All cached glyphs are cleared, but the glyph queue is retained.

### Parameters
- **cache** (&mut Cache): The existing cache instance to modify.
```

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

### Implement CloneToUninit for T

Source: https://docs.rs/rusttype/0.9.3/rusttype/gpu_cache/enum.CacheReadErr.html

Provides unsafe functionality to clone a value into uninitialized memory. This is a nightly-only experimental API.

```rust
impl<T> CloneToUninit for T
where T: Clone,
Source§
#### unsafe fn clone_to_uninit(&self, dest: *mut u8)
🔬This is a nightly-only experimental API. (`clone_to_uninit`)
```

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

### Create a Vector Instance

Source: https://docs.rs/rusttype/0.9.3/src/rusttype/geometry.rs.html

A convenience function for creating new Vector instances. Useful for initializing vectors with specific components.

```rust
pub fn vector<N>(x: N, y: N) -> Vector<N> {
    Vector { x, y }
}
```

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

### PositionedGlyph Methods

Source: https://docs.rs/rusttype/0.9.3/src/rusttype/lib.rs.html

Methods for retrieving glyph metrics, building outlines, and rasterizing glyphs.

```rust
pub fn pixel_bounding_box(&self) -> Option<Rect<i32>> {
        self.bb
    }

    pub fn scale(&self) -> Scale {
        self.sg.api_scale
    }

    pub fn position(&self) -> Point<f32> {
        self.position
    }

    pub fn build_outline(&self, builder: &mut impl OutlineBuilder) -> bool {
        let bb = if let Some(bb) = self.bb.as_ref() {
            bb
        } else {
            return false;
        };

        let offset = vector(bb.min.x as f32, bb.min.y as f32);

        let mut outliner = crate::outliner::OutlineTranslator::new(builder, self.position - offset);

        self.sg.build_outline(&mut outliner)
    }

    pub fn draw<O: FnMut(u32, u32, f32)>(&self, o: O) {
        let bb = if let Some(bb) = self.bb.as_ref() {
            bb
        } else {
            return;
        };

        let width = (bb.max.x - bb.min.x) as u32;
        let height = (bb.max.y - bb.min.y) as u32;

        let mut outliner = crate::outliner::OutlineRasterizer::new(width as _, height as _);

        self.build_outline(&mut outliner);

        outliner.rasterizer.for_each_pixel_2d(o);
    }

    pub fn set_position(&mut self, p: Point<f32>) {
        let p_diff = p - self.position;
        if p_diff.x.fract().is_near_zero() && p_diff.y.fract().is_near_zero() {
            if let Some(bb) = self.bb.as_mut() {
                let rounded_diff = vector(p_diff.x.round() as i32, p_diff.y.round() as i32);
                bb.min = bb.min + rounded_diff;
                bb.max = bb.max + rounded_diff;
            }
        } else {
            self.bb = self.sg.pixel_bounds_at(p);
        }
        self.position = p;
    }
```

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

### Implement Any for T

Source: https://docs.rs/rusttype/0.9.3/rusttype/gpu_cache/enum.CacheReadErr.html

Provides runtime type information for any type `T`. This is a blanket implementation.

```rust
impl<T> Any for T
where T: 'static + ?Sized,
Source§
#### fn type_id(&self) -> TypeId
```

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

### Create Cache Builder from Cache

Source: https://docs.rs/rusttype/0.9.3/src/rusttype/gpu_cache.rs.html

Generates a `CacheBuilder` pre-configured with the current cache's attributes. Useful for creating a new cache with similar settings.

```rust
pub fn to_builder(&self) -> CacheBuilder {
    CacheBuilder {
        dimensions: (self.width, self.height),
        position_tolerance: self.position_tolerance,
        scale_tolerance: self.scale_tolerance,
        pad_glyphs: self.pad_glyphs,
        align_4x4: self.align_4x4,
        multithread: self.multithread,
    }
}
```

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

### Create Uniform Scale

Source: https://docs.rs/rusttype/0.9.3/rusttype/struct.Scale.html

Constructs a Scale instance with identical horizontal and vertical dimensions.

```rust
pub fn uniform(s: f32) -> Scale
```

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

### Pointable Initialization

Source: https://docs.rs/rusttype/0.9.3/rusttype/struct.HMetrics.html

Initializes a value in memory using a given initializer and returns its size.

```rust
unsafe fn init(init: <T as Pointable>::Init) -> usize
```

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

### Test Cache Reordering Glyphs

Source: https://docs.rs/rusttype/0.9.3/src/rusttype/gpu_cache.rs.html

Demonstrates how the cache handles reordering glyphs when new glyphs are added, returning `CachedBy::Adding` or `CachedBy::Reordering`.

```rust
let font_data = include_bytes!("../dev/fonts/wqy-microhei/WenQuanYiMicroHei.ttf");
        let font = Font::try_from_bytes(font_data as &[u8]).unwrap();

        let mut cache = Cache::builder()
            .dimensions(36, 27)
            .scale_tolerance(0.1)
            .position_tolerance(0.1)
            .build();

        for glyph in font.layout("ABCDEFG", Scale::uniform(16.0), point(0.0, 0.0)) {
            cache.queue_glyph(0, glyph);
        }
        assert_eq!(cache.cache_queued(|_, _| {}), Ok(CachedBy::Adding));

        for glyph in font.layout("DEFGHIJK", Scale::uniform(16.0), point(0.0, 0.0)) {
            cache.queue_glyph(0, glyph);
        }
        assert_eq!(cache.cache_queued(|_, _| {}), Ok(CachedBy::Reordering));
```

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

### Layout text horizontally with RustType

Source: https://docs.rs/rusttype/0.9.3/src/rusttype/font.rs.html

Demonstrates the layout method for positioning glyphs and the equivalent manual iteration process including kerning and metrics.

```rust
font.layout("Hello World!", scale, start)
```

```rust
font.glyphs_for("Hello World!".chars())
    .scan((None, 0.0), |(last, x), g| {
        let g = g.scaled(scale);
        if let Some(last) = last {
            *x += font.pair_kerning(scale, *last, g.id());
        }
        let w = g.h_metrics().advance_width;
        let next = g.positioned(start + vector(*x, 0.0));
        *last = Some(next.id());
        *x += w;
        Some(next)
    })
```

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

### TryFrom Implementation

Source: https://docs.rs/rusttype/0.9.3/rusttype/struct.HMetrics.html

Attempts to convert one type into another, returning a Result.

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

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

### Iterator Aggregation and Comparison Methods

Source: https://docs.rs/rusttype/0.9.3/rusttype/struct.LayoutIter.html

Methods for aggregating elements (sum, product) and comparing iterators.

```APIDOC
## fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>

### Description
Returns the element that yields the maximum value based on a key extraction function.

### Method
`max_by_key`

### Parameters
- `f` (F: FnMut(&Self::Item) -> B) - A closure that extracts a key of type `B` (which must implement `Ord`) from an element.

### Returns
- `Option<Self::Item>` - The element that produced the maximum key, or `None` if the iterator is empty.
```

```APIDOC
## fn max_by<F>(self, compare: F) -> Option<Self::Item>

### Description
Returns the element that is considered the maximum according to a custom comparison function.

### Method
`max_by`

### Parameters
- `compare` (F: FnMut(&Self::Item, &Self::Item) -> Ordering) - A closure that compares two elements and returns an `Ordering`.

### Returns
- `Option<Self::Item>` - The maximum element according to the comparison function, or `None` if the iterator is empty.
```

```APIDOC
## fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>

### Description
Returns the element that yields the minimum value based on a key extraction function.

### Method
`min_by_key`

### Parameters
- `f` (F: FnMut(&Self::Item) -> B) - A closure that extracts a key of type `B` (which must implement `Ord`) from an element.

### Returns
- `Option<Self::Item>` - The element that produced the minimum key, or `None` if the iterator is empty.
```

```APIDOC
## fn min_by<F>(self, compare: F) -> Option<Self::Item>

### Description
Returns the element that is considered the minimum according to a custom comparison function.

### Method
`min_by`

### Parameters
- `compare` (F: FnMut(&Self::Item, &Self::Item) -> Ordering) - A closure that compares two elements and returns an `Ordering`.

### Returns
- `Option<Self::Item>` - The minimum element according to the comparison function, or `None` if the iterator is empty.
```

```APIDOC
## fn sum<S>(self) -> S

### Description
Calculates the sum of all elements in the iterator.

### Method
`sum`

### Returns
- `S` - The sum of the elements, where `S` must implement `Sum<Self::Item>`.
```

```APIDOC
## fn product<P>(self) -> P

### Description
Calculates the product of all elements in the iterator.

### Method
`product`

### Returns
- `P` - The product of the elements, where `P` must implement `Product<Self::Item>`.
```

```APIDOC
## fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering

### Description
Lexicographically compares the elements of this iterator with another, using a custom comparison function. This is a nightly-only experimental API.

### Method
`cmp_by`

### Parameters
- `other` (I: IntoIterator) - Another iterator to compare against.
- `cmp` (F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering) - A closure for comparing elements from both iterators.

### Returns
- `Ordering` - The result of the lexicographical comparison.

### Notes
This API is experimental and requires a nightly Rust toolchain.
```

```APIDOC
## fn partial_cmp<I>(self, other: I) -> Option<Ordering>

### Description
Lexicographically compares the elements of this iterator with another using `PartialOrd`. The comparison short-circuits.

### Method
`partial_cmp`

### Parameters
- `other` (I: IntoIterator) - Another iterator to compare against.

### Returns
- `Option<Ordering>` - `Some(Ordering)` if a comparison result is determined, `None` otherwise.
```

```APIDOC
## fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>

### Description
Lexicographically compares the elements of this iterator with another using a custom partial comparison function. This is a nightly-only experimental API.

### Method
`partial_cmp_by`

### Parameters
- `other` (I: IntoIterator) - Another iterator to compare against.
- `partial_cmp` (F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>) - A closure for performing partial comparison on elements.

### Returns
- `Option<Ordering>` - The result of the lexicographical partial comparison.

### Notes
This API is experimental and requires a nightly Rust toolchain.
```

```APIDOC
## fn eq<I>(self, other: I) -> bool

### Description
Determines if the elements of this iterator are equal to the elements of another iterator.

### Method
`eq`

### Parameters
- `other` (I: IntoIterator) - Another iterator to compare against.

### Returns
- `bool` - `true` if all corresponding elements are equal, `false` otherwise.
```

```APIDOC
## fn eq_by<I, F>(self, other: I, eq: F) -> bool

### Description
Determines if the elements of this iterator are equal to those of another, using a custom equality function. This is a nightly-only experimental API.

### Method
`eq_by`

### Parameters
- `other` (I: IntoIterator) - Another iterator to compare against.
- `eq` (F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool) - A closure for determining equality between elements.

### Returns
- `bool` - `true` if all corresponding elements are equal according to the closure, `false` otherwise.

### Notes
This API is experimental and requires a nightly Rust toolchain.
```

```APIDOC
## fn ne<I>(self, other: I) -> bool

### Description
Determines if the elements of this iterator are not equal to the elements of another iterator.

### Method
`ne`

### Parameters
- `other` (I: IntoIterator) - Another iterator to compare against.

### Returns
- `bool` - `true` if any corresponding elements are not equal, `false` otherwise.
```

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

### TryInto Trait Methods

Source: https://docs.rs/rusttype/0.9.3/rusttype/struct.Scale.html

Documentation for the conversion error type and the try_into method.

```APIDOC
## type Error

### Description
The type returned in the event of a conversion error.

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

## fn try_into

### Description
Performs the conversion from one type to another.

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

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

### Vector Comparison Methods

Source: https://docs.rs/rusttype/0.9.3/rusttype/struct.Vector.html

Provides methods for comparing Vector instances with other Vector instances.

```APIDOC
## Vector Comparison Methods

### Description
Methods for comparing Vector instances.

### Methods

#### `partial_cmp(&self, other: &Vector<N>) -> Option<Ordering>`

This method returns an ordering between `self` and `other` values if one exists.

#### `lt(&self, other: &Rhs) -> bool`

Tests less than (for `self` and `other`) and is used by the `<` operator.

#### `le(&self, other: &Rhs) -> bool`

Tests less than or equal to (for `self` and `other`) and is used by the `<=` operator.

#### `gt(&self, other: &Rhs) -> bool`

Tests greater than (for `self` and `other`) and is used by the `>` operator.

#### `ge(&self, other: &Rhs) -> bool`

Tests greater than or equal to (for `self` and `other`) and is used by the `>=` operator.
```

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

### Build Glyph Outline

Source: https://docs.rs/rusttype/0.9.3/rusttype/struct.PositionedGlyph.html

Constructs the outline of the glyph using a provided OutlineBuilder. Returns false if the outline is malformed or empty.

```rust
pub fn build_outline(&self, builder: &mut impl OutlineBuilder) -> bool
```

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

### Iterator Adapters for Collection and Aggregation

Source: https://docs.rs/rusttype/0.9.3/rusttype/struct.GlyphIter.html

This section covers methods for collecting iterator elements into collections or performing aggregations like `collect`, `collect_into`, `try_fold`, `fold`, `reduce`, and `try_reduce`.

```APIDOC
## fn collect<B>(self) -> B

### Description
Transforms an iterator into a collection.

### Method
`collect`

### Parameters
- `B` (FromIterator<Self::Item>): The type of collection to create.

### Response
- `B`: The resulting collection.

## fn collect_into<E>(self, collection: &mut E) -> &mut E

### Description
Collects all the items from an iterator into a collection.

### Method
`collect_into`

### Parameters
- `collection` (&mut E): A mutable reference to the collection to extend.

### Note
This is a nightly-only experimental API.

### Response
- `&mut E`: A mutable reference to the collection.

## fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R

### Description
Applies a function as long as it returns successfully, producing a single, final value.

### Method
`try_fold`

### Parameters
- `init` (B): The initial value for the accumulator.
- `f` (F): A closure that takes the accumulator and an item, returning a `Try`.

### Response
- `R`: The result of the fold operation, which is a `Try`.

## fn fold<B, F>(self, init: B, f: F) -> B

### Description
Folds every element into an accumulator by applying an operation, returning the final result.

### Method
`fold`

### Parameters
- `init` (B): The initial value for the accumulator.
- `f` (F): A closure that takes the accumulator and an item, returning the updated accumulator.

### Response
- `B`: The final accumulated value.

## fn reduce<F>(self, f: F) -> Option<Self::Item>

### Description
Reduces the elements to a single one, by repeatedly applying a reducing operation.

### Method
`reduce`

### Parameters
- `f` (F): A closure that takes two items and returns a single item.

### Response
- `Option<Self::Item>`: An `Option` containing the reduced value, or `None` if the iterator was empty.

## fn try_reduce<R>( &mut self, f: impl FnMut(Self::Item, Self::Item) -> R, ) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType

### Description
Reduces the elements to a single one by repeatedly applying a reducing operation. If the closure returns a failure, the failure is propagated back to the caller immediately.

### Method
`try_reduce`

### Parameters
- `f` (impl FnMut(Self::Item, Self::Item) -> R): A closure that takes two items and returns a `Try`.

### Note
This is a nightly-only experimental API.

### Response
- `<<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType`: The result of the reduction, which can be a success or a failure.
```

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

### Create a Point using point function

Source: https://docs.rs/rusttype/0.9.3/rusttype/fn.point.html

Use this function to generate a new Point instance with the specified x and y coordinates.

```rust
pub fn point<N>(x: N, y: N) -> Point<N>
```

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

### Implementations for Rect<N>

Source: https://docs.rs/rusttype/0.9.3/rusttype/struct.Rect.html

Details the methods and trait implementations available for the Rect struct.

```APIDOC
## Implementations for Rect<N>

### impl<N: Sub<Output = N> + Copy> Rect<N>

#### `width(&self) -> N`
Calculates the width of the rectangle.

#### `height(&self) -> N`
Calculates the height of the rectangle.

### impl<N: Clone> Clone for Rect<N>

#### `clone(&self) -> Rect<N>`
Returns a duplicate of the value.

#### `clone_from(&mut self, source: &Self)`
Performs copy-assignment from `source`.

### impl<N: Debug> Debug for Rect<N>

#### `fmt(&self, f: &mut Formatter<'_>) -> Result`
Formats the value using the given formatter.

### impl<N: Default> Default for Rect<N>

#### `default() -> Rect<N>`
Returns the default value for the Rect type.

### impl<N: Hash> Hash for Rect<N>

#### `hash<__H: Hasher>(&self, state: &mut __H)`
Feeds this value into the given `Hasher`.

#### `hash_slice<H>(data: &[Self], state: &mut H)`
Feeds a slice of this type into the given `Hasher`.

### impl<N: Ord> Ord for Rect<N>

#### `cmp(&self, other: &Rect<N>) -> Ordering`
Compares `self` and `other` and returns an `Ordering`.

#### `max(self, other: Self) -> Self`
Compares and returns the maximum of two values.

#### `min(self, other: Self) -> Self`
Compares and returns the minimum of two values.

#### `clamp(self, min: Self, max: Self) -> Self`
Restricts a value to a certain interval.

### impl<N: PartialEq> PartialEq for Rect<N>

#### `eq(&self, other: &Rect<N>) -> bool`
Tests for equality between `self` and `other`.

#### `ne(&self, other: &Rhs) -> bool`
Tests for inequality.

### impl<N: PartialOrd> PartialOrd for Rect<N>

#### `partial_cmp(&self, other: &Rect<N>) -> Option<Ordering>`
Returns an ordering between `self` and `other` if one exists.

#### `lt(&self, other: &Rhs) -> bool`
Tests if `self` is less than `other`.

#### `le(&self, other: &Rhs) -> bool`
Tests if `self` is less than or equal to `other`.

#### `gt(&self, other: &Rhs) -> bool`
Tests if `self` is greater than `other`.

#### `ge(&self, other: &Rhs) -> bool`
Tests if `self` is greater than or equal to `other`.

### impl<N: Copy> Copy for Rect<N>

### impl<N: Eq> Eq for Rect<N>

### impl<N> StructuralPartialEq for Rect<N>

### Auto Trait Implementations
- `Freeze`
- `RefUnwindSafe`
- `Send`
- `Sync`
- `Unpin`
- `UnwindSafe`

### Blanket Implementations
- `Any`
- `Borrow<T>`
- `BorrowMut<T>`
- `CloneToUninit`
- `From<T>`
- `Into<U>`
- `Pointable`
```

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

### Partial Ordering for VMetrics

Source: https://docs.rs/rusttype/0.9.3/rusttype/struct.VMetrics.html

Provides partial comparison methods for VMetrics values, used by operators like `<`, `<=`, `>`, and `>=`.

```rust
impl PartialOrd for VMetrics {
    fn partial_cmp(&self, other: &VMetrics) -> Option<Ordering> {
        // Implementation details omitted for brevity
        unimplemented!()
    }
}
```

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

### CloneInto Implementation

Source: https://docs.rs/rusttype/0.9.3/rusttype/struct.HMetrics.html

Uses borrowed data to replace owned data, usually by cloning.

```rust
fn clone_into(&self, target: &mut T)
```

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

### Generic TryFrom Implementation

Source: https://docs.rs/rusttype/0.9.3/rusttype/struct.VMetrics.html

A generic implementation of `TryFrom<U>` for `T` where `U: Into<T>`. This is a blanket implementation.

```rust
impl<T, U> TryFrom<U> for T where U: Into<T> {}
```

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

### CacheBuilder API

Source: https://docs.rs/rusttype/0.9.3/src/rusttype/gpu_cache.rs.html

Provides methods for building and rebuilding the GPU cache with various configurations.

```APIDOC
## CacheBuilder

### Description

`CacheBuilder` is used to configure and construct a `Cache` object. It allows for setting various parameters such as dimensions, tolerances, and multithreading options before the cache is built or rebuilt.

### Methods

#### `build<'a>(self) -> Cache<'a>`

Constructs a new CPU-side cache. The GPU texture is managed by the user.

**Panics**

`scale_tolerance` or `position_tolerance` are less than or equal to zero.

**Example**

```rust
# use rusttype::gpu_cache::Cache;
let cache = Cache::builder().build();
```

#### `rebuild(self, cache: &mut Cache)`

Rebuilds an existing `Cache` with new attributes. All cached glyphs are cleared, but the glyph queue is retained unmodified.

**Panics**

`scale_tolerance` or `position_tolerance` are less than or equal to zero.

**Example**

```rust
# use rusttype::gpu_cache::Cache;
# let mut cache = Cache::builder().build();
// Rebuild the cache with different dimensions
cache.to_builder().dimensions(768, 768).rebuild(&mut cache);
```
```

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

### Ownership and String Traits

Source: https://docs.rs/rusttype/0.9.3/rusttype/gpu_cache/enum.CacheReadErr.html

Traits for managing owned data and string conversion.

```APIDOC
## Ownership and String Traits

### Description
Utilities for cloning data and converting types to String representations.

### Methods
- **to_owned(&self) -> T**: Creates owned data from borrowed data.
- **clone_into(&self, target: &mut T)**: Replaces target data with borrowed data.
- **to_string(&self) -> String**: Converts the value to a String.
```

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

### Iterator Adapter for By Reference

Source: https://docs.rs/rusttype/0.9.3/rusttype/struct.GlyphIter.html

This section covers the `by_ref` adapter, which creates a reference to the iterator.

```APIDOC
## fn by_ref(&mut self) -> &mut Self

### Description
Creates a “by reference” adapter for this instance of `Iterator`.

### Method
`by_ref`

### Response
- `&mut Self`: A mutable reference to the iterator.
```

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

### Test Cache to Builder Conversion

Source: https://docs.rs/rusttype/0.9.3/src/rusttype/gpu_cache.rs.html

Ensures that a `Cache` object can be correctly converted back into a `CacheBuilder`.

```rust
let cache = CacheBuilder {
            dimensions: (32, 64),
            scale_tolerance: 0.2,
            position_tolerance: 0.3,
            pad_glyphs: false,
            align_4x4: false,
            multithread: false,
        }
        .build();

        let to_builder: CacheBuilder = cache.to_builder();

        assert_eq!(to_builder.dimensions, (32, 64));
        assert_relative_eq!(to_builder.scale_tolerance, 0.2);
        assert_relative_eq!(to_builder.position_tolerance, 0.3);
        assert_eq!(to_builder.pad_glyphs, false);
        assert_eq!(to_builder.align_4x4, false);
        assert_eq!(to_builder.multithread, false);
```
Tokens:
Raw