gralha-svg-render

Search uses release 0.1.0.1 · 947 definitions

Releases (2)

0.1.0.1 indexed
0.1.0.0 unindexed

Definitions (947)

svg.bend

def filter.blur
def filter.morphology.axisRectangular min/max is separable along the transformed primitive axes.
def filter.morphology
def filter.shadow
def filter.convolution.tapsThe row-major kernel is rotated 180 degrees; target offsets refer to input cells.
def filter.convolution.limits.box
def filter.convolution.boundsResource domains need exact edges; geometric coverage bounds include a tolerance.
def filter.convolution.limits
def filter.convolution.parse
def filter.primitive
def filter.chain
def filter.padding
def filter.present
def filter.density
def filter.source
def filter.render
def filter.cache
def prepare.effect
def prepare.brush
def prepare.paint
def prepare.scenes
def pixel.ppmPortable image export for headless rendering and reference comparisons.
def frame
type TargetA layer covers the device rectangle at (x, y) of w by h pixels; pixel (px, py) lives at index (py - y) * w + (px - x).
def layer.new
def target.index
def target.withinThe target's rectangle intersected with a device box, as a target.
def pixel.lane
def pixel.make
def pixel.packA premultiplied color scaled by f, rounded to 8 bits.
def pixel.round
def pixel.scaleA packed pixel scaled by f in every channel.
def pixel.overfront over back, both premultiplied: front + back * (255 - alpha) / 255 per channel, written as one expression over the four lanes.
def pixel.whiteThe pixel over white as the packed 0xRRGGBB the outputs use.
def pixel.maskThe mask factor a packed pixel gives: its alpha, or the luminance of its premultiplied color.
def blend.got
def blendComposite a packed front over the pixel at index i.
def paint.with
def cover.value
def clip.limitclip.cover, branching through matches since it runs once per clipped pixel.
def paint.limitThe least coverage the enclosing clips leave at p.
def cover.blockA clip's coverage over the device pixel block [x0, x1) by [y0, y1) when it is uniform there, else -1; the frame grid is the device grid.
def cover.block.if
def clip.block
def paint.limit.blockThe least clip coverage over a block when every clip is uniform there, else -1.
def paint.clipped
type PaintCtxWhat one shape's pixels need: the brush (a solid color is kept as a premultiplied color to scale per block), the device-to-local matrix, the color space and the enclosing clips.
def paint.solid
def paint.solid.color
def paint.context
def paint.sampled
def paint.sampled.ctx
def paint.tint.ctx
def paint.color
def paint.ctx.solid
def paint.ctx.direct
def paint.ctx.tint
def paint.ctx.clips
def paint.pixelThe general pixel: brush sampled or solid, coverage limited by the clips; a known block limit (0 or more) replaces the per-pixel clip reads.
def paint.row
def paint.rows
def pixel.underThe fast pixel: a constant packed front blended along the row, its channels split once per row.
def blend.pre.got
def fill.row.pre
def fill.row
def fill.rows
def paint.fromA block's rows or columns within the target: start and count.
def paint.span
def set.row
def set.rows
def fill.rows.mode
def paint.block.mode
def paint.block.knownA block whose clips are uniform paints with that limit folded in: nothing when it is zero, the constant front when the brush is solid, the general row without clip reads otherwise; a block a clip edge crosses reads clips per pixel.
def paint.block.some
def paint.block.limit
def paint.ctx.clipped
def paint.block
def paint.block.if
def paint.tree
def paint.tree.if
def paint.runOne run of a row: the columns within the target, the clip limit over them (per pixel when a clip edge crosses the run), then the row painter.
def paint.runs
def paint.row.if
def paint.rows.go
def paint.rows.of
def paint.solid.row.modeA solid brush with a uniform clip limit paints runs straight: the front for full coverage is packed once per shape, a partial run packs its own, and an opaque front is written without a read.
def paint.solid.run.someThe target rectangle and the tint travel as plain numbers through the run loops: a record passed along would be shared and read again at every run.
def paint.solid.run
def paint.solid.runs
def paint.solid.row.if
def paint.solid.rows.go
def paint.solid.rows
def paint.rows.mode
def paint.dataThe clips are read once over the mask's whole box: uniform there (the usual case, a shape inside the viewport clip), that limit serves every run and nothing reads the clips again; zero there paints nothing.
def paint.data.known
def paint.data.if
def paint.coverA shape's coverage mask on the frame grid, painted with its brush.
def paint.fill.if
def paint.stroke.if
def paint.piecesThe fill, stroke and markers of a shape in its paint order (see paint.order.first): each arm hands the fill's and the stroke's masks to exactly one painter, so the masks are never shared and walked as copies.