Index

Modules: pixie, pixie/blends, pixie/common, pixie/contexts, pixie/fileformats/bmp, pixie/fileformats/gif, pixie/fileformats/jpeg, pixie/fileformats/png, pixie/fileformats/ppm, pixie/fileformats/qoi, pixie/fileformats/svg, pixie/fontformats/opentype, pixie/fontformats/svgfont, pixie/fonts, pixie/images, pixie/internal, pixie/paints, pixie/paths, pixie/simd, pixie/simd/avx, pixie/simd/avx2, pixie/simd/sse2.

API symbols

`$`:

• images: `$`(image: Image): string
• paths: `$`(path: Path): string

`*`:

• common: `*`(color: ColorRGBX; opacity: float32): ColorRGBX
• common: `*`(rgbx: ColorRGBX; opacity: uint8): ColorRGBX

`[]=`:

• images: `[]=`(image: Image; x, y: int; color: SomeColor)
• images: `[]=`(view: UnsafeImage; x, y: int; color: ColorRGBX)

`[]`:

• images: `[]`(image: Image; x, y: int): ColorRGBX
• images: `[]`(view: UnsafeImage; x, y: int): var ColorRGBX

addPath:

• paths: addPath(path: Path; other: Path)

allowSimd:

• simd: allowSimd

AlphabeticBaseline:

• BaselineAlignment.AlphabeticBaseline

angleToMiterLimit:

• paths: angleToMiterLimit(angle: float32): float32

AngularGradientPaint:

• PaintKind.AngularGradientPaint

applyOpacity:

• images: applyOpacity(image: Image; opacity: float32)
• sse2: applyOpacity(color: M128; opacity: float32): ColorRGBX

applyOpacityAvx2:

• avx2: applyOpacityAvx2(image: Image; opacity: float32)

applyOpacitySse2:

• sse2: applyOpacitySse2(image: Image; opacity: float32)

arc:

• contexts: arc(ctx: Context; x, y, r, a0, a1: float32; ccw: bool = false)
• contexts: arc(ctx: Context; pos: Vec2; r: float32; a: Vec2; ccw: bool = false)
• paths: arc(path: Path; x, y, r, a0, a1: float32; ccw: bool = false)
• paths: arc(path: Path; pos: Vec2; r: float32; a: Vec2; ccw: bool = false)

arcTo:

• contexts: arcTo(ctx: Context; x1, y1, x2, y2, radius: float32)
• contexts: arcTo(ctx: Context; a, b: Vec2; r: float32)
• paths: arcTo(path: Path; x1, y1, x2, y2, r: float32)
• paths: arcTo(path: Path; a, b: Vec2; r: float32)

Arrangement:

• fonts: Arrangement

ascent:

• fonts: ascent(typeface: Typeface): float32

autoLineHeight:

• fonts: autoLineHeight

autoPremultipliedAlpha:

• pixie: autoPremultipliedAlpha(c: ColorRGBA): ColorRGBX

autoStraightAlpha:

• pixie: autoStraightAlpha(c: ColorRGBX): ColorRGBA

BaselineAlignment:

• contexts: BaselineAlignment

beginPath:

• contexts: beginPath(ctx: Context)

BevelJoin:

• LineJoin.BevelJoin

bezierCurveTo:

• contexts: bezierCurveTo(ctx: Context; cp1x, cp1y, cp2x, cp2y, x, y: float32)
• contexts: bezierCurveTo(ctx: Context; cp1, cp2, to: Vec2)
• paths: bezierCurveTo(path: Path; x1, y1, x2, y2, x3, y3: float32)
• paths: bezierCurveTo(path: Path; ctrl1, ctrl2, to: Vec2)

blendAlpha:

• blends: blendAlpha(backdrop, source: uint8): uint8

blendColor:

• blends: blendColor(backdrop, source: ColorRGBX): ColorRGBX

blendColorBurn:

• blends: blendColorBurn(backdrop, source: ColorRGBX): ColorRGBX

blendColorDodge:

• blends: blendColorDodge(backdrop, source: ColorRGBX): ColorRGBX

blendDarken:

• blends: blendDarken(backdrop, source: ColorRGBX): ColorRGBX

blendDifference:

• blends: blendDifference(backdrop, source: ColorRGBX): ColorRGBX

Blender:

• blends: Blender

blender:

• blends: blender(blendMode: BlendMode): Blender

blendExcludeMask:

• blends: blendExcludeMask(backdrop, source: ColorRGBX): ColorRGBX

blendExclusion:

• blends: blendExclusion(backdrop, source: ColorRGBX): ColorRGBX

blendHardLight:

• blends: blendHardLight(backdrop, source: ColorRGBX): ColorRGBX

blendHue:

• blends: blendHue(backdrop, source: ColorRGBX): ColorRGBX

blendLighten:

• blends: blendLighten(backdrop, source: ColorRGBX): ColorRGBX

blendLineCoverageMaskAvx2:

• avx2: blendLineCoverageMaskAvx2(line: ptr UncheckedArray[ColorRGBX]; coverages: ptr UncheckedArray[uint8]; rgbx: ColorRGBX; len: int)

blendLineCoverageMaskSse2:

• sse2: blendLineCoverageMaskSse2(line: ptr UncheckedArray[ColorRGBX]; coverages: ptr UncheckedArray[uint8]; rgbx: ColorRGBX; len: int)

blendLineCoverageNormalAvx2:

• avx2: blendLineCoverageNormalAvx2(line: ptr UncheckedArray[ColorRGBX]; coverages: ptr UncheckedArray[uint8]; rgbx: ColorRGBX; len: int)

blendLineCoverageNormalSse2:

• sse2: blendLineCoverageNormalSse2(line: ptr UncheckedArray[ColorRGBX]; coverages: ptr UncheckedArray[uint8]; rgbx: ColorRGBX; len: int)

blendLineCoverageOverwriteAvx2:

• avx2: blendLineCoverageOverwriteAvx2(line: ptr UncheckedArray[ColorRGBX]; coverages: ptr UncheckedArray[uint8]; rgbx: ColorRGBX; len: int)

blendLineCoverageOverwriteSse2:

• sse2: blendLineCoverageOverwriteSse2(line: ptr UncheckedArray[ColorRGBX]; coverages: ptr UncheckedArray[uint8]; rgbx: ColorRGBX; len: int)

blendLineMaskAvx2:

• avx2: blendLineMaskAvx2(line: ptr UncheckedArray[ColorRGBX]; rgbx: ColorRGBX; len: int)
• avx2: blendLineMaskAvx2(a, b: ptr UncheckedArray[ColorRGBX]; len: int)

blendLineMaskSse2:

• sse2: blendLineMaskSse2(line: ptr UncheckedArray[ColorRGBX]; rgbx: ColorRGBX; len: int)
• sse2: blendLineMaskSse2(a, b: ptr UncheckedArray[ColorRGBX]; len: int)

blendLineNormalAvx2:

• avx2: blendLineNormalAvx2(line: ptr UncheckedArray[ColorRGBX]; rgbx: ColorRGBX; len: int)
• avx2: blendLineNormalAvx2(a, b: ptr UncheckedArray[ColorRGBX]; len: int)

blendLineNormalSse2:

• sse2: blendLineNormalSse2(line: ptr UncheckedArray[ColorRGBX]; rgbx: ColorRGBX; len: int)
• sse2: blendLineNormalSse2(a, b: ptr UncheckedArray[ColorRGBX]; len: int)

blendLuminosity:

• blends: blendLuminosity(backdrop, source: ColorRGBX): ColorRGBX

blendMask:

• blends: blendMask(backdrop, source: ColorRGBX): ColorRGBX

BlendMode:

• common: BlendMode

blendMultiply:

• blends: blendMultiply(backdrop, source: ColorRGBX): ColorRGBX

blendNormal:

• blends: blendNormal(backdrop, source: ColorRGBX): ColorRGBX

blendOverlay:

• blends: blendOverlay(backdrop, source: ColorRGBX): ColorRGBX

blendSaturation:

• blends: blendSaturation(backdrop, source: ColorRGBX): ColorRGBX

blendScreen:

• blends: blendScreen(backdrop, source: ColorRGBX): ColorRGBX

blendSoftLight:

• blends: blendSoftLight(backdrop, source: ColorRGBX): ColorRGBX

blendSubtractMask:

• blends: blendSubtractMask(backdrop, source: ColorRGBX): ColorRGBX

blur:

• images: blur(image: Image; radius: float32; outOfBounds: SomeColor = color(0, 0, 0, 0))

BmpFormat:

• FileFormat.BmpFormat

bmpSignature:

• bmp: bmpSignature

BottomAlign:

• VerticalAlignment.BottomAlign

BottomBaseline:

• BaselineAlignment.BottomBaseline

ButtCap:

• LineCap.ButtCap

ceil:

• images: ceil(image: Image)

ceilAvx2:

• avx2: ceilAvx2(image: Image)

ceilSse2:

• sse2: ceilSse2(image: Image)

CenterAlign:

• HorizontalAlignment.CenterAlign

circle:

• contexts: circle(ctx: Context; circle: Circle)
• contexts: circle(ctx: Context; cx, cy, r: float32)
• paths: circle(path: Path; circle: Circle)
• paths: circle(path: Path; cx, cy, r: float32)

clearRect:

• contexts: clearRect(ctx: Context; x, y, width, height: float32)
• contexts: clearRect(ctx: Context; rect: Rect)

clip:

• contexts: clip(ctx: Context; windingRule = NonZero)
• contexts: clip(ctx: Context; path: Path; windingRule = NonZero)

closePath:

• contexts: closePath(ctx: Context)
• paths: closePath(path: Path)

CmapTable:

• opentype: CmapTable

ColorBlend:

• BlendMode.ColorBlend

ColorBurnBlend:

• BlendMode.ColorBurnBlend

ColorDodgeBlend:

• BlendMode.ColorDodgeBlend

Colorspace:

• qoi: Colorspace

ColorStop:

• paints: ColorStop

colorStop:

• paints: colorStop(color: Color; position: float32): ColorStop

computeBounds:

• fonts: computeBounds(arrangement: Arrangement; transform = mat3()): Rect
• paths: computeBounds(path: Path; transform = mat3()): Rect

Context:

• contexts: Context

convertToImage:

• png: convertToImage(png: Png): Image
• qoi: convertToImage(qoi: Qoi): Image

copy:

• common: copy(image: Image): Image
• fonts: copy(font: Font): Font
• paints: copy(paint: Paint): Paint
• paths: copy(path: Path): Path

cpuHasAvx:

• simd: cpuHasAvx

cpuHasAvx2:

• simd: cpuHasAvx2

currentExceptionAsPixieError:

• internal: currentExceptionAsPixieError(): untyped

DarkenBlend:

• BlendMode.DarkenBlend

dataIndex:

• common: dataIndex(image: Image; x, y: int): int

decodeBmp:

• bmp: decodeBmp(data: string): Image

decodeBmpDimensions:

• bmp: decodeBmpDimensions(data: string): ImageDimensions

decodeDib:

• bmp: decodeDib(data: pointer; len: int; lpBitmapInfo = false): Image

decodeGif:

• gif: decodeGif(data: string): Gif

decodeGifDimensions:

• gif: decodeGifDimensions(data: string): ImageDimensions

decodeImage:

• pixie: decodeImage(data: string): Image

decodeImageDimensions:

• pixie: decodeImageDimensions(data: string): ImageDimensions

decodeJpeg:

• jpeg: decodeJpeg(data: string): Image

decodeJpegDimensions:

• jpeg: decodeJpegDimensions(data: string): ImageDimensions

decodePng:

• png: decodePng(data: pointer; len: int): Png
• png: decodePng(data: string): Png

decodePngDimensions:

• png: decodePngDimensions(data: pointer; len: int): ImageDimensions
• png: decodePngDimensions(data: string): ImageDimensions

decodePpm:

• ppm: decodePpm(data: string): Image

decodePpmDimensions:

• ppm: decodePpmDimensions(data: string): ImageDimensions

decodeQoi:

• qoi: decodeQoi(data: string): Qoi

decodeQoiDimensions:

• qoi: decodeQoiDimensions(data: string): ImageDimensions

defaultLineHeight:

• fonts: defaultLineHeight(font: Font): float32

defaultMiterLimit:

• paths: defaultMiterLimit

descent:

• fonts: descent(typeface: Typeface): float32

diff:

• images: diff(master, image: Image): (float32, Image)

DifferenceBlend:

• BlendMode.DifferenceBlend

draw:

• images: draw(a, b: Image; transform = mat3(); blendMode = NormalBlend)

drawImage:

• contexts: drawImage(ctx: Context; image: Image; dx, dy: float32)
• contexts: drawImage(ctx: Context; image: Image; dx, dy, dWidth, dHeight: float32)
• contexts: drawImage(ctx: Context; image: Image; sx, sy, sWidth, sHeight, dx, dy, dWidth, dHeight: float32)
• contexts: drawImage(ctx: Context; image: Image; rect: Rect)
• contexts: drawImage(ctx: Context; image: Image; src, dest: Rect)
• contexts: drawImage(ctx: Context; image: Image; pos: Vec2)

drawTiled:

• images: drawTiled(dst, src: Image; mat: Mat3; blendMode = NormalBlend)

ellipse:

• contexts: ellipse(ctx: Context; x, y, rx, ry: float32)
• contexts: ellipse(ctx: Context; center: Vec2; rx, ry: float32)
• paths: ellipse(path: Path; cx, cy, rx, ry: float32)
• paths: ellipse(path: Path; center: Vec2; rx, ry: float32)

ellipticalArcTo:

• paths: ellipticalArcTo(path: Path; rx, ry: float32; xAxisRotation: float32; largeArcFlag, sweepFlag: bool; x, y: float32)

encodeBmp:

• bmp: encodeBmp(image: Image): string

encodeDib:

• bmp: encodeDib(image: Image): string

encodeImage:

• pixie: encodeImage(image: Image; fileFormat: FileFormat): string

encodePng:

• png: encodePng(image: Image): string
• png: encodePng(width, height, channels: int; data: pointer; len: int): string
• png: encodePng(png: Png): string

encodePpm:

• ppm: encodePpm(image: Image): string

encodeQoi:

• qoi: encodeQoi(image: Image): string
• qoi: encodeQoi(qoi: Qoi): string

EncodingRecord:

• opentype: EncodingRecord

EvenOdd:

• WindingRule.EvenOdd

ExcludeMaskBlend:

• BlendMode.ExcludeMaskBlend

ExclusionBlend:

• BlendMode.ExclusionBlend

failUnsupportedBlendMode:

• internal: failUnsupportedBlendMode(blendMode: BlendMode)

fallbackTypeface:

• fonts: fallbackTypeface(typeface: Typeface; rune: Rune): Typeface

FileFormat:

• pixie: FileFormat

fill:

• pixie: fill(image: Image; paint: Paint)
• contexts: fill(ctx: Context; windingRule = NonZero)
• contexts: fill(ctx: Context; path: Path; windingRule = NonZero)
• images: fill(image: Image; color: SomeColor)

fillCircle:

• contexts: fillCircle(ctx: Context; circle: Circle)

fillEllipse:

• contexts: fillEllipse(ctx: Context; center: Vec2; rx, ry: float32)

fillGradient:

• paints: fillGradient(image: Image; paint: Paint)

fillOverlaps:

• paths: fillOverlaps(path: Path; test: Vec2; transform = mat3(); ## Applied to the path, not the test point. windingRule = NonZero): bool

fillPath:

• paths: fillPath(image: Image; path: SomePath; paint: Paint; transform = mat3(); windingRule = NonZero)

fillPolygon:

• contexts: fillPolygon(ctx: Context; pos: Vec2; size: float32; sides: int)

fillRect:

• contexts: fillRect(ctx: Context; x, y, width, height: float32)
• contexts: fillRect(ctx: Context; rect: Rect)

fillRoundedRect:

• contexts: fillRoundedRect(ctx: Context; rect: Rect; radius: float32)
• contexts: fillRoundedRect(ctx: Context; rect: Rect; nw, ne, se, sw: float32)

fillText:

• contexts: fillText(ctx: Context; text: string; x, y: float32)
• contexts: fillText(ctx: Context; text: string; at: Vec2)
• fonts: fillText(target: Image; arrangement: Arrangement; transform = mat3())
• fonts: fillText(target: Image; font: Font; text: sink string; transform = mat3(); bounds = vec2(0, 0); hAlign = LeftAlign; vAlign = TopAlign)

fillUnsafe:

• internal: fillUnsafe(data: var seq[ColorRGBX]; color: SomeColor; start, len: int)

fillUnsafeAvx:

• avx: fillUnsafeAvx(data: var seq[ColorRGBX]; color: SomeColor; start, len: int)

fillUnsafeSse2:

• sse2: fillUnsafeSse2(data: var seq[ColorRGBX]; color: SomeColor; start, len: int)

flipHorizontal:

• images: flipHorizontal(image: Image)

flipVertical:

• images: flipVertical(image: Image)

Font:

• fonts: Font

fullName:

• opentype: fullName(opentype: OpenType): string

gaussianKernel:

• internal: gaussianKernel(radius: int): seq[uint16]

getAdvance:

• opentype: getAdvance(opentype: OpenType; rune: Rune): float32
• svgfont: getAdvance(svgFont: SvgFont; rune: Rune): float32
• fonts: getAdvance(typeface: Typeface; rune: Rune): float32

getColor:

• images: getColor(image: Image; x, y: int): Color

getGlyphPath:

• opentype: getGlyphPath(opentype: OpenType; rune: Rune): Path
• svgfont: getGlyphPath(svgFont: SvgFont; rune: Rune): Path
• fonts: getGlyphPath(typeface: Typeface; rune: Rune): Path

getKerningAdjustment:

• opentype: getKerningAdjustment(opentype: OpenType; left, right: Rune): float32
• svgfont: getKerningAdjustment(svgFont: SvgFont; left, right: Rune): float32
• fonts: getKerningAdjustment(typeface: Typeface; left, right: Rune): float32

getLeftSideBearing:

• opentype: getLeftSideBearing(opentype: OpenType; rune: Rune): float32

getLineDash:

• contexts: getLineDash(ctx: Context): seq[float32]

getRgbaSmooth:

• images: getRgbaSmooth(image: Image; x, y: float32; wrapped = false): ColorRGBX

getTransform:

• contexts: getTransform(ctx: Context): Mat3

getUncheckedArray:

• internal: getUncheckedArray(image: Image; x, y: int): ptr UncheckedArray[ColorRGBX]

Gif:

• gif: Gif

GifFormat:

• FileFormat.GifFormat

gifSignatures:

• gif: gifSignatures

GlyfTable:

• opentype: GlyfTable

HangingBaseline:

• BaselineAlignment.HangingBaseline

HardLightBlend:

• BlendMode.HardLightBlend

hasGlyph:

• opentype: hasGlyph(opentype: OpenType; rune: Rune): bool
• svgfont: hasGlyph(svgFont: SvgFont; rune: Rune): bool
• fonts: hasGlyph(typeface: Typeface; rune: Rune): bool

HeadTable:

• opentype: HeadTable

HheaTable:

• opentype: HheaTable

HmtxTable:

• opentype: HmtxTable

HorizontalAlignment:

• fonts: HorizontalAlignment

HueBlend:

• BlendMode.HueBlend

IdeographicBaseline:

• BaselineAlignment.IdeographicBaseline

Image:

• common: Image

ImageDimensions:

• common: ImageDimensions

ImagePaint:

• PaintKind.ImagePaint

inside:

• images: inside(image: Image; x, y: int): bool

intersectsInside:

• internal: intersectsInside(a, b: Segment; at: var Vec2): bool

invert:

• images: invert(image: Image)

invertAvx2:

• avx2: invertAvx2(image: Image)

invertSse2:

• sse2: invertSse2(image: Image)

isCCW:

• opentype: isCCW(opentype: OpenType): bool

isOneColor:

• images: isOneColor(image: Image): bool

isOneColorAvx2:

• avx2: isOneColorAvx2(image: Image): bool

isOneColorSse2:

• sse2: isOneColorSse2(image: Image): bool

isOpaque:

• images: isOpaque(image: Image): bool
• internal: isOpaque(data: var seq[ColorRGBX]; start, len: int): bool

isOpaqueAvx2:

• avx2: isOpaqueAvx2(data: var seq[ColorRGBX]; start, len: int): bool

isOpaqueSse2:

• sse2: isOpaqueSse2(data: var seq[ColorRGBX]; start, len: int): bool

isPointInPath:

• contexts: isPointInPath(ctx: Context; x, y: float32; windingRule = NonZero): bool
• contexts: isPointInPath(ctx: Context; path: Path; x, y: float32; windingRule = NonZero): bool
• contexts: isPointInPath(ctx: Context; path: Path; pos: Vec2; windingRule = NonZero): bool
• contexts: isPointInPath(ctx: Context; pos: Vec2; windingRule = NonZero): bool

isPointInStroke:

• contexts: isPointInStroke(ctx: Context; x, y: float32): bool
• contexts: isPointInStroke(ctx: Context; path: Path; x, y: float32): bool
• contexts: isPointInStroke(ctx: Context; path: Path; pos: Vec2): bool
• contexts: isPointInStroke(ctx: Context; pos: Vec2): bool

isTransparent:

• images: isTransparent(image: Image): bool

isTransparentAvx2:

• avx2: isTransparentAvx2(image: Image): bool

isTransparentSse2:

• sse2: isTransparentSse2(image: Image): bool

JpegFormat:

• FileFormat.JpegFormat

jpegStartOfImage:

• jpeg: jpegStartOfImage

KernPair:

• opentype: KernPair

KernSubTable:

• opentype: KernSubTable

KernTable:

• opentype: KernTable

layoutBounds:

• fonts: layoutBounds(arrangement: Arrangement): Vec2
• fonts: layoutBounds(font: Font; text: string): Vec2
• fonts: layoutBounds(spans: seq[Span]): Vec2

LeftAlign:

• HorizontalAlignment.LeftAlign

LightenBlend:

• BlendMode.LightenBlend

Linear:

• Colorspace.Linear

LinearGradientPaint:

• PaintKind.LinearGradientPaint

LineCap:

• paths: LineCap

lineGap:

• fonts: lineGap(typeface: Typeface): float32

lineHeight:

• fonts: lineHeight(typeface: Typeface): float32

LineJoin:

• paths: LineJoin

lineTo:

• contexts: lineTo(ctx: Context; x, y: float32)
• contexts: lineTo(ctx: Context; v: Vec2)
• paths: lineTo(path: Path; x, y: float32)
• paths: lineTo(path: Path; v: Vec2)

LocaTable:

• opentype: LocaTable

LongHorMetricRecord:

• opentype: LongHorMetricRecord

LowerCase:

• TextCase.LowerCase

LuminosityBlend:

• BlendMode.LuminosityBlend

magnifyBy2:

• images: magnifyBy2(image: Image; power = 1): Image

magnifyBy2Sse2:

• sse2: magnifyBy2Sse2(image: Image; power = 1): Image

MaskBlend:

• BlendMode.MaskBlend

MaxpTable:

• opentype: MaxpTable

measureText:

• contexts: measureText(ctx: Context; text: string): TextMetrics

MiddleAlign:

• VerticalAlignment.MiddleAlign

MiddleBaseline:

• BaselineAlignment.MiddleBaseline

minifyBy2:

• images: minifyBy2(image: Image; power = 1): Image

minifyBy2Avx2:

• avx2: minifyBy2Avx2(image: Image; power = 1): Image

minifyBy2Sse2:

• sse2: minifyBy2Sse2(image: Image; power = 1): Image

MiterJoin:

• LineJoin.MiterJoin

miterLimitToAngle:

• paths: miterLimitToAngle(limit: float32): float32

mix:

• common: mix(a, b: ColorRGBX; t: float32): ColorRGBX

moveTo:

• contexts: moveTo(ctx: Context; x, y: float32)
• contexts: moveTo(ctx: Context; v: Vec2)
• paths: moveTo(path: Path; x, y: float32)
• paths: moveTo(path: Path; v: Vec2)

MultiplyBlend:

• BlendMode.MultiplyBlend

name:

• fonts: name(typeface: Typeface): string

NameRecord:

• opentype: NameRecord

NameTable:

• opentype: NameTable

newContext:

• contexts: newContext(image: Image): Context
• contexts: newContext(width, height: int): Context

newFont:

• fonts: newFont(typeface: Typeface): Font

newImage:

• common: newImage(width, height: int): Image
• gif: newImage(gif: Gif): Image
• png: newImage(png: Png): Image
• qoi: newImage(qoi: Qoi): Image
• svg: newImage(svg: Svg): Image

newPaint:

• paints: newPaint(kind: PaintKind): Paint

newPath:

• paths: newPath(): Path

newSpan:

• fonts: newSpan(text: sink string; font: Font): Span

NonZero:

• WindingRule.NonZero

NormalBlend:

• BlendMode.NormalBlend

NormalCase:

• TextCase.NormalCase

opaqueBounds:

• images: opaqueBounds(image: Image): Rect

OpenType:

• opentype: OpenType

OS2Table:

• opentype: OS2Table

OverlayBlend:

• BlendMode.OverlayBlend

OverwriteBlend:

• BlendMode.OverwriteBlend

paint:

• fonts: paint(font: Font): Paint

Paint:

• paints: Paint

paint=:

• fonts: paint=(font: Font; paint: Paint)

PaintKind:

• paints: PaintKind

parseOpenType:

• opentype: parseOpenType(buf: string; startLoc = 0): OpenType

parseOpenTypeCollection:

• opentype: parseOpenTypeCollection(buf: string): seq[OpenType]

parseOtf:

• fonts: parseOtf(buf: string): Typeface

parsePath:

• paths: parsePath(path: string): Path

parseSomePaint:

• paints: parseSomePaint(paint: SomePaint): Paint

parseSvg:

• svg: parseSvg(data: string | XmlNode; width = 0; height = 0): Svg

parseSvgFont:

• svgfont: parseSvgFont(buf: string): SvgFont
• fonts: parseSvgFont(buf: string): Typeface

parseTtf:

• fonts: parseTtf(buf: string): Typeface

Path:

• paths: Path

PixieError:

• common: PixieError

Png:

• png: Png

PngFormat:

• FileFormat.PngFormat

pngSignature:

• png: pngSignature

polygon:

• contexts: polygon(ctx: Context; x, y, size: float32; sides: int)
• contexts: polygon(ctx: Context; pos: Vec2; size: float32; sides: int)
• paths: polygon(path: Path; x, y, size: float32; sides: int)
• paths: polygon(path: Path; pos: Vec2; size: float32; sides: int)

PpmFormat:

• FileFormat.PpmFormat

ppmSignatures:

• ppm: ppmSignatures

Qoi:

• qoi: Qoi

QoiFormat:

• FileFormat.QoiFormat

qoiSignature:

• qoi: qoiSignature

quadraticCurveTo:

• contexts: quadraticCurveTo(ctx: Context; cpx, cpy, x, y: float32)
• contexts: quadraticCurveTo(ctx: Context; ctrl, to: Vec2)
• paths: quadraticCurveTo(path: Path; x1, y1, x2, y2: float32)
• paths: quadraticCurveTo(path: Path; ctrl, to: Vec2)

RadialGradientPaint:

• PaintKind.RadialGradientPaint

readFont:

• fonts: readFont(filePath: string): Font

readImage:

• pixie: readImage(filePath: string): Image

readImageDimensions:

• pixie: readImageDimensions(filePath: string): ImageDimensions

readTypeface:

• fonts: readTypeface(filePath: string): Typeface

readTypefaces:

• fonts: readTypefaces(filePath: string): seq[Typeface]

rect:

• contexts: rect(ctx: Context; x, y, width, height: float32)
• contexts: rect(ctx: Context; rect: Rect)
• paths: rect(path: Path; x, y, w, h: float32; clockwise = true)
• paths: rect(path: Path; rect: Rect; clockwise = true)

resetTransform:

• contexts: resetTransform(ctx: Context)

resize:

• images: resize(srcImage: Image; width, height: int): Image

restore:

• contexts: restore(ctx: Context)

RightAlign:

• HorizontalAlignment.RightAlign

rotate:

• contexts: rotate(ctx: Context; angle: float32)

rotate90:

• images: rotate90(image: Image)

RoundCap:

• LineCap.RoundCap

roundedRect:

• contexts: roundedRect(ctx: Context; x, y, w, h, nw, ne, se, sw: float32)
• contexts: roundedRect(ctx: Context; rect: Rect; nw, ne, se, sw: float32)
• paths: roundedRect(path: Path; x, y, w, h, nw, ne, se, sw: float32; clockwise = true)
• paths: roundedRect(path: Path; rect: Rect; nw, ne, se, sw: float32; clockwise = true)

RoundJoin:

• LineJoin.RoundJoin

SaturationBlend:

• BlendMode.SaturationBlend

save:

• contexts: save(ctx: Context)

saveLayer:

• contexts: saveLayer(ctx: Context)

scale:

• contexts: scale(ctx: Context; x, y: float32)
• contexts: scale(ctx: Context; v: Vec2)
• fonts: scale(font: Font): float32
• fonts: scale(typeface: Typeface): float32

ScreenBlend:

• BlendMode.ScreenBlend

setColor:

• images: setColor(image: Image; x, y: int; color: Color)

setLineDash:

• contexts: setLineDash(ctx: Context; lineDash: seq[float32])

setTransform:

• contexts: setTransform(ctx: Context; transform: Mat3)

shadow:

• images: shadow(image: Image; offset: Vec2; spread, blur: float32; color: SomeColor): Image

snapToPixels:

• common: snapToPixels(rect: Rect): Rect

SoftLightBlend:

• BlendMode.SoftLightBlend

SolidPaint:

• PaintKind.SolidPaint

SomePaint:

• paints: SomePaint

SomePath:

• paths: SomePath

Span:

• fonts: Span

SquareCap:

• LineCap.SquareCap

sRBG:

• Colorspace.sRBG

stroke:

• contexts: stroke(ctx: Context)
• contexts: stroke(ctx: Context; path: Path)

strokeCircle:

• contexts: strokeCircle(ctx: Context; circle: Circle)

strokeEllipse:

• contexts: strokeEllipse(ctx: Context; center: Vec2; rx, ry: float32)

strokeOverlaps:

• paths: strokeOverlaps(path: Path; test: Vec2; transform = mat3(); ## Applied to the path, not the test point. strokeWidth: float32 = 1.0; lineCap = ButtCap; lineJoin = MiterJoin; miterLimit = defaultMiterLimit; dashes: seq[float32] = @[]): bool

strokePath:

• paths: strokePath(image: Image; path: SomePath; paint: Paint; transform = mat3(); strokeWidth: float32 = 1.0; lineCap = ButtCap; lineJoin = MiterJoin; miterLimit = defaultMiterLimit; dashes: seq[float32] = @[])

strokePolygon:

• contexts: strokePolygon(ctx: Context; pos: Vec2; size: float32; sides: int)

strokeRect:

• contexts: strokeRect(ctx: Context; x, y, width, height: float32)
• contexts: strokeRect(ctx: Context; rect: Rect)

strokeRoundedRect:

• contexts: strokeRoundedRect(ctx: Context; rect: Rect; radius: float32)
• contexts: strokeRoundedRect(ctx: Context; rect: Rect; nw, ne, se, sw: float32)

strokeSegment:

• contexts: strokeSegment(ctx: Context; ax, ay, bx, by: float32)
• contexts: strokeSegment(ctx: Context; segment: Segment)

strokeText:

• contexts: strokeText(ctx: Context; text: string; x, y: float32)
• contexts: strokeText(ctx: Context; text: string; at: Vec2)
• fonts: strokeText(target: Image; arrangement: Arrangement; transform = mat3(); strokeWidth: float32 = 1.0; lineCap = ButtCap; lineJoin = MiterJoin; miterLimit = defaultMiterLimit; dashes: seq[float32] = @[])
• fonts: strokeText(target: Image; font: Font; text: sink string; transform = mat3(); strokeWidth: float32 = 1.0; bounds = vec2(0, 0); hAlign = LeftAlign; vAlign = TopAlign; lineCap = ButtCap; lineJoin = MiterJoin; miterLimit = defaultMiterLimit; dashes: seq[float32] = @[])

subImage:

• images: subImage(image: Image; x, y, w, h: int): Image
• images: subImage(image: Image; rect: Rect): Image

SubtractMaskBlend:

• BlendMode.SubtractMaskBlend

superImage:

• images: superImage(image: Image; x, y, w, h: int): Image

Svg:

• svg: Svg

SvgFont:

• svgfont: SvgFont

svgSignature:

• svg: svgSignature

TableRecord:

• opentype: TableRecord

TextCase:

• fonts: TextCase

TextMetrics:

• contexts: TextMetrics

TiledImagePaint:

• PaintKind.TiledImagePaint

TitleCase:

• TextCase.TitleCase

TopAlign:

• VerticalAlignment.TopAlign

TopBaseline:

• BaselineAlignment.TopBaseline

toPremultipliedAlpha:

• internal: toPremultipliedAlpha(data: var seq[ColorRGBA | ColorRGBX])

toPremultipliedAlphaAvx2:

• avx2: toPremultipliedAlphaAvx2(data: var seq[ColorRGBA | ColorRGBX])

toPremultipliedAlphaSse2:

• sse2: toPremultipliedAlphaSse2(data: var seq[ColorRGBA | ColorRGBX])

toStraightAlpha:

• internal: toStraightAlpha(data: var seq[ColorRGBA | ColorRGBX])

transform:

• contexts: transform(ctx: Context; transform: Mat3)
• paths: transform(path: Path; mat: Mat3)

translate:

• contexts: translate(ctx: Context; x, y: float32)
• contexts: translate(ctx: Context; v: Vec2)

Typeface:

• fonts: Typeface

typeset:

• fonts: typeset(font: Font; text: sink string; bounds = vec2(0, 0); hAlign = LeftAlign; vAlign = TopAlign; wrap = true): Arrangement
• fonts: typeset(spans: openArray[Span]; bounds = vec2(0, 0); hAlign = LeftAlign; vAlign = TopAlign; wrap = true): Arrangement

unsafe:

• images: unsafe(src: Image): UnsafeImage

UpperCase:

• TextCase.UpperCase

VerticalAlignment:

• fonts: VerticalAlignment

WindingRule:

• paths: WindingRule

writeFile:

• pixie: writeFile(image: Image; filePath: string)

xmlSignature:

• svg: xmlSignature