tiny-skia

tiny-skia-path is a Bezier path implementation designed for use with tiny-skia. It provides tools for managing and manipulating paths, specifically focusing on memory efficiency and compatibility with Skia's precision model.

Key features include:

• Bezier path container: A memory-efficient way to store path data.
• Path builder: Tools to construct complex paths.
• Path stroker: Functionality to create outlines (strokes) from paths.
• Path dasher: Functionality to create dashed lines from paths.
• Geometry types: Basic geometric primitives (note: these are planned to move to an external crate in the future).

Technical Note: All types use single-precision floats (f32) to maintain parity with Skia.

Benchmarks require the nightly Rust toolchain. To run the default benchmarks (which only test tiny-skia), install the nightly toolchain and use rustup run nightly cargo bench.

To compare tiny-skia against other libraries like skia-rs, raqote, or cairo-rs, you must enable them via the --features flag. Note that enabling these requires additional setup, such as installing cairo or building Skia from source.

When running benchmarks with the skia-rs feature enabled, you must provide the paths to your Skia installation using the following environment variables:

• SKIA_DIR: The root directory of your Skia build.
• SKIA_LIB_DIR: The directory containing the Skia shared libraries (e.g., out/Shared).
• LD_LIBRARY_PATH: Must include the path to the Skia shared libraries so the linker can find them at runtime.

export SKIA_DIR="/path/to/skia"
export SKIA_LIB_DIR="/path/to/skia/out/Shared"
export LD_LIBRARY_PATH="/path/to/skia/out/Shared"

By default, tiny-skia provides decent performance on x86 targets. However, to achieve better performance by enabling AVX instructions on x86-64, you should compile your application with the RUSTFLAGS environment variable set to -Ctarget-cpu=haswell.

On ARM AArch64, NEON support is included by default and does not require additional flags.

RUSTFLAGS="-Ctarget-cpu=haswell"

A Mask is an 8-bit alpha mask used for clipping and masking operations during drawing. In a mask, black (0) pixels block rendering, while white (255) pixels allow it. Intermediate values are used for gradual masking and anti-aliasing.

Unlike Skia, tiny-skia uses a simple 8-bit alpha mask for efficiency and implementation simplicity.

The Transform struct represents an affine transformation matrix used for 2D coordinate transformations. It uses column-major-column-vector matrix notation.

Note on Validity: Unlike many mathematical libraries, Transform does not guarantee validity. It follows a Skia quirk where non-finite values or zero-scale transforms (like Transform(0, 0, 0, 0, 0, 0)) are technically allowed and do not trigger errors.

Unlike higher-level drawing APIs (like HTML Canvas or Skia), tiny-skia provides low-level drawing primitives. Users are responsible for manually managing:

• World Transforms: Applying transformations to the coordinate system.
• Clipping Masks: Defining the visible area for drawing.
• Styles: Managing how shapes and lines are rendered.

For practical implementation patterns, refer to the examples/ directory in the repository.

A Shader specifies the source color(s) for what is being drawn. If a Paint has a shader, the shader's colors are used instead of the paint's color, but they are modulated by the paint's alpha. This allows you to change the transparency of a shape without modifying the underlying shader.

Supported shader types:

• SolidColor(Color)
• LinearGradient(LinearGradient)
• RadialGradient(RadialGradient)
• SweepGradient(SweepGradient)
• Pattern(Pattern<'a>)

#[derive(Clone, PartialEq, Debug)]
pub enum Shader<'a> {
    /// A solid color shader.
    SolidColor(Color),
    /// A linear gradient shader.
    LinearGradient(LinearGradient),
    /// A radial gradient shader.
    RadialGradient(RadialGradient),
    /// A sweep gradient shader.
    SweepGradient(SweepGradient),
    /// A pattern shader.
    Pattern(Pattern<'a>),
}

The Pixmap struct is a container that owns premultiplied RGBA pixels. It is used as a primary drawing surface in tiny-skia. Pixmap data is not aligned, meaning the width is equal to the stride.

Key Characteristics

• Color Format: Premultiplied RGBA.
• Byte Order: RGBA.
• Memory Layout: Linear, non-aligned (width == stride).
• Constraints: Width is limited by i32::MAX / 4.