lyon

To use Lyon, you typically follow these steps:

1. Build a Path: Use lyon::path::Path::builder() to define a sequence of commands like begin, line_to, quadratic_bezier_to, cubic_bezier_to, and end.
2. Define Vertex Data: You can use the default vertex types or define your own custom vertex struct (e.g., for specific GPU layouts).
3. Tessellate: Use a FillTessellator to process the path. You provide FillOptions and a BuffersBuilder which maps the tessellator's output (FillVertex) into your custom vertex buffers (VertexBuffers).
4. Output: The result is a VertexBuffers object containing the vertices and indices ready for GPU upload.

extern crate lyon;
use lyon::math::point;
use lyon::path::Path;
use lyon::tessellation::*

fn main() {
    // 1. Build a Path
    let mut builder = Path::builder();
    builder.begin(point(0.0, 0.0));
    builder.line_to(point(1.0, 0.0));
    builder.quadratic_bezier_to(point(2.0, 0.0), point(2.0, 1.0));
    builder.cubic_bezier_to(point(1.0, 1.0), point(0.0, 1.0), point(0.0, 0.0));
    builder.end(true);
    let path = builder.build();

    // 2. Define custom vertex type
    #[derive(Copy, Clone, Debug)]
    struct MyVertex { position: [f32; 2] };

    // 3. Prepare buffers and tessellator
    let mut geometry: VertexBuffers<MyVertex, u16> = VertexBuffers::new();
    let mut tessellator = FillTessellator::new();

    // 4. Compute the tessellation
    tessellator.tessellate_path(
        &path,
        &FillOptions::default(),
        &mut BuffersBuilder::new(&mut geometry, |vertex: FillVertex| {
            MyVertex {
                position: vertex.position().to_array(),
            }
        }),
    ).unwrap();

    // The tessellated geometry is ready to be uploaded to the GPU.
    println!(" -- {} vertices {} indices",
        geometry.vertices.len(),
        geometry.indices.len()
    );
}

To use Lyon, you typically follow these steps:

1. Build a Path: Use lyon::path::Path::builder() to define lines, quadratic beziers, and cubic beziers.
2. Define Vertex Type: You can use the default vertex type or define your own (e.g., a struct containing [f32; 2] positions).
3. Initialize Tessellator: Create a FillTessellator.
4. Compute Tessellation: Use tessellate_path with a BuffersBuilder. The BuffersBuilder allows you to map Lyon's internal FillVertex data into your custom vertex format.
5. Output: The result is stored in VertexBuffers<V, I>, which contains the vertices and indices ready for GPU upload.

extern crate lyon;
use lyon::math::point;
use lyon::path::Path;
use lyon::tessellation::*;

fn main() {
    // Build a Path.
    let mut builder = Path::builder();
    builder.begin(point(0.0, 0.0));
    builder.line_to(point(1.0, 0.0));
    builder.quadratic_bezier_to(point(2.0, 0.0), point(2.0, 1.0));
    builder.cubic_bezier_to(point(1.0, 1.0), point(0.0, 1.0), point(0.0, 0.0));
    builder.end(true);
    let path = builder.build();

    // Let's use our own custom vertex type instead of the default one.
    #[derive(Copy, Clone, Debug)]
    struct MyVertex { position: [f32; 2] }

    // Will contain the result of the tessellation.
    let mut geometry: VertexBuffers<MyVertex, u16> = VertexBuffers::new();
    let mut tessellator = FillTessellator::new();
    {
        // Compute the tessellation.
        tessellator.tessellate_path(
            &path,
            &FillOptions::default(),
            &mut BuffersBuilder::new(&mut geometry, |vertex: FillVertex| {
                MyVertex {
                    position: vertex.position().to_array(),
                }
            }),
        ).unwrap();
    }

    // The tessellated geometry is ready to be uploaded to the GPU.
    println!(" -- {} vertices {} indices",
        geometry.vertices.len(),
        geometry.indices.len()
    );
}

Lyon provides an acceleration structure for sampling distances along a path using PathMeasurements. Building these measurements can be expensive, so you should create them once and reuse them for multiple queries.

To perform queries, you create a PathSampler from the PathMeasurements object. The sampler can be configured to use either real distances or normalized distances (0.0 to 1.0).

Key Differences: PathMeasurements vs. PathWalker

• PathWalker computes everything on the fly without storing data.
• PathMeasurements stores data to speed up random access queries.
• PathMeasurements supports normalized distances; PathWalker does not.
• Use PathMeasurements if you can cache the results and perform many queries.

```rust
use lyon_algorithms::{
    math::point,
    path::Path,
    length::approximate_length,
    measure::{PathMeasurements, SampleType},
};

let mut path = Path::builder();
path.begin(point(0.0, 0.0));
path.quadratic_bezier_to(point(1.0, 1.0), point(2.0, 0.0));
path.end(false);
let path = path.build();

// Build the acceleration structure.
let measurements = PathMeasurements::from_path(&path, 1e-3);
let mut sampler = measurements.create_sampler(&path, SampleType::Normalized);

let sample  = sampler.sample(0.5);
println!(

The Pattern trait defines how the path walker decides when to take the next step. To implement it, you must provide a next method that receives a WalkerEvent and returns an Option<f32>.

• If next returns Some(distance), the walker will move distance units along the path before calling the method again.
• If next returns None, path walking stops immediately.

Additionally, you can optionally implement begin to handle the start of each sub-path, allowing you to specify a custom distance to the first step of a new sub-path.

/// Types implementing the `Pattern` can be used to walk along a path
/// at constant speed.
///
/// At each step, the pattern receives the position, tangent and already
/// traversed distance along the path and returns the distance until the
/// next step.
pub trait Pattern {
    /// This method is invoked at each step along the path.
    ///
    /// If this method returns None, path walking stops. Otherwise the returned
    /// value is the distance along the path to the next element in the pattern.
    fn next(&mut self, event: WalkerEvent) -> Option<f32>;

    /// Invoked at the start each sub-path.
    ///
    /// Takes the leftover requested distance from the previous sub-path path,
    /// if any.
    ///
    /// If this method returns None, path walking stops. Otherwise the returned
    /// value is the distance along the path to the next element in the pattern.
    fn begin(&mut self, distance: f32) -> Option<f32> {
        Some(distance)
    }
}

Lyon provides two primary abstractions for constructing paths:

1. PathBuilder: A simple, efficient, and low-level interface. It requires manual management of sub-paths using begin and end methods. All coordinates are absolute. This is the preferred trait to implement when creating new path data structures.
2. SvgPathBuilder: A higher-level interface that follows the SVG specification. It is more permissive and handles corner cases (like adding segments without an explicit begin) automatically, but at a slight runtime cost. It supports relative coordinates and SVG-specific commands (like smooth_cubic_bezier_to).

Relationship: Any implementation of PathBuilder can be converted into an SvgPathBuilder using the .with_svg() adapter method.

// Using PathBuilder (Low-level)
let mut builder = Path::builder();
builder.begin(point(0.0, 0.0));
builder.line_to(point(1.0, 0.0));
builder.end(false);

// Using SvgPathBuilder (High-level adapter)
let mut builder = Path::builder().with_svg();
builder.move_to(point(0.0, 0.0));
builder.line_to(point(1.0, 0.0));