Crate vello_cpu

Vello CPU is a 2D graphics rendering engine written in Rust, for devices with no or underpowered GPUs.

It is currently available as an alpha. See the Caveats section for things you need to be aware of.

We also develop Vello, which makes use of the GPU for 2D rendering and has higher performance than Vello CPU. Vello CPU is being developed as part of work to address shortcomings in Vello.

Usage

To use Vello CPU, you need to:

• Create a RenderContext, a 2D drawing context for a fixed-size target area.
• For each object in your scene:
  • Set how the object will be painted, using set_paint.
  • Set the shape to be drawn for that object, using methods like fill_path, stroke_path, or glyph_run.
• Render it to an image using RenderContext::render_to_pixmap.

use vello_cpu::{RenderContext, Pixmap, RenderMode};
use vello_cpu::{color::{palette::css, PremulRgba8}, kurbo::Rect};
let width = 10;
let height = 5;
let mut context = RenderContext::new(width, height);
context.set_paint(css::MAGENTA);
context.fill_rect(&Rect::from_points((3., 1.), (7., 4.)));

let mut target = Pixmap::new(width, height);
context.render_to_pixmap(&mut target, RenderMode::default());

let expected_render = b"\
    0000000000\
    0001111000\
    0001111000\
    0001111000\
    0000000000";
let magenta = css::MAGENTA.premultiply().to_rgba8();
let transparent = PremulRgba8 {r: 0, g: 0, b: 0, a: 0};
let mut result = Vec::new();
for pixel in target.data() {
    if *pixel == magenta {
        result.push(b'1');
    } else if *pixel == transparent {
        result.push(b'0');
    } else {
         panic!("Got unexpected pixel value {pixel:?}");
    }
}
assert_eq!(&result, expected_render);

Features

• std (enabled by default): Get floating point functions from the standard library (likely using your target’s libc).
• libm: Use floating point implementations from libm.
• png(enabled by default): Allow loading Pixmaps from PNG images. Also required for rendering glyphs with an embedded PNG.

At least one of std and libm is required; std overrides libm.

Caveats

Vello CPU is an alpha for several reasons, including the following.

API stability

This API has been developed for an initial version, and has no stability guarantees. Whilst we are in the 0.0.x release series, any release is likely to breaking. We have known plans to change the API around how image resources are used.

Documentation

We have not yet put any work into documentation.

Performance

We do not perform several important optimisations, such as the use of multithreading and SIMD. Additionally, some algorithms we use aren’t final, and will be replaced with higher-performance variants.

Implementation

TODO: Point to documentation of sparse strips pattern.

Re-exports

pub use vello_common::color;

pub use vello_common::kurbo;

pub use vello_common::peniko;

Structs

Glyph

Positioned glyph.

Image

An image.

Mask

A mask.

Pixmap

A pixmap of premultiplied RGBA8 values backed by u8.

RenderContext

A render context.

Enums

Paint

A paint that is used internally by a rendering frontend to store how a wide tile command should be painted. There are only two types of paint:

PaintType

A kind of paint that can be used for filling and stroking shapes.

RenderMode

The selected rendering mode.