vector

type FillRule ¶

type FillRule int

FillRule selects how a path's winding count decides which side of the outline is "inside" and therefore filled.

const (
	// NonZero fills a point when the signed edge-crossing count around it is
	// non-zero. Overlapping sub-paths that wind the same way merge into a solid
	// region; this is the intuitive rule for most icon shapes.
	NonZero FillRule = iota

	// EvenOdd fills a point when the crossing count is odd. Overlapping regions
	// alternate filled/empty, so a shape drawn over itself punches a hole — the
	// rule that turns a self-overlapping star's centre into a cut-out.
	EvenOdd
)

type LineCap ¶ added in v0.9.0

type LineCap int

A LineCap says how the open end of a stroke is finished.

const (
	// ButtCap stops the stroke square at the end point.
	ButtCap LineCap = iota
	// RoundCap finishes it with a half disc.
	RoundCap
	// SquareCap carries it half a width past the end point.
	SquareCap
)

type LineJoin ¶ added in v0.9.0

type LineJoin int

A LineJoin says how two segments of a stroke meet.

const (
	// MiterJoin carries the two outer edges to where they cross, unless that
	// point is further away than the miter limit allows, in which case the
	// join is bevelled instead.
	MiterJoin LineJoin = iota
	// RoundJoin fills the corner with a disc.
	RoundJoin
	// BevelJoin closes the corner with a straight line.
	BevelJoin
)

type LinearGradient ¶ added in v0.3.0

type LinearGradient struct {
	X0, Y0, X1, Y1 float64
	Spread         SpreadMethod
	// contains filtered or unexported fields
}

LinearGradient is a Paint whose colour varies along the axis from (X0, Y0) to (X1, Y1): a point's parameter is its projection onto that axis, 0 at the start and 1 at the end, extended past the ends by the Spread method.

func NewLinearGradient(x0, y0, x1, y1 float64, spread SpreadMethod, stops ...Stop) *LinearGradient

func (g *LinearGradient) ColorAt(x, y float64) color.RGBA

type Paint ¶ added in v0.3.0

type Paint interface {
	// ColorAt returns the straight-alpha colour at surface point (x, y).
	ColorAt(x, y float64) color.RGBA
}

A Paint is a per-pixel colour source: given a point in surface coordinates it returns the straight-alpha colour to lay down there. Composite pushes a Paint through a coverage grid onto a pixel buffer, so the rasterizer stays colour-agnostic while gradients and solid fills plug in as Paints.

type Path ¶

type Path struct {
	// contains filtered or unexported fields
}

Path is a mutable 2-D outline: a sequence of sub-paths built from move / line / quadratic / cubic / close commands. A Path carries no colour or width — it is handed to a Rasterizer's Fill / Stroke together with a clamp box. The builder methods return the receiver so calls chain:

pth := vector.NewPath().MoveTo(0, 0).LineTo(10, 0).LineTo(5, 8).Close()

Coordinates are float64 pixel units. Curves are flattened to line segments by an error tolerance at fill/stroke time, so a consumer never deals with beziers directly.

func NewPath() *Path

func (p *Path) Close() *Path

func (p *Path) CubicTo(cx1, cy1, cx2, cy2, x, y float64) *Path

func (p *Path) LineTo(x, y float64) *Path

func (p *Path) MoveTo(x, y float64) *Path

func (p *Path) QuadTo(cx, cy, x, y float64) *Path

type RadialGradient ¶ added in v0.3.0

type RadialGradient struct {
	CX, CY, R float64
	Spread    SpreadMethod
	// contains filtered or unexported fields
}

RadialGradient is a Paint whose colour varies with distance from the centre (CX, CY): a point's parameter is its distance divided by radius R, 0 at the centre and 1 on the circle, extended past the edge by the Spread method.

func NewRadialGradient(cx, cy, r float64, spread SpreadMethod, stops ...Stop) *RadialGradient

func (g *RadialGradient) ColorAt(x, y float64) color.RGBA

type Rasterizer ¶

type Rasterizer struct {
	// contains filtered or unexported fields
}

Rasterizer turns paths into per-pixel coverage grids. It owns reusable scratch buffers (the coverage accumulator, a per-stroke-segment temporary, and a scanline crossings list), grown on demand and reused across Fill / Stroke calls so a steady stream of vector draws amortises to ~zero allocation. The scratch carries no state between calls — each use re-zeroes / resets the region it touches — but a returned coverage slice aliases the accumulator, so a caller must consume it before the next Fill / Stroke.

The zero Rasterizer is ready to use; it is not safe for concurrent use.

func (rz *Rasterizer) Fill(pth *Path, rule FillRule, clampW, clampH int) (cov []float64, ox, oy, w, h int, ok bool)

func (rz *Rasterizer) Stroke(pth *Path, width float64, clampW, clampH int) (cov []float64, ox, oy, w, h int, ok bool)

func (rz *Rasterizer) StrokeWith(pth *Path, style StrokeStyle, clampW, clampH int) (cov []float64, ox, oy, w, h int, ok bool)

type SolidPaint ¶ added in v0.3.0

type SolidPaint struct{ Color color.RGBA }

SolidPaint is a Paint that returns one flat colour everywhere.

func (s SolidPaint) ColorAt(_, _ float64) color.RGBA

type SpreadMethod ¶ added in v0.3.0

type SpreadMethod int

SpreadMethod decides the colour of points whose gradient parameter falls outside the [0, 1] range spanned by the stops.

const (
	// Pad clamps out-of-range parameters, extending the end stops' colours.
	Pad SpreadMethod = iota
	// Repeat tiles the gradient, wrapping the parameter modulo 1.
	Repeat
	// Reflect mirrors the gradient on every other tile (a triangle wave).
	Reflect
)

type Stop ¶ added in v0.3.0

type Stop struct {
	Offset float64
	Color  color.RGBA
}

Stop is one colour stop of a gradient at parameter Offset (nominally in [0, 1]).

type StrokeStyle ¶ added in v0.9.0

type StrokeStyle struct {
	Width      float64
	Cap        LineCap
	Join       LineJoin
	MiterLimit float64 // zero means the usual ten
	// Dash is the pattern of on and off lengths, beginning with an on length.
	// An odd pattern repeats to become even, so a single length means equal
	// dashes and gaps. An empty pattern draws a solid line.
	Dash      []float64
	DashPhase float64
}

A StrokeStyle is everything about a stroke except where it goes.

The zero value is butt caps and miter joins, which is what PostScript, PDF, SVG and Canvas all start from — set Width to something useful.