lib-svg

lib-svg architecture

kinogaki-svg turns SVG text into pixels in five stages, each a module with one responsibility. The design follows luce-svg's full renderer (itself modelled on resvg's usvg/resvg split), so behavior can be compared stage by stage, but the data structures are Rust's: borrowed strings through parsing, an owned render tree with shared (Arc) paint servers, and a renderer that streams coverage rows.

The rasterizer

Every fill and stroke becomes closed outlines in device pixels. Rasterizer::resolve sorts the lines by top and walks bands of 16 rows. Each line adds, to an accumulation buffer, the signed area it contributes to every cell it crosses (the technique of font rasterizers): a running sum along a row then gives each pixel's winding-weighted covered area, which the fill rule folds (nonzero: |a| clamped to 1; even-odd: folded at every two). This is exact wherever the outline does not overlap itself within a pixel. When a row has a pixel whose winding exceeds one and an edge crossing it (two coincident contours, say), that row is resolved again exactly: sixteen sub-scanlines, each sweeping its crossings with the winding counted and adding the exact horizontal extent of the spans inside. Coverage rows stream to the painter, so memory is bounded by the shape's width, not its area.

Strokes

A stroke is built in user space and mapped to the device piece by piece, so non-uniform transforms stretch it as SVG asks. An open polyline becomes one outline: the left offset forward, the end cap, the right offset backward, the start cap; a closed one two loops. The outer side of each vertex gets the join (miter, miter-clip, bevel, round arc); the inner side the point where the offset lines cross, or a pivot through the vertex when they do not cross within both segments. As chains this outline equals the sum of every segment's rectangle and every join's wedge, all wound alike, so under the nonzero rule it covers exactly their union. Dashes cut the flattened path first; curves are measured as tiny-skia measures them (a polyline within 0.5 / resolution scale, quadratics by their own rule), so dash ends land where resvg puts them.

Rendering

The renderer walks the tree with the transform so far. A group that needs isolation (opacity, clip, mask, filters, blend mode, isolation) draws into a layer sized to its content's conservative device bounds; clip and mask coverage multiply the layer, which composites onto its parent. A group isolated only by opacity whose sole child is a shape with one paint is drawn without a layer, the opacity folded into the paint (identical output). Compositing is in sRGB as browsers and resvg composite; RenderOptions { linear: true } composites in linear light.

Bounds on work

Limits caps source bytes, nesting depth, node count, entity expansion, use copies, bitmap sides and the steps reading a document takes (max_work: each test of a selector against an element, so a selector of many descendant combinators can't try its combinations without end, and each element converted, so a clip path's, mask's or marker's content, converted again at each use, can't multiply through nesting); past it the document is refused. href chains stop after 64 links, patterns nest at most 16 deep, SVG images 8 deep, a drawing cuts at most 16,777,216 dashes across its strokes and their runs, flattening stops after 1000 pieces a curve, turbulence keeps its lattice in floats so any base frequency is a number, and every geometric computation tolerates NaN and infinite input. tests/robustness.rs feeds mutated icons, random markup and numeric extremes through parse and render.

Dependencies

None at run time. The tools crate and the conformance tests use resvg 0.45.1 as the reference renderer.