gfx

package module
Version: v0.0.0-...-4a6ef15 Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: Sep 5, 2021 License: MIT Imports: 18 Imported by: 2

README

gfx

Build Status Go Report Card GoDoc License MIT

Convenience package for dealing with graphics in my pixel drawing experiments.

⚠️ NO STABILITY GUARANTEES ⚠️

Triangles

Triangles can be drawn to an image using a *gfx.DrawTarget.

gfx-triangles

package main

import "github.com/peterhellberg/gfx"

var p = gfx.PaletteFamicube

func main() {
	n := 50
	m := gfx.NewPaletted(900, 270, p, p.Color(n+7))
	t := gfx.NewDrawTarget(m)

	t.MakeTriangles(&gfx.TrianglesData{
		vx(114, 16, n+1), vx(56, 142, n+2), vx(352, 142, n+3),
		vx(350, 142, n+4), vx(500, 50, n+5), vx(640, 236, n+6),
		vx(640, 70, n+8), vx(820, 160, n+9), vx(670, 236, n+10),
	}).Draw()

	gfx.SavePNG("gfx-example-triangles.png", m)
}

func vx(x, y float64, n int) gfx.Vertex {
	return gfx.Vertex{Position: gfx.V(x, y), Color: p.Color(n)}
}

Polygons

A gfx.Polygon is represented by a list of vectors. There is also gfx.Polyline which is a slice of polygons forming a line.

gfx-example-polygon

package main

import "github.com/peterhellberg/gfx"

var edg32 = gfx.PaletteEDG32

func main() {
	m := gfx.NewNRGBA(gfx.IR(0, 0, 1024, 256))
	p := gfx.Polygon{
		{80, 40},
		{440, 60},
		{700, 200},
		{250, 230},
		{310, 140},
	}

	p.EachPixel(m, func(x, y int) {
		pv := gfx.IV(x, y)
		l := pv.To(p.Rect().Center()).Len()

		gfx.Mix(m, x, y, edg32.Color(int(l/18)%32))
	})

	for n, v := range p {
		c := edg32.Color(n * 4)

		gfx.DrawCircle(m, v, 15, 8, gfx.ColorWithAlpha(c, 96))
		gfx.DrawCircle(m, v, 16, 1, c)
	}

	gfx.SavePNG("gfx-example-polygon.png", m)
}

Blocks

You can draw (isometric) blocks using the gfx.Blocks and gfx.Block types.

gfx-example-blocks

package main

import "github.com/peterhellberg/gfx"

func main() {
	var (
		dst    = gfx.NewPaletted(898, 330, gfx.PaletteGo, gfx.PaletteGo[14])
		rect   = gfx.BoundsToRect(dst.Bounds())
		origin = rect.Center().ScaledXY(gfx.V(1.5, -2.5)).Vec3(0.55)
		blocks gfx.Blocks
	)

	for i, bc := range gfx.BlockColorsGo {
		var (
			f    = float64(i) + 0.5
			v    = f * 11
			pos  = gfx.V3(290+(v*3), 8.5*v, 9*(f+2))
			size = gfx.V3(90, 90, 90)
		)

		blocks.AddNewBlock(pos, size, bc)
	}

	blocks.Draw(dst, origin)

	gfx.SavePNG("gfx-example-blocks.png", dst)
}

Signed Distance Functions

The gfx.SignedDistance type allows you to use basic signed distance functions (and operations) to produce some interesting graphics.

gfx-example-sdf

package main

import "github.com/peterhellberg/gfx"

func main() {
	c := gfx.PaletteEDG36.Color
	m := gfx.NewImage(1024, 256, c(5))

	gfx.EachPixel(m.Bounds(), func(x, y int) {
		sd := gfx.SignedDistance{gfx.IV(x, y)}

		if d := sd.OpRepeat(gfx.V(128, 128), func(sd gfx.SignedDistance) float64 {
			return sd.OpSubtraction(sd.Circle(50), sd.Line(gfx.V(0, 0), gfx.V(64, 64)))
		}); d < 40 {
			m.Set(x, y, c(int(gfx.MathAbs(d/5))))
		}
	})

	gfx.SavePNG("gfx-example-sdf.png", m)
}

Domain Coloring

You can use the CmplxPhaseAt method on a gfx.Palette to do domain coloring.

gfx-example-domain-coloring

package main

import "github.com/peterhellberg/gfx"

const (
	w, h        = 1800, 540
	fovY        = 1.9
	aspectRatio = float64(w) / float64(h)
	centerReal  = 0
	centerImag  = 0
	ahc         = aspectRatio*fovY/2.0 + centerReal
	hfc         = fovY/2.0 + centerImag
)

func pixelCoordinates(px, py int) gfx.Vec {
	return gfx.V(
		((float64(px)/(w-1))*2-1)*ahc,
		((float64(h-py-1)/(h-1))*2-1)*hfc,
	)
}

func main() {
	var (
		p  = gfx.PaletteEN4
		p0 = pixelCoordinates(0, 0)
		p1 = pixelCoordinates(w-1, h-1)
		y  = p0.Y
		d  = gfx.V((p1.X-p0.X)/(w-1), (p1.Y-p0.Y)/(h-1))
		m  = gfx.NewImage(w, h)
	)

	for py := 0; py < h; py++ {
		x := p0.X

		for px := 0; px < w; px++ {
			cc := p.CmplxPhaseAt(gfx.CmplxCos(gfx.CmplxSin(0.42 / complex(y*x, x*x))))

			m.Set(px, py, cc)

			x += d.X
		}

		y += d.Y
	}

	gfx.SavePNG("gfx-example-domain-coloring.png", m)
}

Animation

There is rudimentary support for making animations using gfx.Animation, the animations can then be encoded into GIF.

gfx-example-animation

package main

import "github.com/peterhellberg/gfx"

func main() {
	a := &gfx.Animation{}
	p := gfx.PaletteEDG36

	var fireflower = []uint8{
		0, 1, 1, 1, 1, 1, 1, 0,
		1, 1, 2, 2, 2, 2, 1, 1,
		1, 2, 3, 3, 3, 3, 2, 1,
		1, 1, 2, 2, 2, 2, 1, 1,
		0, 1, 1, 1, 1, 1, 1, 0,
		0, 0, 0, 4, 4, 0, 0, 0,
		0, 0, 0, 4, 4, 0, 0, 0,
		4, 4, 0, 4, 4, 0, 4, 4,
		0, 4, 0, 4, 4, 0, 4, 0,
		0, 4, 4, 4, 4, 4, 4, 0,
		0, 0, 4, 4, 4, 4, 0, 0,
	}

	for i := 0; i < len(p)-4; i++ {
		t := gfx.NewTile(p[i:i+4], 8, fireflower)

		a.AddPalettedImage(gfx.NewScaledPalettedImage(t, 20))
	}

	a.SaveGIF("gfx-example-animation.gif")
}

Line drawing

DrawInt functions

Drawing functions based on TinyDraw, which in turn is based on the Adafruit GFX library.

gfx-example-draw-int

package main

import "github.com/peterhellberg/gfx"

func main() {
	m := gfx.NewImage(160, 128, gfx.ColorTransparent)

	p := gfx.PaletteNight16

	gfx.DrawIntLine(m, 10, 10, 94, 10, p.Color(0))
	gfx.DrawIntLine(m, 94, 16, 10, 16, p.Color(1))
	gfx.DrawIntLine(m, 10, 20, 10, 118, p.Color(2))
	gfx.DrawIntLine(m, 16, 118, 16, 20, p.Color(4))

	gfx.DrawIntLine(m, 40, 40, 80, 80, p.Color(5))
	gfx.DrawIntLine(m, 40, 40, 80, 70, p.Color(6))
	gfx.DrawIntLine(m, 40, 40, 80, 60, p.Color(7))
	gfx.DrawIntLine(m, 40, 40, 80, 50, p.Color(8))
	gfx.DrawIntLine(m, 40, 40, 80, 40, p.Color(9))

	gfx.DrawIntLine(m, 100, 100, 40, 100, p.Color(10))
	gfx.DrawIntLine(m, 100, 100, 40, 90, p.Color(11))
	gfx.DrawIntLine(m, 100, 100, 40, 80, p.Color(12))
	gfx.DrawIntLine(m, 100, 100, 40, 70, p.Color(13))
	gfx.DrawIntLine(m, 100, 100, 40, 60, p.Color(14))
	gfx.DrawIntLine(m, 100, 100, 40, 50, p.Color(15))

	gfx.DrawIntRectangle(m, 30, 106, 120, 20, p.Color(14))
	gfx.DrawIntFilledRectangle(m, 34, 110, 112, 12, p.Color(8))

	gfx.DrawIntCircle(m, 120, 30, 20, p.Color(5))
	gfx.DrawIntFilledCircle(m, 120, 30, 16, p.Color(4))

	gfx.DrawIntTriangle(m, 120, 102, 100, 80, 152, 46, p.Color(9))
	gfx.DrawIntFilledTriangle(m, 119, 98, 105, 80, 144, 54, p.Color(6))

	s := gfx.NewScaledImage(m, 6)

	gfx.SavePNG("gfx-example-draw-int.png", s)
}
Bresenham's line algorithm

gfx.DrawLineBresenham draws a line using Bresenham's line algorithm.

gfx-example-bresenham-line

package main

import "github.com/peterhellberg/gfx"

var (
	red   = gfx.BlockColorRed.Medium
	green = gfx.BlockColorGreen.Medium
	blue  = gfx.BlockColorBlue.Medium
)

func main() {
	m := gfx.NewImage(32, 16, gfx.ColorTransparent)

	gfx.DrawLineBresenham(m, gfx.V(2, 2), gfx.V(2, 14), red)
	gfx.DrawLineBresenham(m, gfx.V(6, 2), gfx.V(32, 2), green)
	gfx.DrawLineBresenham(m, gfx.V(6, 6), gfx.V(30, 14), blue)

	s := gfx.NewScaledImage(m, 16)

	gfx.SavePNG("gfx-example-bresenham-line.png", s)
}

Geometry and Transformation

The (2D) geometry and transformation types are based on those found in https://github.com/faiface/pixel (but indended for use without Pixel)

2D types
Vec

gfx.Vec is a 2D vector type with X and Y components.

Rect

gfx.Rect is a 2D rectangle aligned with the axes of the coordinate system. It is defined by two gfx.Vec, Min and Max.

Matrix

gfx.Matrix is a 2x3 affine matrix that can be used for all kinds of spatial transforms, such as movement, scaling and rotations.

gfx-readme-examples-matrix

package main

import "github.com/peterhellberg/gfx"

var en4 = gfx.PaletteEN4

func main() {
	a := &gfx.Animation{Delay: 10}

	c := gfx.V(128, 128)

	p := gfx.Polygon{
		{50, 50},
		{50, 206},
		{128, 96},
		{206, 206},
		{206, 50},
	}

	for d := 0.0; d < 360; d += 2 {
		m := gfx.NewPaletted(256, 256, en4, en4.Color(3))

		matrix := gfx.IM.RotatedDegrees(c, d)

		gfx.DrawPolygon(m, p.Project(matrix), 0, en4.Color(2))
		gfx.DrawPolygon(m, p.Project(matrix.Scaled(c, 0.5)), 0, en4.Color(1))

		gfx.DrawCircleFilled(m, c, 5, en4.Color(0))

		a.AddPalettedImage(m)
	}

	a.SaveGIF("/tmp/gfx-readme-examples-matrix.gif")
}
3D types
Vec3

gfx.Vec3 is a 3D vector type with X, Y and Z components.

Box

gfx.Box is a 3D box. It is defined by two gfx.Vec3, Min and Max

Errors

The gfx.Error type is a string that implements the error interface.

If you are using Ebiten then you can return the provided gfx.ErrDone error to exit its run loop.

HTTP

You can use gfx.GetPNG to download and decode a PNG given an URL.

Log

I find that it is fairly common for me to do some logging driven development when experimenting with graphical effects, so I've included gfx.Log, gfx.Dump, gfx.Printf and gfx.Sprintf in this package.

Math

I have included a few functions that call functions in the math package.

There is also gfx.Sign, gfx.Clamp and gfx.Lerp functions for float64.

Cmplx

I have included a few functions that call functions in the cmplx package.

Reading files

It is fairly common to read files in my experiments, so I've included gfx.ReadFile and gfx.ReadJSON in this package.

Resizing images

You can use gfx.ResizeImage to resize an image. (nearest neighbor, mainly useful for pixelated graphics)

Noise

Different types of noise is often used in procedural generation.

SimplexNoise

SimplexNoise is a speed-improved simplex noise algorithm for 2D, 3D and 4D.

gfx-example-simplex

package main

import "github.com/peterhellberg/gfx"

func main() {
	sn := gfx.NewSimplexNoise(17)

	dst := gfx.NewImage(1024, 256)

	gfx.EachImageVec(dst, gfx.ZV, func(u gfx.Vec) {
		n := sn.Noise2D(u.X/900, u.Y/900)
		c := gfx.PaletteSplendor128.At(n / 2)

		gfx.SetVec(dst, u, c)
	})

	gfx.SavePNG("gfx-example-simplex.png", dst)
}

Colors

You can construct new colors using gfx.ColorRGBA, gfx.ColorNRGBA, gfx.ColorGray, gfx.ColorGray16 and gfx.ColorWithAlpha.

There is also a gfx.LerpColors function that performs linear interpolation between two colors.

Default colors

There are a few default colors in this package, convenient when you just want to experiment, for more ambitious projects I suggest creating a gfx.Palette (or even use one of the included palettes).

Variable Color
gfx.ColorBlack gfx.ColorBlack
gfx.ColorWhite gfx.ColorWhite
gfx.ColorTransparent gfx.ColorTransparent
gfx.ColorOpaque gfx.ColorOpaque
gfx.ColorRed gfx.ColorRed
gfx.ColorGreen gfx.ColorGreen
gfx.ColorBlue gfx.ColorBlue
gfx.ColorCyan gfx.ColorCyan
gfx.ColorMagenta gfx.ColorMagenta
gfx.ColorYellow gfx.ColorYellow
Block colors

Each gfx.BlockColor consists of a Dark, Medium and Light shade of the same color.

Variable Block Color
gfx.BlockColorYellow gfx.BlockColorYellow
gfx.BlockColorOrange gfx.BlockColorOrange
gfx.BlockColorBrown gfx.BlockColorBrown
gfx.BlockColorGreen gfx.BlockColorGreen
gfx.BlockColorBlue gfx.BlockColorBlue
gfx.BlockColorPurple gfx.BlockColorPurple
gfx.BlockColorRed gfx.BlockColorRed
gfx.BlockColorWhite gfx.BlockColorWhite
gfx.BlockColorBlack gfx.BlockColorBlack
gfx.BlockColorGoGopherBlue gfx.BlockColorGoGopherBlue
gfx.BlockColorGoLightBlue gfx.BlockColorGoLightBlue
gfx.BlockColorGoAqua gfx.BlockColorGoAqua
gfx.BlockColorGoFuchsia gfx.BlockColorGoFuchsia
gfx.BlockColorGoBlack gfx.BlockColorGoBlack
gfx.BlockColorGoYellow gfx.BlockColorGoYellow
Palettes

There are a number of palettes in the gfx package, most of them are found in the Lospec Palette List.

Variable Colors Lospec Palette
gfx.Palette1Bit 2 Palette1Bit
gfx.Palette2BitGrayScale 4 Palette2BitGrayScale
gfx.PaletteEN4 4 PaletteEN4
gfx.PaletteARQ4 4 PaletteARQ4
gfx.PaletteInk 5 PaletteInk
gfx.Palette3Bit 8 Palette3Bit
gfx.PaletteEDG8 8 PaletteEDG8
gfx.PaletteAmmo8 8 PaletteAmmo8
gfx.PaletteNYX8 8 PaletteNYX8
gfx.Palette15PDX 15 Palette15PDX
gfx.PaletteCGA 16 PaletteCGA
gfx.PalettePICO8 16 PalettePICO8
gfx.PaletteNight16 16 PaletteNight16
gfx.PaletteAAP16 16 PaletteAAP16
gfx.PaletteArne16 16 PaletteArne16
gfx.PaletteEDG16 16 PaletteEDG16
gfx.Palette20PDX 20 Palette20PDX
gfx.PaletteTango 27 PaletteTango
gfx.PaletteEDG32 32 PaletteEDG32
gfx.PaletteEDG36 36 PaletteEDG36
gfx.PaletteEDG64 64 PaletteEDG64
gfx.PaletteAAP64 64 PaletteAAP64
gfx.PaletteFamicube 64 PaletteFamicube
gfx.PaletteSplendor128 128 PaletteSplendor128

The palette images were generated like this:

package main

import "github.com/peterhellberg/gfx"

func main() {
	for size, paletteLookup := range gfx.PalettesByNumberOfColors {
		for name, palette := range paletteLookup {
			dst := gfx.NewImage(size, 1)

			for x, c := range palette {
				dst.Set(x, 0, c)
			}

			filename := gfx.Sprintf("gfx-Palette%s.png", name)

			gfx.SavePNG(filename, gfx.NewResizedImage(dst, 1120, 96))
		}
	}
}

License (MIT)

Copyright (c) 2019-2021 Peter Hellberg

Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

Documentation

Overview

Package gfx is a convenience package for dealing with graphics in my pixel drawing experiments.

My experiments are often published under https://gist.github.com/peterhellberg

Usage examples and images can be found in the package README https://github.com/peterhellberg/gfx

Index

Examples

Constants

View Source
const (
	Pi = 3.14159265358979323846264338327950288419716939937510582097494459 // https://oeis.org/A000796
)

Mathematical constants.

Variables

View Source
var (
	ColorTransparent = ColorNRGBA(0, 0, 0, 0)
	ColorOpaque      = ColorNRGBA(0xFF, 0xFF, 0xFF, 0xFF)
	ColorBlack       = Palette1Bit.Color(0)
	ColorWhite       = Palette1Bit.Color(1)
	ColorRed         = Palette3Bit.Color(1)
	ColorGreen       = Palette3Bit.Color(2)
	ColorBlue        = Palette3Bit.Color(3)
	ColorCyan        = Palette3Bit.Color(4)
	ColorMagenta     = Palette3Bit.Color(5)
	ColorYellow      = Palette3Bit.Color(6)

	// ColorByName is a map of all the default colors by name.
	ColorByName = map[string]color.NRGBA{
		"Transparent": ColorTransparent,
		"Opaque":      ColorOpaque,
		"Black":       ColorBlack,
		"White":       ColorWhite,
		"Red":         ColorRed,
		"Green":       ColorGreen,
		"Blue":        ColorBlue,
		"Cyan":        ColorCyan,
		"Magenta":     ColorMagenta,
		"Yellow":      ColorYellow,
	}
)

Standard colors transparent, opaque, black, white, red, green, blue, cyan, magenta, and yellow.

View Source
var (
	// Default block colors based on PaletteTango.
	BlockColorYellow = BlockColor{Light: PaletteTango[0], Medium: PaletteTango[1], Dark: PaletteTango[2]}
	BlockColorOrange = BlockColor{Light: PaletteTango[3], Medium: PaletteTango[4], Dark: PaletteTango[5]}
	BlockColorBrown  = BlockColor{Light: PaletteTango[6], Medium: PaletteTango[7], Dark: PaletteTango[8]}
	BlockColorGreen  = BlockColor{Light: PaletteTango[9], Medium: PaletteTango[10], Dark: PaletteTango[11]}
	BlockColorBlue   = BlockColor{Light: PaletteTango[12], Medium: PaletteTango[13], Dark: PaletteTango[14]}
	BlockColorPurple = BlockColor{Light: PaletteTango[15], Medium: PaletteTango[16], Dark: PaletteTango[17]}
	BlockColorRed    = BlockColor{Light: PaletteTango[18], Medium: PaletteTango[19], Dark: PaletteTango[20]}
	BlockColorWhite  = BlockColor{Light: PaletteTango[21], Medium: PaletteTango[22], Dark: PaletteTango[23]}
	BlockColorBlack  = BlockColor{Light: PaletteTango[24], Medium: PaletteTango[25], Dark: PaletteTango[26]}

	// BlockColors is a slice of the default block colors.
	BlockColors = []BlockColor{
		BlockColorYellow,
		BlockColorOrange,
		BlockColorBrown,
		BlockColorGreen,
		BlockColorBlue,
		BlockColorPurple,
		BlockColorRed,
		BlockColorWhite,
		BlockColorBlack,
	}

	// Block colors based on the Go color palette.
	BlockColorGoGopherBlue = BlockColor{Dark: PaletteGo[0], Medium: PaletteGo[2], Light: PaletteGo[4]}
	BlockColorGoLightBlue  = BlockColor{Dark: PaletteGo[9], Medium: PaletteGo[11], Light: PaletteGo[13]}
	BlockColorGoAqua       = BlockColor{Dark: PaletteGo[18], Medium: PaletteGo[20], Light: PaletteGo[22]}
	BlockColorGoFuchsia    = BlockColor{Dark: PaletteGo[27], Medium: PaletteGo[29], Light: PaletteGo[31]}
	BlockColorGoBlack      = BlockColor{Dark: PaletteGo[36], Medium: PaletteGo[38], Light: PaletteGo[40]}
	BlockColorGoYellow     = BlockColor{Dark: PaletteGo[45], Medium: PaletteGo[47], Light: PaletteGo[49]}

	// BlockColorsGo is a slice of block colors based on the Go color palette.
	BlockColorsGo = []BlockColor{
		BlockColorGoGopherBlue,
		BlockColorGoLightBlue,
		BlockColorGoAqua,
		BlockColorGoFuchsia,
		BlockColorGoBlack,
		BlockColorGoYellow,
	}

	// BlockColorByName is a map of block colors by name.
	BlockColorByName = map[string]BlockColor{

		"Yellow": BlockColorYellow,
		"Orange": BlockColorOrange,
		"Brown":  BlockColorBrown,
		"Green":  BlockColorGreen,
		"Blue":   BlockColorBlue,
		"Purple": BlockColorPurple,
		"Red":    BlockColorRed,
		"White":  BlockColorWhite,
		"Black":  BlockColorBlack,

		"GoGopherBlue": BlockColorGoGopherBlue,
		"GoLightBlue":  BlockColorGoLightBlue,
		"GoAqua":       BlockColorGoAqua,
		"GoFuchsia":    BlockColorGoFuchsia,
		"GoBlack":      BlockColorGoBlack,
		"GoYellow":     BlockColorGoYellow,
	}
)

Block colors, each containing a Light, Medium and Dark color.

View Source
var (
	Stdout = os.Stdout
	Stderr = os.Stderr
)

Stdout, and Stderr are open Files pointing to the standard output, and standard error file descriptors.

View Source
var (
	// XYZReference2 for CIE 1931 2° Standard Observer
	XYZReference2 = XYZReference{
		A:   XYZ{109.850, 100.000, 35.585},
		B:   XYZ{99.0927, 100.000, 85.313},
		C:   XYZ{98.074, 100.000, 118.232},
		D50: XYZ{96.422, 100.000, 82.521},
		D55: XYZ{95.682, 100.000, 92.149},
		D65: XYZ{95.047, 100.000, 108.883},
		D75: XYZ{94.972, 100.000, 122.638},
		E:   XYZ{100.000, 100.000, 100.000},
		F1:  XYZ{92.834, 100.000, 103.665},
		F2:  XYZ{99.187, 100.000, 67.395},
		F3:  XYZ{103.754, 100.000, 49.861},
		F4:  XYZ{109.147, 100.000, 38.813},
		F5:  XYZ{90.872, 100.000, 98.723},
		F6:  XYZ{97.309, 100.000, 60.191},
		F7:  XYZ{95.044, 100.000, 108.755},
		F8:  XYZ{96.413, 100.000, 82.333},
		F9:  XYZ{100.365, 100.000, 67.868},
		F10: XYZ{96.174, 100.000, 81.712},
		F11: XYZ{100.966, 100.000, 64.370},
		F12: XYZ{108.046, 100.000, 39.228},
	}

	// XYZReference10 for CIE 1964 10° Standard Observer
	XYZReference10 = XYZReference{
		A:   XYZ{111.144, 100.000, 35.200},
		B:   XYZ{99.178, 100.000, 84.3493},
		C:   XYZ{97.285, 100.000, 116.145},
		D50: XYZ{96.720, 100.000, 81.427},
		D55: XYZ{95.799, 100.000, 90.926},
		D65: XYZ{94.811, 100.000, 107.304},
		D75: XYZ{94.416, 100.000, 120.641},
		E:   XYZ{100.000, 100.000, 100.000},
		F1:  XYZ{94.791, 100.000, 103.191},
		F2:  XYZ{103.280, 100.000, 69.026},
		F3:  XYZ{108.968, 100.000, 51.965},
		F4:  XYZ{114.961, 100.000, 40.963},
		F5:  XYZ{93.369, 100.000, 98.636},
		F6:  XYZ{102.148, 100.000, 62.074},
		F7:  XYZ{95.792, 100.000, 107.687},
		F8:  XYZ{97.115, 100.000, 81.135},
		F9:  XYZ{102.116, 100.000, 67.826},
		F10: XYZ{99.001, 100.000, 83.134},
		F11: XYZ{103.866, 100.000, 65.627},
		F12: XYZ{111.428, 100.000, 40.353},
	}
)
View Source
var DefaultAnimationDelay = 50

DefaultAnimationDelay is the default animation delay, in 100ths of a second.

View Source
var ErrDone = Error("done")

ErrDone can for example be returned when you are done rendering.

View Source
var HTTPClient = HTTP{
	Client: &http.Client{
		Timeout: 30 * time.Second,
	},
	UserAgent: "gfx.HTTPClient",
}

HTTPClient is the default client used by Get/GetPNG/GetTileset, etc.

View Source
var IM = Matrix{1, 0, 0, 1, 0, 0}

IM stands for identity matrix. Does nothing, no transformation.

View Source
var Palette15PDX = Palette{
	{0x6E, 0x32, 0x32, 0xFF},
	{0xBB, 0x57, 0x35, 0xFF},
	{0xDF, 0x92, 0x45, 0xFF},
	{0xEC, 0xD2, 0x74, 0xFF},
	{0x83, 0xA8, 0x16, 0xFF},
	{0x27, 0x72, 0x24, 0xFF},
	{0x17, 0x3B, 0x47, 0xFF},
	{0x04, 0x68, 0x94, 0xFF},
	{0x17, 0xA1, 0xA9, 0xFF},
	{0x81, 0xDB, 0xCD, 0xFF},
	{0xFD, 0xF9, 0xF1, 0xFF},
	{0xC7, 0xB2, 0x95, 0xFF},
	{0x87, 0x71, 0x5B, 0xFF},
	{0x46, 0x3F, 0x3C, 0xFF},
	{0x20, 0x17, 0x08, 0xFF},
}

Palette15PDX is the 15P DX palette.

Palette created by GrafxKid.

https://lospec.com/palette-list/15p-dx

View Source
var Palette1Bit = Palette{
	{0x00, 0x00, 0x00, 0xFF},
	{0xFF, 0xFF, 0xFF, 0xFF},
}

Palette1Bit is a basic 1-bit (black and white) palette.

View Source
var Palette20PDX = Palette{
	{0x17, 0x0D, 0x20, 0xFF},
	{0x47, 0x47, 0x57, 0xFF},
	{0x78, 0x78, 0x76, 0xFF},
	{0xB1, 0xB9, 0xA6, 0xFF},
	{0xEB, 0xFF, 0xDA, 0xFF},
	{0x68, 0x29, 0x3E, 0xFF},
	{0xA9, 0x44, 0x00, 0xFF},
	{0xD9, 0x7E, 0x00, 0xFF},
	{0xEB, 0xD0, 0x00, 0xFF},
	{0x52, 0x3C, 0x14, 0xFF},
	{0x81, 0x60, 0x31, 0xFF},
	{0xBC, 0x8B, 0x57, 0xFF},
	{0xEB, 0xCD, 0x93, 0xFF},
	{0x0E, 0x4C, 0x58, 0xFF},
	{0x04, 0x6E, 0x92, 0xFF},
	{0x01, 0xA3, 0xC3, 0xFF},
	{0x55, 0xDE, 0xB7, 0xFF},
	{0x17, 0x79, 0x47, 0xFF},
	{0x5A, 0xB2, 0x17, 0xFF},
	{0xB1, 0xE3, 0x29, 0xFF},
}

Palette20PDX is the 20P DX palette.

Palette created by GrafxKid.

https://lospec.com/palette-list/20p-dx

View Source
var Palette2BitGrayScale = Palette{
	{0x00, 0x00, 0x00, 0xFF},
	{0x67, 0x67, 0x67, 0xFF},
	{0xB6, 0xB6, 0xB6, 0xFF},
	{0xFF, 0xFF, 0xFF, 0xFF},
}

Palette2BitGrayScale is a grayscale palette calculated using 2-bits per color.

It was used by the original gameboy and a few other computer systems.

https://lospec.com/palette-list/2-bit-grayscale

View Source
var Palette3Bit = Palette{
	{0x00, 0x00, 0x00, 0xFF},
	{0xFF, 0x00, 0x00, 0xFF},
	{0x00, 0xFF, 0x00, 0xFF},
	{0x00, 0x00, 0xFF, 0xFF},
	{0x00, 0xFF, 0xFF, 0xFF},
	{0xFF, 0x00, 0xFF, 0xFF},
	{0xFF, 0xFF, 0x00, 0xFF},
	{0xFF, 0xFF, 0xFF, 0xFF},
}

Palette3Bit is the 3-Bit palette.

A calculated palette using 1 bit for each RGB value. It was used by a number of early computers.

View Source
var PaletteAAP16 = Palette{
	{0x07, 0x07, 0x08, 0xFF},
	{0x33, 0x22, 0x22, 0xFF},
	{0x77, 0x44, 0x33, 0xFF},
	{0xCC, 0x88, 0x55, 0xFF},
	{0x99, 0x33, 0x11, 0xFF},
	{0xDD, 0x77, 0x11, 0xFF},
	{0xFF, 0xDD, 0x55, 0xFF},
	{0xFF, 0xFF, 0x33, 0xFF},
	{0x55, 0xAA, 0x44, 0xFF},
	{0x11, 0x55, 0x22, 0xFF},
	{0x44, 0xEE, 0xBB, 0xFF},
	{0x33, 0x88, 0xDD, 0xFF},
	{0x55, 0x44, 0xAA, 0xFF},
	{0x55, 0x55, 0x77, 0xFF},
	{0xAA, 0xBB, 0xBB, 0xFF},
	{0xFF, 0xFF, 0xFF, 0xFF},
}

PaletteAAP16 is the AAP-16 palette.

Created by Adigun Polack, meant for beginners.

https://lospec.com/palette-list/aap-16

View Source
var PaletteAAP64 = Palette{
	{0x06, 0x06, 0x08, 0xFF},
	{0x14, 0x10, 0x13, 0xFF},
	{0x3B, 0x17, 0x25, 0xFF},
	{0x73, 0x17, 0x2D, 0xFF},
	{0xB4, 0x20, 0x2A, 0xFF},
	{0xDF, 0x3E, 0x23, 0xFF},
	{0xFA, 0x6A, 0x0A, 0xFF},
	{0xF9, 0xA3, 0x1B, 0xFF},
	{0xFF, 0xD5, 0x41, 0xFF},
	{0xFF, 0xFC, 0x40, 0xFF},
	{0xD6, 0xF2, 0x64, 0xFF},
	{0x9C, 0xDB, 0x43, 0xFF},
	{0x59, 0xC1, 0x35, 0xFF},
	{0x14, 0xA0, 0x2E, 0xFF},
	{0x1A, 0x7A, 0x3E, 0xFF},
	{0x24, 0x52, 0x3B, 0xFF},
	{0x12, 0x20, 0x20, 0xFF},
	{0x14, 0x34, 0x64, 0xFF},
	{0x28, 0x5C, 0xC4, 0xFF},
	{0x24, 0x9F, 0xDE, 0xFF},
	{0x20, 0xD6, 0xC7, 0xFF},
	{0xA6, 0xFC, 0xDB, 0xFF},
	{0xFF, 0xFF, 0xFF, 0xFF},
	{0xFE, 0xF3, 0xC0, 0xFF},
	{0xFA, 0xD6, 0xB8, 0xFF},
	{0xF5, 0xA0, 0x97, 0xFF},
	{0xE8, 0x6A, 0x73, 0xFF},
	{0xBC, 0x4A, 0x9B, 0xFF},
	{0x79, 0x3A, 0x80, 0xFF},
	{0x40, 0x33, 0x53, 0xFF},
	{0x24, 0x22, 0x34, 0xFF},
	{0x22, 0x1C, 0x1A, 0xFF},
	{0x32, 0x2B, 0x28, 0xFF},
	{0x71, 0x41, 0x3B, 0xFF},
	{0xBB, 0x75, 0x47, 0xFF},
	{0xDB, 0xA4, 0x63, 0xFF},
	{0xF4, 0xD2, 0x9C, 0xFF},
	{0xDA, 0xE0, 0xEA, 0xFF},
	{0xB3, 0xB9, 0xD1, 0xFF},
	{0x8B, 0x93, 0xAF, 0xFF},
	{0x6D, 0x75, 0x8D, 0xFF},
	{0x4A, 0x54, 0x62, 0xFF},
	{0x33, 0x39, 0x41, 0xFF},
	{0x42, 0x24, 0x33, 0xFF},
	{0x5B, 0x31, 0x38, 0xFF},
	{0x8E, 0x52, 0x52, 0xFF},
	{0xBA, 0x75, 0x6A, 0xFF},
	{0xE9, 0xB5, 0xA3, 0xFF},
	{0xE3, 0xE6, 0xFF, 0xFF},
	{0xB9, 0xBF, 0xFB, 0xFF},
	{0x84, 0x9B, 0xE4, 0xFF},
	{0x58, 0x8D, 0xBE, 0xFF},
	{0x47, 0x7D, 0x85, 0xFF},
	{0x23, 0x67, 0x4E, 0xFF},
	{0x32, 0x84, 0x64, 0xFF},
	{0x5D, 0xAF, 0x8D, 0xFF},
	{0x92, 0xDC, 0xBA, 0xFF},
	{0xCD, 0xF7, 0xE2, 0xFF},
	{0xE4, 0xD2, 0xAA, 0xFF},
	{0xC7, 0xB0, 0x8B, 0xFF},
	{0xA0, 0x86, 0x62, 0xFF},
	{0x79, 0x67, 0x55, 0xFF},
	{0x5A, 0x4E, 0x44, 0xFF},
	{0x42, 0x39, 0x34, 0xFF},
}

PaletteAAP64 is the AAP-64 palette.

Created by Adigun Polack.

https://lospec.com/palette-list/aap-16

View Source
var PaletteARQ4 = Palette{
	{0xFF, 0xFF, 0xFF, 0xFF},
	{0x67, 0x72, 0xA9, 0xFF},
	{0x3A, 0x32, 0x77, 0xFF},
	{0x00, 0x00, 0x00, 0xFF},
}

PaletteARQ4 is the ARQ4 palette.

Created by Endesga. #ARQ4

https://lospec.com/palette-list/arq4

View Source
var PaletteAmmo8 = Palette{
	{0x04, 0x0C, 0x06, 0xFF},
	{0x11, 0x23, 0x18, 0xFF},
	{0x1E, 0x3A, 0x29, 0xFF},
	{0x30, 0x5D, 0x42, 0xFF},
	{0x4D, 0x80, 0x61, 0xFF},
	{0x89, 0xA2, 0x57, 0xFF},
	{0xBE, 0xDC, 0x7F, 0xFF},
	{0xEE, 0xFF, 0xCC, 0xFF},
}

PaletteAmmo8 is the Ammo-8 palette.

Created by rsvp asap.

https://lospec.com/palette-list/ammo-8

View Source
var PaletteArne16 = Palette{
	{0x00, 0x00, 0x00, 0xFF},
	{0x49, 0x3C, 0x2B, 0xFF},
	{0xBE, 0x26, 0x33, 0xFF},
	{0xE0, 0x6F, 0x8B, 0xFF},
	{0x9D, 0x9D, 0x9D, 0xFF},
	{0xA4, 0x64, 0x22, 0xFF},
	{0xEB, 0x89, 0x31, 0xFF},
	{0xF7, 0xE2, 0x6B, 0xFF},
	{0xFF, 0xFF, 0xFF, 0xFF},
	{0x1B, 0x26, 0x32, 0xFF},
	{0x2F, 0x48, 0x4E, 0xFF},
	{0x44, 0x89, 0x1A, 0xFF},
	{0xA3, 0xCE, 0x27, 0xFF},
	{0x00, 0x57, 0x84, 0xFF},
	{0x31, 0xA2, 0xF2, 0xFF},
	{0xB2, 0xDC, 0xEF, 0xFF},
}

PaletteArne16 is the Arne 16 palette.

Created by Arne.

https://lospec.com/palette-list/arne-16

View Source
var PaletteByName = PaletteLookup{

	"1Bit":          Palette1Bit,
	"2BitGrayScale": Palette2BitGrayScale,
	"3Bit":          Palette3Bit,
	"CGA":           PaletteCGA,

	"15PDX": Palette15PDX,
	"20PDX": Palette20PDX,

	"AAP16":       PaletteAAP16,
	"AAP64":       PaletteAAP64,
	"Splendor128": PaletteSplendor128,

	"Arne16":   PaletteArne16,
	"Famicube": PaletteFamicube,

	"EDG16": PaletteEDG16,
	"EDG32": PaletteEDG32,
	"EDG36": PaletteEDG36,
	"EDG64": PaletteEDG64,
	"EDG8":  PaletteEDG8,
	"EN4":   PaletteEN4,
	"ARQ4":  PaletteARQ4,

	"Ink":     PaletteInk,
	"Ammo8":   PaletteAmmo8,
	"NYX8":    PaletteNYX8,
	"Night16": PaletteNight16,
	"PICO8":   PalettePICO8,

	"Tango": PaletteTango,
	"Go":    PaletteGo,
}

PaletteByName is a map of all palettes by name.

View Source
var PaletteCGA = Palette{
	{0x00, 0x00, 0x00, 0xFF},
	{0x55, 0x55, 0x55, 0xFF},
	{0xAA, 0xAA, 0xAA, 0xFF},
	{0xFF, 0xFF, 0xFF, 0xFF},
	{0x00, 0x00, 0xAA, 0xFF},
	{0x55, 0x55, 0xFF, 0xFF},
	{0x00, 0xAA, 0x00, 0xFF},
	{0x55, 0xFF, 0x55, 0xFF},
	{0x00, 0xAA, 0xAA, 0xFF},
	{0x55, 0xFF, 0xFF, 0xFF},
	{0xAA, 0x00, 0x00, 0xFF},
	{0xFF, 0x55, 0x55, 0xFF},
	{0xAA, 0x00, 0xAA, 0xFF},
	{0xFF, 0x55, 0xFF, 0xFF},
	{0xAA, 0x55, 0x00, 0xFF},
	{0xFF, 0xFF, 0x55, 0xFF},
}

PaletteCGA is the Color Graphics Adapter palette.

CGA was a graphics card released in 1981 for the IBM PC. The standard mode uses one of two 4-color palettes (each with a low-intensity and high-intensity mode), but a hack allows use of all 16. #cga

https://lospec.com/palette-list/color-graphics-adapter

View Source
var PaletteEDG16 = Palette{
	{0xE4, 0xA6, 0x72, 0xFF},
	{0xB8, 0x6F, 0x50, 0xFF},
	{0x74, 0x3F, 0x39, 0xFF},
	{0x3F, 0x28, 0x32, 0xFF},
	{0x9E, 0x28, 0x35, 0xFF},
	{0xE5, 0x3B, 0x44, 0xFF},
	{0xFB, 0x92, 0x2B, 0xFF},
	{0xFF, 0xE7, 0x62, 0xFF},
	{0x63, 0xC6, 0x4D, 0xFF},
	{0x32, 0x73, 0x45, 0xFF},
	{0x19, 0x3D, 0x3F, 0xFF},
	{0x4F, 0x67, 0x81, 0xFF},
	{0xAF, 0xBF, 0xD2, 0xFF},
	{0xFF, 0xFF, 0xFF, 0xFF},
	{0x2C, 0xE8, 0xF4, 0xFF},
	{0x04, 0x84, 0xD1, 0xFF},
}

PaletteEDG16 is the Endesga 16 palette.

Created by Endesga. #EDG16

https://lospec.com/palette-list/endesga-16

View Source
var PaletteEDG32 = Palette{
	{0xBE, 0x4A, 0x2F, 0xFF},
	{0xD7, 0x76, 0x43, 0xFF},
	{0xEA, 0xD4, 0xAA, 0xFF},
	{0xE4, 0xA6, 0x72, 0xFF},
	{0xB8, 0x6F, 0x50, 0xFF},
	{0x73, 0x3E, 0x39, 0xFF},
	{0x3E, 0x27, 0x31, 0xFF},
	{0xA2, 0x26, 0x33, 0xFF},
	{0xE4, 0x3B, 0x44, 0xFF},
	{0xF7, 0x76, 0x22, 0xFF},
	{0xFE, 0xAE, 0x34, 0xFF},
	{0xFE, 0xE7, 0x61, 0xFF},
	{0x63, 0xC7, 0x4D, 0xFF},
	{0x3E, 0x89, 0x48, 0xFF},
	{0x26, 0x5C, 0x42, 0xFF},
	{0x19, 0x3C, 0x3E, 0xFF},
	{0x12, 0x4E, 0x89, 0xFF},
	{0x00, 0x99, 0xDB, 0xFF},
	{0x2C, 0xE8, 0xF5, 0xFF},
	{0xFF, 0xFF, 0xFF, 0xFF},
	{0xC0, 0xCB, 0xDC, 0xFF},
	{0x8B, 0x9B, 0xB4, 0xFF},
	{0x5A, 0x69, 0x88, 0xFF},
	{0x3A, 0x44, 0x66, 0xFF},
	{0x26, 0x2B, 0x44, 0xFF},
	{0x18, 0x14, 0x25, 0xFF},
	{0xFF, 0x00, 0x44, 0xFF},
	{0x68, 0x38, 0x6C, 0xFF},
	{0xB5, 0x50, 0x88, 0xFF},
	{0xF6, 0x75, 0x7A, 0xFF},
	{0xE8, 0xB7, 0x96, 0xFF},
	{0xC2, 0x85, 0x69, 0xFF},
}

PaletteEDG32 is the Endesga 32 palette.

Created by Endesga for his game NYKRA. #EDG32

https://lospec.com/palette-list/endesga-32

View Source
var PaletteEDG36 = Palette{
	{0xDB, 0xE0, 0xE7, 0xFF},
	{0xA3, 0xAC, 0xBE, 0xFF},
	{0x67, 0x70, 0x8B, 0xFF},
	{0x4E, 0x53, 0x71, 0xFF},
	{0x39, 0x3A, 0x56, 0xFF},
	{0x26, 0x24, 0x3A, 0xFF},
	{0x14, 0x10, 0x20, 0xFF},
	{0x7B, 0xCF, 0x5C, 0xFF},
	{0x50, 0x9B, 0x4B, 0xFF},
	{0x2E, 0x6A, 0x42, 0xFF},
	{0x1A, 0x45, 0x3B, 0xFF},
	{0x0F, 0x27, 0x38, 0xFF},
	{0x0D, 0x2F, 0x6D, 0xFF},
	{0x0F, 0x4D, 0xA3, 0xFF},
	{0x0E, 0x82, 0xCE, 0xFF},
	{0x13, 0xB2, 0xF2, 0xFF},
	{0x41, 0xF3, 0xFC, 0xFF},
	{0xF0, 0xD2, 0xAF, 0xFF},
	{0xE5, 0xAE, 0x78, 0xFF},
	{0xC5, 0x81, 0x58, 0xFF},
	{0x94, 0x55, 0x42, 0xFF},
	{0x62, 0x35, 0x30, 0xFF},
	{0x46, 0x21, 0x1F, 0xFF},
	{0x97, 0x43, 0x2A, 0xFF},
	{0xE5, 0x70, 0x28, 0xFF},
	{0xF7, 0xAC, 0x37, 0xFF},
	{0xFB, 0xDF, 0x6B, 0xFF},
	{0xFE, 0x97, 0x9B, 0xFF},
	{0xED, 0x52, 0x59, 0xFF},
	{0xC4, 0x2C, 0x36, 0xFF},
	{0x78, 0x1F, 0x2C, 0xFF},
	{0x35, 0x14, 0x28, 0xFF},
	{0x4D, 0x23, 0x52, 0xFF},
	{0x7F, 0x3B, 0x86, 0xFF},
	{0xB4, 0x5E, 0xB3, 0xFF},
	{0xE3, 0x8D, 0xD6, 0xFF},
}

PaletteEDG36 is the Endesga 36 palette.

Created by Endesga. #EDG36

https://lospec.com/palette-list/endesga-36

View Source
var PaletteEDG64 = Palette{
	{0xFF, 0x00, 0x40, 0xFF},
	{0x13, 0x13, 0x13, 0xFF},
	{0x1B, 0x1B, 0x1B, 0xFF},
	{0x27, 0x27, 0x27, 0xFF},
	{0x3D, 0x3D, 0x3D, 0xFF},
	{0x5D, 0x5D, 0x5D, 0xFF},
	{0x85, 0x85, 0x85, 0xFF},
	{0xB4, 0xB4, 0xB4, 0xFF},
	{0xFF, 0xFF, 0xFF, 0xFF},
	{0xC7, 0xCF, 0xDD, 0xFF},
	{0x92, 0xA1, 0xB9, 0xFF},
	{0x65, 0x73, 0x92, 0xFF},
	{0x42, 0x4C, 0x6E, 0xFF},
	{0x2A, 0x2F, 0x4E, 0xFF},
	{0x1A, 0x19, 0x32, 0xFF},
	{0x0E, 0x07, 0x1B, 0xFF},
	{0x1C, 0x12, 0x1C, 0xFF},
	{0x39, 0x1F, 0x21, 0xFF},
	{0x5D, 0x2C, 0x28, 0xFF},
	{0x8A, 0x48, 0x36, 0xFF},
	{0xBF, 0x6F, 0x4A, 0xFF},
	{0xE6, 0x9C, 0x69, 0xFF},
	{0xF6, 0xCA, 0x9F, 0xFF},
	{0xF9, 0xE6, 0xCF, 0xFF},
	{0xED, 0xAB, 0x50, 0xFF},
	{0xE0, 0x74, 0x38, 0xFF},
	{0xC6, 0x45, 0x24, 0xFF},
	{0x8E, 0x25, 0x1D, 0xFF},
	{0xFF, 0x50, 0x00, 0xFF},
	{0xED, 0x76, 0x14, 0xFF},
	{0xFF, 0xA2, 0x14, 0xFF},
	{0xFF, 0xC8, 0x25, 0xFF},
	{0xFF, 0xEB, 0x57, 0xFF},
	{0xD3, 0xFC, 0x7E, 0xFF},
	{0x99, 0xE6, 0x5F, 0xFF},
	{0x5A, 0xC5, 0x4F, 0xFF},
	{0x33, 0x98, 0x4B, 0xFF},
	{0x1E, 0x6F, 0x50, 0xFF},
	{0x13, 0x4C, 0x4C, 0xFF},
	{0x0C, 0x2E, 0x44, 0xFF},
	{0x00, 0x39, 0x6D, 0xFF},
	{0x00, 0x69, 0xAA, 0xFF},
	{0x00, 0x98, 0xDC, 0xFF},
	{0x00, 0xCD, 0xF9, 0xFF},
	{0x0C, 0xF1, 0xFF, 0xFF},
	{0x94, 0xFD, 0xFF, 0xFF},
	{0xFD, 0xD2, 0xED, 0xFF},
	{0xF3, 0x89, 0xF5, 0xFF},
	{0xDB, 0x3F, 0xFD, 0xFF},
	{0x7A, 0x09, 0xFA, 0xFF},
	{0x30, 0x03, 0xD9, 0xFF},
	{0x0C, 0x02, 0x93, 0xFF},
	{0x03, 0x19, 0x3F, 0xFF},
	{0x3B, 0x14, 0x43, 0xFF},
	{0x62, 0x24, 0x61, 0xFF},
	{0x93, 0x38, 0x8F, 0xFF},
	{0xCA, 0x52, 0xC9, 0xFF},
	{0xC8, 0x50, 0x86, 0xFF},
	{0xF6, 0x81, 0x87, 0xFF},
	{0xF5, 0x55, 0x5D, 0xFF},
	{0xEA, 0x32, 0x3C, 0xFF},
	{0xC4, 0x24, 0x30, 0xFF},
	{0x89, 0x1E, 0x2B, 0xFF},
	{0x57, 0x1C, 0x27, 0xFF},
}

PaletteEDG64 is the Endesga 64 palette.

"Honed over years of palette creation, refined for materialistic pixelart and design. High contrast, high saturation, shaped around painting the organic and structured life of the heptaverse." Created by Endesga. #EDG64

https://lospec.com/palette-list/endesga-64

View Source
var PaletteEDG8 = Palette{
	{0xFD, 0xFD, 0xF8, 0xFF},
	{0xD3, 0x27, 0x34, 0xFF},
	{0xDA, 0x7D, 0x22, 0xFF},
	{0xE6, 0xDA, 0x29, 0xFF},
	{0x28, 0xC6, 0x41, 0xFF},
	{0x2D, 0x93, 0xDD, 0xFF},
	{0x7B, 0x53, 0xAD, 0xFF},
	{0x1B, 0x1C, 0x33, 0xFF},
}

PaletteEDG8 is the Endesga 8 palette.

Created by Endesga. #EDG8

https://lospec.com/palette-list/endesga-8

View Source
var PaletteEN4 = Palette{
	{0xFB, 0xF7, 0xF3, 0xFF},
	{0xE5, 0xB0, 0x83, 0xFF},
	{0x42, 0x6E, 0x5D, 0xFF},
	{0x20, 0x28, 0x3D, 0xFF},
}

PaletteEN4 is the EN4 palette.

Created by Endesga. #EN4

https://lospec.com/palette-list/en4

View Source
var PaletteFamicube = Palette{
	{0x00, 0x00, 0x00, 0xFF},
	{0x00, 0x17, 0x7D, 0xFF},
	{0x02, 0x4A, 0xCA, 0xFF},
	{0x00, 0x84, 0xFF, 0xFF},
	{0x5B, 0xA8, 0xFF, 0xFF},
	{0x98, 0xDC, 0xFF, 0xFF},
	{0x9B, 0xA0, 0xEF, 0xFF},
	{0x62, 0x64, 0xDC, 0xFF},
	{0x3D, 0x34, 0xA5, 0xFF},
	{0x21, 0x16, 0x40, 0xFF},
	{0x5A, 0x19, 0x91, 0xFF},
	{0x6A, 0x31, 0xCA, 0xFF},
	{0xA6, 0x75, 0xFE, 0xFF},
	{0xE2, 0xC9, 0xFF, 0xFF},
	{0xFE, 0xC9, 0xED, 0xFF},
	{0xD5, 0x9C, 0xFC, 0xFF},
	{0xCC, 0x69, 0xE4, 0xFF},
	{0xA3, 0x28, 0xB3, 0xFF},
	{0x87, 0x16, 0x46, 0xFF},
	{0xCF, 0x3C, 0x71, 0xFF},
	{0xFF, 0x82, 0xCE, 0xFF},
	{0xFF, 0xE9, 0xC5, 0xFF},
	{0xF5, 0xB7, 0x84, 0xFF},
	{0xE1, 0x82, 0x89, 0xFF},
	{0xDA, 0x65, 0x5E, 0xFF},
	{0x82, 0x3C, 0x3D, 0xFF},
	{0x4F, 0x15, 0x07, 0xFF},
	{0xE0, 0x3C, 0x28, 0xFF},
	{0xE2, 0xD7, 0xB5, 0xFF},
	{0xC5, 0x97, 0x82, 0xFF},
	{0xAE, 0x6C, 0x37, 0xFF},
	{0x5C, 0x3C, 0x0D, 0xFF},
	{0x23, 0x17, 0x12, 0xFF},
	{0xAD, 0x4E, 0x1A, 0xFF},
	{0xF6, 0x8F, 0x37, 0xFF},
	{0xFF, 0xE7, 0x37, 0xFF},
	{0xFF, 0xBB, 0x31, 0xFF},
	{0xCC, 0x8F, 0x15, 0xFF},
	{0x93, 0x97, 0x17, 0xFF},
	{0xB6, 0xC1, 0x21, 0xFF},
	{0xEE, 0xFF, 0xA9, 0xFF},
	{0xBE, 0xEB, 0x71, 0xFF},
	{0x8C, 0xD6, 0x12, 0xFF},
	{0x6A, 0xB4, 0x17, 0xFF},
	{0x37, 0x6D, 0x03, 0xFF},
	{0x17, 0x28, 0x08, 0xFF},
	{0x00, 0x4E, 0x00, 0xFF},
	{0x13, 0x9D, 0x08, 0xFF},
	{0x58, 0xD3, 0x32, 0xFF},
	{0x20, 0xB5, 0x62, 0xFF},
	{0x00, 0x60, 0x4B, 0xFF},
	{0x00, 0x52, 0x80, 0xFF},
	{0x0A, 0x98, 0xAC, 0xFF},
	{0x25, 0xE2, 0xCD, 0xFF},
	{0xBD, 0xFF, 0xCA, 0xFF},
	{0x71, 0xA6, 0xA1, 0xFF},
	{0x41, 0x5D, 0x66, 0xFF},
	{0x0D, 0x20, 0x30, 0xFF},
	{0x15, 0x15, 0x15, 0xFF},
	{0x34, 0x34, 0x34, 0xFF},
	{0x7B, 0x7B, 0x7B, 0xFF},
	{0xA8, 0xA8, 0xA8, 0xFF},
	{0xD7, 0xD7, 0xD7, 0xFF},
	{0xFF, 0xFF, 0xFF, 0xFF},
}

PaletteFamicube is the Famicube palette.

Created by Arne as part of his Famicube Project.

https://lospec.com/palette-list/famicube

View Source
var PaletteGo = Palette{
	{0x00, 0xAD, 0xD8, 0xFF},
	{0x0B, 0xB5, 0xDB, 0xFF},
	{0x31, 0xBE, 0xE0, 0xFF},
	{0x4D, 0xC7, 0xE4, 0xFF},
	{0x68, 0xCC, 0xE7, 0xFF},
	{0x82, 0xD2, 0xE8, 0xFF},
	{0x9C, 0xDB, 0xED, 0xFF},
	{0xB5, 0xE3, 0xF0, 0xFF},
	{0xE9, 0xF3, 0xF9, 0xFF},
	{0x5D, 0xC9, 0xE2, 0xFF},
	{0x7D, 0xD1, 0xE6, 0xFF},
	{0x98, 0xD9, 0xEA, 0xFF},
	{0x98, 0xD5, 0xEC, 0xFF},
	{0xC5, 0xE9, 0xF2, 0xFF},
	{0xD5, 0xEE, 0xF5, 0xFF},
	{0xE3, 0xF4, 0xF8, 0xFF},
	{0xEE, 0xF8, 0xFB, 0xFF},
	{0xF7, 0xFC, 0xFD, 0xFF},
	{0x00, 0xA2, 0x9C, 0xFF},
	{0x5B, 0xC4, 0xBA, 0xFF},
	{0x77, 0xCB, 0xC5, 0xFF},
	{0x94, 0xD5, 0xD1, 0xFF},
	{0xAD, 0xDE, 0xDB, 0xFF},
	{0xC4, 0xE7, 0xE4, 0xFF},
	{0xD7, 0xEE, 0xED, 0xFF},
	{0xE8, 0xF5, 0xF4, 0xFF},
	{0xD8, 0xEE, 0xEB, 0xFF},
	{0xCE, 0x32, 0x62, 0xFF},
	{0xD7, 0x5C, 0x7E, 0xFF},
	{0xDE, 0x7B, 0x96, 0xFF},
	{0xE4, 0x97, 0xAD, 0xFF},
	{0xEB, 0xB1, 0xC1, 0xFF},
	{0xF2, 0xC9, 0xD4, 0xFF},
	{0xF6, 0xDC, 0xE3, 0xFF},
	{0xF9, 0xEA, 0xEE, 0xFF},
	{0xF1, 0xD2, 0xD3, 0xFF},
	{0x00, 0x00, 0x00, 0xFF},
	{0x1B, 0x1A, 0x1A, 0xFF},
	{0x2E, 0x2D, 0x2C, 0xFF},
	{0x40, 0x3D, 0x3D, 0xFF},
	{0x53, 0x50, 0x50, 0xFF},
	{0x68, 0x64, 0x64, 0xFF},
	{0x7F, 0x7C, 0x7B, 0xFF},
	{0x9A, 0x97, 0x96, 0xFF},
	{0xB5, 0xB2, 0xB3, 0xFF},
	{0xFD, 0xDD, 0x00, 0xFF},
	{0xFE, 0xE3, 0x3D, 0xFF},
	{0xFF, 0xE9, 0x67, 0xFF},
	{0xFF, 0xED, 0x88, 0xFF},
	{0xFE, 0xF1, 0xA4, 0xFF},
	{0xFE, 0xF5, 0xBE, 0xFF},
	{0xFE, 0xF9, 0xD5, 0xFF},
	{0xFF, 0xFB, 0xE6, 0xFF},
	{0xFF, 0xFE, 0xF3, 0xFF},
	{0x00, 0x75, 0x8D, 0xFF},
	{0x55, 0x57, 0x59, 0xFF},
	{0x40, 0x2B, 0x56, 0xFF},
	{0xDB, 0xD9, 0xD6, 0xFF},
}

PaletteGo is the Go palette.

https://golang.org/s/brandbook

View Source
var PaletteInk = Palette{
	{0x1F, 0x1F, 0x29, 0xFF},
	{0x41, 0x3A, 0x42, 0xFF},
	{0x59, 0x60, 0x70, 0xFF},
	{0x96, 0xA2, 0xB3, 0xFF},
	{0xEA, 0xF0, 0xD8, 0xFF},
}

PaletteInk is the Ink palette.

Created by AprilSundae.

https://lospec.com/palette-list/ink

View Source
var PaletteNYX8 = Palette{
	{0x08, 0x14, 0x1E, 0xFF},
	{0x0F, 0x2A, 0x3F, 0xFF},
	{0x20, 0x39, 0x4F, 0xFF},
	{0xF6, 0xD6, 0xBD, 0xFF},
	{0xC3, 0xA3, 0x8A, 0xFF},
	{0x99, 0x75, 0x77, 0xFF},
	{0x81, 0x62, 0x71, 0xFF},
	{0x4E, 0x49, 0x5F, 0xFF},
}

PaletteNYX8 is the NYX8 palette.

Palette created by Javier Guerrero.

https://lospec.com/palette-list/nyx8

View Source
var PaletteNight16 = Palette{
	{0x0F, 0x0F, 0x1E, 0xFF},
	{0xFF, 0xF8, 0xBC, 0xFF},
	{0x0C, 0x21, 0x33, 0xFF},
	{0x48, 0x58, 0x6D, 0xFF},
	{0x79, 0xA0, 0xB0, 0xFF},
	{0xB0, 0xCE, 0x9D, 0xFF},
	{0x65, 0x7F, 0x49, 0xFF},
	{0x3F, 0x45, 0x36, 0xFF},
	{0xB9, 0x9D, 0x6A, 0xFF},
	{0xFF, 0xDD, 0x91, 0xFF},
	{0xDD, 0x94, 0x5B, 0xFF},
	{0x9A, 0x51, 0x42, 0xFF},
	{0x64, 0x4B, 0x48, 0xFF},
	{0x33, 0x30, 0x33, 0xFF},
	{0x76, 0x70, 0x88, 0xFF},
	{0xC5, 0xA3, 0xB3, 0xFF},
}

PaletteNight16 is the Night 16 palette.

3rd place winner of the PixelJoint 16 color palette competition (2015). Created by Night.

https://lospec.com/palette-list/night-16

View Source
var PalettePICO8 = Palette{
	{0x00, 0x00, 0x00, 0xFF},
	{0x5F, 0x57, 0x4F, 0xFF},
	{0xC2, 0xC3, 0xC7, 0xFF},
	{0xFF, 0xF1, 0xE8, 0xFF},
	{0xFF, 0xEC, 0x27, 0xFF},
	{0xFF, 0xA3, 0x00, 0xFF},
	{0xFF, 0xCC, 0xAA, 0xFF},
	{0xAB, 0x52, 0x36, 0xFF},
	{0xFF, 0x77, 0xA8, 0xFF},
	{0xFF, 0x00, 0x4D, 0xFF},
	{0x83, 0x76, 0x9C, 0xFF},
	{0x7E, 0x25, 0x53, 0xFF},
	{0x29, 0xAD, 0xFF, 0xFF},
	{0x1D, 0x2B, 0x53, 0xFF},
	{0x00, 0x87, 0x51, 0xFF},
	{0x00, 0xE4, 0x36, 0xFF},
}

PalettePICO8 is the palette used by PICO-8.

The PICO-8 is a virtual video game console created by Lexaloffle Games.

https://lospec.com/palette-list/pico-8

View Source
var PaletteSplendor128 = Palette{}/* 128 elements not displayed */

PaletteSplendor128 is the Splendor 128 palette.

Created by Adigun Polack as a successor to his AAP-64 palette. #Splendor128

https://lospec.com/palette-list/aap-splendor128

View Source
var PaletteTango = Palette{
	{0xFC, 0xE9, 0x4F, 0xFF},
	{0xED, 0xD4, 0x00, 0xFF},
	{0xC4, 0xA0, 0x00, 0xFF},
	{0xFC, 0xAF, 0x3E, 0xFF},
	{0xF5, 0x79, 0x00, 0xFF},
	{0xCE, 0x5C, 0x00, 0xFF},
	{0xE9, 0xB9, 0x6E, 0xFF},
	{0xC1, 0x7D, 0x11, 0xFF},
	{0x8F, 0x59, 0x02, 0xFF},
	{0x8A, 0xE2, 0x34, 0xFF},
	{0x73, 0xD2, 0x16, 0xFF},
	{0x4E, 0x9A, 0x06, 0xFF},
	{0x72, 0x9F, 0xCF, 0xFF},
	{0x34, 0x65, 0xA4, 0xFF},
	{0x20, 0x4A, 0x87, 0xFF},
	{0xAD, 0x7F, 0xA8, 0xFF},
	{0x75, 0x50, 0x7B, 0xFF},
	{0x5C, 0x35, 0x66, 0xFF},
	{0xEF, 0x29, 0x29, 0xFF},
	{0xCC, 0x00, 0x00, 0xFF},
	{0xA4, 0x00, 0x00, 0xFF},
	{0xEE, 0xEE, 0xEC, 0xFF},
	{0xD3, 0xD7, 0xCF, 0xFF},
	{0xBA, 0xBD, 0xB6, 0xFF},
	{0x88, 0x8A, 0x85, 0xFF},
	{0x55, 0x57, 0x53, 0xFF},
	{0x2E, 0x34, 0x36, 0xFF},
}

PaletteTango is the Tango palette.

http://en.wikipedia.org/wiki/Tango_Desktop_Project#Palette

View Source
var PalettesByNumberOfColors = func() map[int]PaletteLookup {
	pnc := map[int]PaletteLookup{}

	for n, p := range PaletteByName {
		c := len(p)

		if pnc[c] == nil {
			pnc[c] = PaletteLookup{}
		}

		pnc[c][n] = p
	}

	return pnc
}()

PalettesByNumberOfColors is a map of int to Palettes.

View Source
var ZP = image.ZP

ZP is the zero image.Point.

View Source
var ZR = image.ZR

ZR is the zero image.Rectangle.

View Source
var ZV = Vec{0, 0}

ZV is a zero vector.

View Source
var ZV3 = Vec3{0, 0, 0}

ZV3 is the zero Vec3

Functions

func Base64EncodedPNG

func Base64EncodedPNG(src image.Image) string

Base64EncodedPNG encodes the given image into a string using base64.StdEncoding.

func Base64ImgTag

func Base64ImgTag(src image.Image) string

Base64ImgTag returns a HTML tag for an img with its src set to a base64 encoded PNG.

func Clamp

func Clamp(x, min, max float64) float64

Clamp returns x clamped to the interval [min, max].

If x is less than min, min is returned. If x is more than max, max is returned. Otherwise, x is returned.

Example
Dump(
	Clamp(-5, 10, 10),
	Clamp(15, 10, 15),
	Clamp(25, 10, 20),
)
Output:

10
15
20

func CmplxCos

func CmplxCos(x complex128) complex128

CmplxCos returns the cosine of x.

Example
Log("%f %f %f",
	CmplxCos(complex(1, 2)),
	CmplxCos(complex(2, 3)),
	CmplxCos(complex(4, 5)),
)
Output:

(2.032723-3.051898i) (-4.189626-9.109228i) (-48.506859+56.157175i)

func CmplxCosh

func CmplxCosh(x complex128) complex128

CmplxCosh returns the hyperbolic cosine of x.

Example
Log("%f %f %f",
	CmplxCosh(complex(1, 2)),
	CmplxCosh(complex(2, 3)),
	CmplxCosh(complex(4, 5)),
)
Output:

(-0.642148+1.068607i) (-3.724546+0.511823i) (7.746313-26.168964i)

func CmplxPhase

func CmplxPhase(x complex128) float64

CmplxPhase returns the phase (also called the argument) of x. The returned value is in the range [-Pi, Pi].

Example
Log("%f %f %f",
	CmplxPhase(complex(1, 2)),
	CmplxPhase(complex(2, 3)),
	CmplxPhase(complex(4, 5)),
)
Output:

1.107149 0.982794 0.896055

func CmplxPow

func CmplxPow(x, y complex128) complex128

CmplxPow returns x**y, the base-x exponential of y.

Example
Log("%f %f",
	CmplxPow(complex(1, 2), complex(2, 3)),
	CmplxPow(complex(4, 5), complex(5, 6)),
)
Output:

(-0.015133-0.179867i) (-49.591090+4.323851i)

func CmplxSin

func CmplxSin(x complex128) complex128

CmplxSin returns the sine of x.

Example
Log("%f %f %f",
	CmplxSin(complex(1, 2)),
	CmplxSin(complex(2, 3)),
	CmplxSin(complex(4, 5)),
)
Output:

(3.165779+1.959601i) (9.154499-4.168907i) (-56.162274-48.502455i)

func CmplxSinh

func CmplxSinh(x complex128) complex128

CmplxSinh returns the hyperbolic sine of x.

Example
Log("%f %f %f",
	CmplxSinh(complex(1, 2)),
	CmplxSinh(complex(2, 3)),
	CmplxSinh(complex(4, 5)),
)
Output:

(-0.489056+1.403119i) (-3.590565+0.530921i) (7.741118-26.186527i)

func CmplxSqrt

func CmplxSqrt(x complex128) complex128

CmplxSqrt returns the square root of x. The result r is chosen so that real(r) ≥ 0 and imag(r) has the same sign as imag(x).

Example
Log("%f %f %f",
	CmplxSqrt(complex(1, 2)),
	CmplxSqrt(complex(2, 3)),
	CmplxSqrt(complex(4, 5)),
)
Output:

(1.272020+0.786151i) (1.674149+0.895977i) (2.280693+1.096158i)

func CmplxTan

func CmplxTan(x complex128) complex128

CmplxTan returns the tangent of x.

Example
Log("%f %f %f",
	CmplxTan(complex(1, 2)),
	CmplxTan(complex(2, 3)),
	CmplxTan(complex(4, 5)),
)
Output:

(0.033813+1.014794i) (-0.003764+1.003239i) (0.000090+1.000013i)

func CmplxTanh

func CmplxTanh(x complex128) complex128

CmplxTanh returns the hyperbolic tangent of x.

Example
Log("%f %f %f",
	CmplxTanh(complex(1, 2)),
	CmplxTanh(complex(2, 3)),
	CmplxTanh(complex(4, 5)),
)
Output:

(1.166736-0.243458i) (0.965386-0.009884i) (1.000563-0.000365i)

func ColorGray

func ColorGray(y uint8) color.Gray

ColorGray construcs a color.Gray.

func ColorGray16

func ColorGray16(y uint16) color.Gray16

ColorGray16 construcs a color.Gray16.

func ColorNRGBA

func ColorNRGBA(r, g, b, a uint8) color.NRGBA

ColorNRGBA constructs a color.NRGBA.

func ColorRGBA

func ColorRGBA(r, g, b, a uint8) color.RGBA

ColorRGBA constructs a color.RGBA.

func ColorWithAlpha

func ColorWithAlpha(c color.Color, a uint8) color.NRGBA

ColorWithAlpha creates a new color.RGBA based on the provided color.Color and alpha arguments.

func CreateFile

func CreateFile(fn string) (*os.File, error)

CreateFile creates or truncates the named file.

func DecodeImage

func DecodeImage(r io.Reader) (image.Image, error)

DecodeImage decodes an image from the provided io.Reader.

func DecodeImageBytes

func DecodeImageBytes(b []byte) (image.Image, error)

DecodeImageBytes decodes an image from the provided []byte.

func DecodePNG

func DecodePNG(r io.Reader) (image.Image, error)

DecodePNG decodes a PNG from the provided io.Reader.

func DecodePNGBytes

func DecodePNGBytes(b []byte) (image.Image, error)

DecodePNGBytes decodes a PNG from the provided []byte.

func Draw

func Draw(dst draw.Image, r image.Rectangle, src image.Image)

Draw draws src on dst, at the zero point using draw.Src.

func DrawCicleFast

func DrawCicleFast(dst draw.Image, u Vec, radius float64, c color.Color)

DrawCicleFast draws a (crude) filled circle.

func DrawCircle

func DrawCircle(dst draw.Image, u Vec, radius, thickness float64, c color.Color)

DrawCircle draws a circle with radius and thickness. (filled if thickness == 0)

Example (Annular)
dst := NewPaletted(15, 13, Palette1Bit, ColorWhite)

DrawCircle(dst, V(7, 6), 6, 3, ColorBlack)

for y := 0; y < dst.Bounds().Dy(); y++ {
	for x := 0; x < dst.Bounds().Dx(); x++ {
		if dst.Index(x, y) == 0 {
			Printf("▓▓")
		} else {
			Printf("░░")
		}
	}
	Printf("\n")
}
Output:


░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
░░░░░░░░░░▓▓▓▓▓▓▓▓▓▓░░░░░░░░░░
░░░░░░░░▓▓▓▓▓▓▓▓▓▓▓▓▓▓░░░░░░░░
░░░░░░▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓░░░░░░
░░░░▓▓▓▓▓▓▓▓░░░░░░▓▓▓▓▓▓▓▓░░░░
░░░░▓▓▓▓▓▓░░░░░░░░░░▓▓▓▓▓▓░░░░
░░░░▓▓▓▓▓▓░░░░░░░░░░▓▓▓▓▓▓░░░░
░░░░▓▓▓▓▓▓░░░░░░░░░░▓▓▓▓▓▓░░░░
░░░░▓▓▓▓▓▓▓▓░░░░░░▓▓▓▓▓▓▓▓░░░░
░░░░░░▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓░░░░░░
░░░░░░░░▓▓▓▓▓▓▓▓▓▓▓▓▓▓░░░░░░░░
░░░░░░░░░░▓▓▓▓▓▓▓▓▓▓░░░░░░░░░░
░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
Example (Filled)
dst := NewPaletted(15, 13, Palette1Bit, ColorWhite)

DrawCircle(dst, V(7, 6), 6, 0, ColorBlack)

for y := 0; y < dst.Bounds().Dy(); y++ {
	for x := 0; x < dst.Bounds().Dx(); x++ {
		if dst.Index(x, y) == 0 {
			Printf("▓▓")
		} else {
			Printf("░░")
		}
	}
	Printf("\n")
}
Output:


░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
░░░░░░░░▓▓▓▓▓▓▓▓▓▓▓▓▓▓░░░░░░░░
░░░░░░▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓░░░░░░
░░░░▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓░░░░
░░░░▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓░░░░
░░░░▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓░░░░
░░░░▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓░░░░
░░░░▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓░░░░
░░░░▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓░░░░
░░░░▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓░░░░
░░░░░░▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓░░░░░░
░░░░░░░░▓▓▓▓▓▓▓▓▓▓▓▓▓▓░░░░░░░░
░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░

func DrawCircleFilled

func DrawCircleFilled(dst draw.Image, u Vec, radius float64, c color.Color)

DrawCircleFilled draws a filled circle.

func DrawColor

func DrawColor(dst draw.Image, r image.Rectangle, c color.Color)

DrawColor draws an image.Rectangle of uniform color on dst.

func DrawColorOver

func DrawColorOver(dst draw.Image, r image.Rectangle, c color.Color)

DrawColorOver draws an image.Rectangle of uniform color over dst.

func DrawIntCircle

func DrawIntCircle(dst draw.Image, x0, y0, r int, c color.Color)

DrawIntCircle draws a circle given a point and radius

func DrawIntFilledCircle

func DrawIntFilledCircle(dst draw.Image, x0, y0, r int, c color.Color)

DrawIntFilledCircle draws a filled circle given a point and radius

func DrawIntFilledRectangle

func DrawIntFilledRectangle(dst draw.Image, x, y, w, h int, c color.Color)

DrawIntFilledRectangle draws a filled rectangle given a point, width and height

func DrawIntFilledTriangle

func DrawIntFilledTriangle(dst draw.Image, x0, y0, x1, y1, x2, y2 int, c color.Color)

DrawIntFilledTriangle draws a filled triangle given three points

func DrawIntLine

func DrawIntLine(dst draw.Image, x0, y0, x1, y1 int, c color.Color)

DrawIntLine draws a line between two points

func DrawIntRectangle

func DrawIntRectangle(dst draw.Image, x, y, w, h int, c color.Color)

DrawIntRectangle draws a rectangle given a point, width and height

func DrawIntTriangle

func DrawIntTriangle(dst draw.Image, x0, y0, x1, y1, x2, y2 int, c color.Color)

DrawIntTriangle draws a triangle given three points

func DrawLine

func DrawLine(dst draw.Image, from, to Vec, thickness float64, c color.Color)

DrawLine draws a line of the given color. A thickness of <= 1 is drawn using DrawBresenhamLine.

func DrawLineBresenham

func DrawLineBresenham(dst draw.Image, from, to Vec, c color.Color)

DrawLineBresenham draws a line using Bresenham's line algorithm.

http://en.wikipedia.org/wiki/Bresenham's_line_algorithm

Example
dst := NewPaletted(10, 5, Palette1Bit, ColorWhite)

DrawLineBresenham(dst, V(1, 1), V(8, 3), ColorBlack)

for y := 0; y < dst.Bounds().Dy(); y++ {
	for x := 0; x < dst.Bounds().Dx(); x++ {
		if dst.Index(x, y) == 0 {
			Printf("▓▓")
		} else {
			Printf("░░")
		}
	}
	Printf("\n")
}
Output:


░░░░░░░░░░░░░░░░░░░░
░░▓▓▓▓░░░░░░░░░░░░░░
░░░░░░▓▓▓▓▓▓▓▓░░░░░░
░░░░░░░░░░░░░░▓▓▓▓░░
░░░░░░░░░░░░░░░░░░░░
Example (Steep)
dst := NewPaletted(10, 5, Palette1Bit, ColorWhite)

DrawLineBresenham(dst, V(7, 3), V(6, 1), ColorBlack)

for y := 0; y < dst.Bounds().Dy(); y++ {
	for x := 0; x < dst.Bounds().Dx(); x++ {
		if dst.Index(x, y) == 0 {
			Printf("▓▓")
		} else {
			Printf("░░")
		}
	}
	Printf("\n")
}
Output:


░░░░░░░░░░░░░░░░░░░░
░░░░░░░░░░░░▓▓░░░░░░
░░░░░░░░░░░░▓▓░░░░░░
░░░░░░░░░░░░░░▓▓░░░░
░░░░░░░░░░░░░░░░░░░░

func DrawOver

func DrawOver(dst draw.Image, r image.Rectangle, src image.Image, sp image.Point)

DrawOver draws src over dst.

func DrawPalettedImage

func DrawPalettedImage(dst PalettedDrawImage, r image.Rectangle, src PalettedImage)

DrawPalettedImage draws a PalettedImage over a PalettedDrawImage.

func DrawPalettedLayer

func DrawPalettedLayer(dst *Paletted, r image.Rectangle, src *Layer)

DrawPalettedLayer draws a *Layer over a *Paletted. (slightly faster than using the generic DrawPalettedImage)

func DrawPointCircle

func DrawPointCircle(dst draw.Image, p image.Point, radius, thickness float64, c color.Color)

DrawPointCircle draws a circle at the given point.

func DrawPolygon

func DrawPolygon(dst draw.Image, p Polygon, thickness float64, c color.Color)

DrawPolygon filled or as line polygons if the thickness is >= 1.

func DrawPolyline

func DrawPolyline(dst draw.Image, pl Polyline, thickness float64, c color.Color)

DrawPolyline draws a polyline with the given color and thickness.

func DrawSrc

func DrawSrc(dst draw.Image, r image.Rectangle, src image.Image, sp image.Point)

DrawSrc draws src on dst.

func DrawTriangles

func DrawTriangles(dst draw.Image, triangles []Triangle)

DrawTriangles draws triangles on dst.

func DrawTrianglesOver

func DrawTrianglesOver(dst draw.Image, triangles []Triangle)

DrawTrianglesOver draws triangles over dst.

func DrawTrianglesWireframe

func DrawTrianglesWireframe(dst draw.Image, triangles []Triangle)

DrawTrianglesWireframe draws triangles on dst.

func Dump

func Dump(a ...interface{})

Dump all of the arguments to standard output.

Example
Dump([]string{"foo", "bar"})
Output:

[foo bar]

func EachImageVec

func EachImageVec(src image.Image, dir Vec, fn func(u Vec))

EachImageVec calls the provided function for each Vec in the provided image in the given direction.

gfx.V(1,1) to call the function on each pixel starting from the top left.

func EachPixel

func EachPixel(r image.Rectangle, fn func(x, y int))

EachPixel calls the provided function for each pixel in the provided rectangle.

func EncodeJSON

func EncodeJSON(w io.Writer, v interface{}, options ...func(*json.Encoder)) error

EncodeJSON creates a new JSON encoder and encodes the provided value.

func EncodePNG

func EncodePNG(w io.Writer, src image.Image) error

EncodePNG encodes an image as PNG to the provided io.Writer.

func Errorf

func Errorf(format string, a ...interface{}) error

Errorf constructs a formatted error.

Example
err := Errorf("foo %d and bar %s", 123, "abc")

fmt.Println(err)
Output:

foo 123 and bar abc

func Fatal

func Fatal(v ...interface{})

Fatal prints to os.Stderr, followed by a call to os.Exit(1).

func Get

func Get(rawurl string) (*http.Response, error)

Get performs a HTTP GET request using the DefaultClient.

func GetImage

func GetImage(rawurl string) (image.Image, error)

GetImage retrieves a remote image using DefaultClient

func GetPNG

func GetPNG(rawurl string) (image.Image, error)

GetPNG retrieves a remote PNG using DefaultClient

func IR

func IR(x0, y0, x1, y1 int) image.Rectangle

IR returns an image.Rectangle for the given input.

func IntAbs

func IntAbs(x int) int

IntAbs returns the absolute value of x.

Example
Dump(
	IntAbs(10),
	IntAbs(-5),
)
Output:

10
5

func IntClamp

func IntClamp(x, min, max int) int

IntClamp returns x clamped to the interval [min, max].

If x is less than min, min is returned. If x is more than max, max is returned. Otherwise, x is returned.

func IntMax

func IntMax(x, y int) int

IntMax returns the larger of x or y.

Example
Dump(
	IntMax(1, 2),
	IntMax(2, 1),
	IntMax(-1, -2),
)
Output:

2
2
-1

func IntMin

func IntMin(x, y int) int

IntMin returns the smaller of x or y.

Example
Dump(
	IntMin(1, 2),
	IntMin(2, 1),
	IntMin(-1, -2),
)
Output:

1
1
-2

func JSONIndent

func JSONIndent(prefix, indent string) func(*json.Encoder)

JSONIndent configures the prefix and indent level of a JSON encoder.

func Lerp

func Lerp(a, b, t float64) float64

Lerp does linear interpolation between two values.

Example
Dump(
	Lerp(0, 2, 0.1),
	Lerp(1, 10, 0.5),
	Lerp(2, 4, 0.5),
)
Output:

0.2
5.5
3

func LerpColors

func LerpColors(c0, c1 color.Color, t float64) color.Color

LerpColors performs linear interpolation between two colors.

func Log

func Log(format string, a ...interface{})

Log to standard output.

Example
Log("Foo: %d", 123)
Output:

Foo: 123

func MathAbs

func MathAbs(x float64) float64

MathAbs returns the absolute value of x.

Example
Dump(
	MathAbs(-2),
	MathAbs(-1),
	MathAbs(0),
	MathAbs(1),
	MathAbs(2),
)
Output:

2
1
0
1
2

func MathAtan

func MathAtan(x float64) float64

MathAtan returns the arctangent, in radians, of x.

func MathCeil

func MathCeil(x float64) float64

MathCeil returns the least integer value greater than or equal to x.

Example
Dump(
	MathCeil(0.2),
	MathCeil(1.4),
	MathCeil(2.6),
)
Output:

1
2
3

func MathCos

func MathCos(x float64) float64

MathCos returns the cosine of the radian argument x.

Example
Dump(
	MathCos(1),
	MathCos(2),
	MathCos(3),
)
Output:

0.5403023058681398
-0.4161468365471424
-0.9899924966004454

func MathCosh

func MathCosh(x float64) float64

MathCosh returns the hyperbolic cosine of x.

func MathFloor

func MathFloor(x float64) float64

MathFloor returns the greatest integer value less than or equal to x.

Example
Dump(
	MathFloor(0.2),
	MathFloor(1.4),
	MathFloor(2.6),
)
Output:

0
1
2

func MathHypot

func MathHypot(p, q float64) float64

MathHypot returns Sqrt(p*p + q*q), taking care to avoid unnecessary overflow and underflow.

Example
Dump(
	MathHypot(15, 8),
	MathHypot(5, 12),
	MathHypot(3, 4),
)
Output:

17
13
5

func MathLog

func MathLog(x float64) float64

MathLog returns the natural logarithm of x.

func MathMax

func MathMax(x, y float64) float64

MathMax returns the larger of x or y.

Example
Dump(
	MathMax(-1, 1),
	MathMax(1, 2),
	MathMax(3, 2),
)
Output:

1
2
3

func MathMin

func MathMin(x, y float64) float64

MathMin returns the smaller of x or y.

Example
Dump(
	MathMin(-1, 1),
	MathMin(1, 2),
	MathMin(3, 2),
)
Output:

-1
1
2

func MathPow

func MathPow(x, y float64) float64

MathPow returns x**y, the base-x exponential of y.

func MathRound

func MathRound(x float64) float64

MathRound returns the nearest integer, rounding half away from zero.

func MathSin

func MathSin(x float64) float64

MathSin returns the sine of the radian argument x.

Example
Dump(
	MathSin(1),
	MathSin(2),
	MathSin(3),
)
Output:

0.8414709848078965
0.9092974268256816
0.1411200080598672

func MathSinh

func MathSinh(x float64) float64

MathSinh returns the hyperbolic sine of x.

func MathSqrt

func MathSqrt(x float64) float64

MathSqrt returns the square root of x.

Example
Dump(
	MathSqrt(1),
	MathSqrt(2),
	MathSqrt(3),
)
Output:

1
1.4142135623730951
1.7320508075688772

func MathTan

func MathTan(x float64) float64

MathTan returns the tangent of the radian argument x.

func Mix

func Mix(m draw.Image, x, y int, c color.Color)

Mix the current pixel color at x and y with the given color.

func MixPoint

func MixPoint(dst draw.Image, p image.Point, c color.Color)

MixPoint the current pixel color at the image.Point with the given color.

func MustOpenImage

func MustOpenImage(fn string) image.Image

MustOpenImage decodes an image using the provided file name. Panics on error.

func NewGray

func NewGray(r image.Rectangle) *image.Gray

NewGray returns a new Gray image with the given bounds.

func NewGray16

func NewGray16(r image.Rectangle) *image.Gray16

NewGray16 returns a new Gray16 image with the given bounds. (For example useful for height maps)

func NewImage

func NewImage(w, h int, colors ...color.Color) *image.RGBA

NewImage creates an image of the given size (optionally filled with a color)

func NewJSONEncoder

func NewJSONEncoder(w io.Writer, options ...func(*json.Encoder)) *json.Encoder

NewJSONEncoder creates a new JSON encoder for the given io.Writer.

func NewNRGBA

func NewNRGBA(r image.Rectangle) *image.NRGBA

NewNRGBA returns a new NRGBA image with the given bounds.

func NewRGBA

func NewRGBA(r image.Rectangle) *image.RGBA

NewRGBA returns a new RGBA image with the given bounds.

func NewResizedImage

func NewResizedImage(src image.Image, w, h int) image.Image

NewResizedImage returns a new image with the provided dimensions.

func NewResizedRGBA

func NewResizedRGBA(src image.Image, r image.Rectangle) *image.RGBA

NewResizedRGBA returns a new RGBA image with the provided dimensions.

func NewScaledImage

func NewScaledImage(src image.Image, s float64) image.Image

NewScaledImage returns a new image scaled by the provided scaling factor.

Example
src := NewTile(Palette1Bit, 8, []uint8{
	1, 1, 1, 1, 1, 1, 1, 1,
	1, 0, 0, 0, 0, 0, 0, 1,
	1, 0, 0, 1, 1, 0, 0, 1,
	1, 0, 1, 1, 1, 1, 0, 1,
	1, 0, 0, 0, 0, 0, 0, 1,
	1, 1, 1, 1, 1, 1, 1, 1,
})

dst := NewScaledImage(src, 2.0)

func(images ...image.Image) {
	for _, m := range images {
		for y := 0; y < m.Bounds().Dy(); y++ {
			for x := 0; x < m.Bounds().Dx(); x++ {
				if r, _, _, _ := m.At(x, y).RGBA(); r == 0 {
					Printf("▓▓")
				} else {
					Printf("░░")
				}
			}
			Printf("\n")
		}
		Printf("\n")
	}
}(src, dst)
Output:


░░░░░░░░░░░░░░░░
░░▓▓▓▓▓▓▓▓▓▓▓▓░░
░░▓▓▓▓░░░░▓▓▓▓░░
░░▓▓░░░░░░░░▓▓░░
░░▓▓▓▓▓▓▓▓▓▓▓▓░░
░░░░░░░░░░░░░░░░

░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
░░░░▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓░░░░
░░░░▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓░░░░
░░░░▓▓▓▓▓▓▓▓░░░░░░░░▓▓▓▓▓▓▓▓░░░░
░░░░▓▓▓▓▓▓▓▓░░░░░░░░▓▓▓▓▓▓▓▓░░░░
░░░░▓▓▓▓░░░░░░░░░░░░░░░░▓▓▓▓░░░░
░░░░▓▓▓▓░░░░░░░░░░░░░░░░▓▓▓▓░░░░
░░░░▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓░░░░
░░░░▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓░░░░
░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░

func NewScaledRGBA

func NewScaledRGBA(src image.Image, s float64) *image.RGBA

NewScaledRGBA returns a new RGBA image scaled by the provided scaling factor.

func NewUniform

func NewUniform(c color.Color) *image.Uniform

NewUniform creates a new uniform image of the given color.

func OpenFile

func OpenFile(fn string) (*os.File, error)

OpenFile opens the named file for reading.

func OpenImage

func OpenImage(fn string) (image.Image, error)

OpenImage decodes an image using the provided file name.

func Playground

func Playground(src image.Image)

Playground displays image on The Go Playground using the IMAGE: base64 encoded PNG “hack”

func Printf

func Printf(format string, a ...interface{}) (n int, err error)

Printf formats according to a format specifier and writes to standard output.

Example
Printf("%q %.01f", "foo bar", 1.23)
Output:

"foo bar" 1.2

func Pt

func Pt(x, y int) image.Point

Pt returns an image.Point for the given x and y.

func RandFloat64

func RandFloat64() float64

RandFloat64 returns, as a float64, a pseudo-random number in [0.0,1.0) from the default Source.

func RandIntn

func RandIntn(n int) int

RandIntn returns, as an int, a non-negative pseudo-random number in [0,n) from the default Source. It panics if n <= 0.

func RandSeed

func RandSeed(seed int64)

RandSeed uses the provided seed value to initialize the default Source to a deterministic state. If Seed is not called, the generator behaves as if seeded by Seed(1). Seed values that have the same remainder when divided by 2^31-1 generate the same pseudo-random sequence. RandSeed, unlike the Rand.Seed method, is safe for concurrent use.

func ReadFile

func ReadFile(fn string, rf ReadFunc) error

ReadFile opens a file and calls the given ReadFunc.

func ReadJSON

func ReadJSON(fn string, v interface{}) error

ReadJSON opens and decodes a JSON file.

func ResizeImage

func ResizeImage(dst draw.Image, src image.Image)

ResizeImage using nearest neighbor scaling on dst from src.

func SavePNG

func SavePNG(fn string, src image.Image) error

SavePNG saves an image using the provided file name.

func Set

func Set(dst draw.Image, x, y int, c color.Color)

Set x and y to the given color.

func SetPoint

func SetPoint(dst draw.Image, p image.Point, c color.Color)

SetPoint to the given color.

func SetVec

func SetVec(dst draw.Image, u Vec, c color.Color)

SetVec to the given color.

func Sign

func Sign(x float64) float64

Sign returns -1 for values < 0, 0 for 0, and 1 for values > 0.

Example
Dump(
	Sign(-2),
	Sign(0),
	Sign(2),
)
Output:

-1
0
1

func SortSlice

func SortSlice(slice interface{}, less func(i, j int) bool)

SortSlice sorts the provided slice given the provided less function.

func Sprintf

func Sprintf(format string, a ...interface{}) string

Sprintf formats according to a format specifier and returns the resulting string.

Types

type Animation

type Animation struct {
	Frames   []image.Image   // The successive images.
	Palettes []color.Palette // The successive palettes.

	Delay int // Delay between each of the frames.

	// LoopCount controls the number of times an animation will be
	// restarted during display.
	// A LoopCount of 0 means to loop forever.
	// A LoopCount of -1 means to show each frame only once.
	// Otherwise, the animation is looped LoopCount+1 times.
	LoopCount int
}

Animation represents multiple images.

func (*Animation) AddFrame

func (a *Animation) AddFrame(frame image.Image, palette color.Palette)

AddFrame adds a frame to the animation.

func (*Animation) AddPalettedImage

func (a *Animation) AddPalettedImage(frame PalettedImage)

AddPalettedImage adds a frame and palette to the animation.

func (*Animation) EncodeGIF

func (a *Animation) EncodeGIF(w io.Writer) error

EncodeGIF writes the animation to w in GIF format with the given loop count and delay between frames.

func (*Animation) SaveGIF

func (a *Animation) SaveGIF(fn string) error

SaveGIF saves the animation to a GIF using the provided file name.

type BasicTarget

type BasicTarget interface {
	Target

	// SetMatrix sets a Matrix that every point will be projected by.
	SetMatrix(Matrix)
}

BasicTarget is a Target with additional basic adjustment methods.

type Batch

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

Batch is a Target that allows for efficient drawing of many objects with the same Picture.

To put an object into a Batch, just draw it onto it:

object.Draw(batch)

func NewBatch

func NewBatch(container Triangles, pic Picture) *Batch

NewBatch creates an empty Batch with the specified Picture and container.

The container is where objects get accumulated. Batch will support precisely those Triangles properties, that the supplied container supports. If you retain access to the container and change it, call Dirty to notify Batch about the change.

Note, that if the container does not support TrianglesColor, color masking will not work.

func (*Batch) Clear

func (b *Batch) Clear()

Clear removes all objects from the Batch.

func (*Batch) Dirty

func (b *Batch) Dirty()

Dirty notifies Batch about an external modification of it's container. If you retain access to the Batch's container and change it, call Dirty to notify Batch about the change.

container := &gfx.TrianglesData{}
batch := gfx.NewBatch(container, nil)
container.SetLen(10) // container changed from outside of Batch
batch.Dirty()        // notify Batch about the change

func (*Batch) Draw

func (b *Batch) Draw(t Target)

Draw draws all objects that are currently in the Batch onto another Target.

func (*Batch) MakePicture

func (b *Batch) MakePicture(p Picture) TargetPicture

MakePicture returns a specialized copy of the provided Picture that draws onto this Batch.

func (*Batch) MakeTriangles

func (b *Batch) MakeTriangles(t Triangles) TargetTriangles

MakeTriangles returns a specialized copy of the provided Triangles that draws onto this Batch.

func (*Batch) SetMatrix

func (b *Batch) SetMatrix(m Matrix)

SetMatrix sets a Matrix that every point will be projected by.

type Block

type Block struct {
	Pos   Vec3
	Size  Vec3
	Color BlockColor
}

Block has a position, size and color.

func NewBlock

func NewBlock(pos, size Vec3, ic BlockColor) Block

NewBlock creates a new Block.

func (Block) Behind

func (b Block) Behind(a Block) bool

Behind checks if the box for b is in front of the box for a.

func (Block) Box

func (b Block) Box() Box

Box creates a box for the Block.

func (Block) Corners

func (b Block) Corners(origin Vec3) BlockCorners

Corners returns the screen coordinates for the Block corners.

func (Block) Draw

func (b Block) Draw(dst draw.Image, origin Vec3)

Draw block on dst at origin.

func (Block) DrawBounds

func (b Block) DrawBounds(dst draw.Image, origin Vec3)

DrawBounds for block on dst at origin.

func (Block) DrawOver

func (b Block) DrawOver(dst draw.Image, origin Vec3)

DrawOver draws block over dst at origin.

func (Block) DrawPolygons

func (b Block) DrawPolygons(dst draw.Image, origin Vec3)

DrawPolygons for block on dst at origin.

func (Block) DrawRectangles

func (b Block) DrawRectangles(dst draw.Image, origin Vec3)

DrawRectangles for block on dst at origin.

func (Block) DrawWireframe

func (b Block) DrawWireframe(dst draw.Image, origin Vec3)

DrawWireframe block on dst at origin.

func (Block) Polygons

func (b Block) Polygons(origin Vec3) (shape, top, left, right Polygon)

Polygons returns the shape, top, left and right polygons with coordinates based on origin.

func (Block) Rect

func (b Block) Rect(origin Vec3) Rect

Rect for the block.

func (Block) Shape

func (b Block) Shape(origin Vec3) Polygon

Shape returns the shape Polygon

func (Block) Space

func (b Block) Space() BlockSpace

Space returns the BlockSpace for the Block.

func (Block) Triangles

func (b Block) Triangles(origin Vec3) []Triangle

Triangles for the Block

func (Block) TrianglesData

func (b Block) TrianglesData(origin Vec3) *TrianglesData

TrianglesData creates triangles data for the Block.

type BlockColor

type BlockColor struct {
	Light  color.NRGBA
	Medium color.NRGBA
	Dark   color.NRGBA
}

BlockColor contains a Light, Medium and Dark color.

type BlockCorners

type BlockCorners struct {
	LeftUp    Vec
	LeftDown  Vec
	FrontDown Vec
	RightDown Vec
	RightUp   Vec
	BackUp    Vec
	BackDown  Vec
	FrontUp   Vec
}

BlockCorners contains screen coordinates for all of the corners.

func (BlockCorners) Left

func (bc BlockCorners) Left() Polygon

Left face Polygon.

func (BlockCorners) Rect

func (bc BlockCorners) Rect() Rect

Rect for the Block corners.

func (BlockCorners) Right

func (bc BlockCorners) Right() Polygon

Right face Polygon.

func (BlockCorners) Shape

func (bc BlockCorners) Shape() Polygon

Shape Polygon.

func (BlockCorners) Top

func (bc BlockCorners) Top() Polygon

Top face Polygon.

type BlockSpace

type BlockSpace struct {
	LeftUp    Vec3
	LeftDown  Vec3
	FrontDown Vec3
	RightDown Vec3
	RightUp   Vec3
	BackUp    Vec3
	BackDown  Vec3
	FrontUp   Vec3
}

BlockSpace contains 3D space coordinates for the block corners.

func (BlockSpace) CornerBackDown

func (bs BlockSpace) CornerBackDown(origin Vec3) Vec

CornerBackDown returns the screen coordinate for the BackDown corner.

func (BlockSpace) CornerBackUp

func (bs BlockSpace) CornerBackUp(origin Vec3) Vec

CornerBackUp returns the screen coordinate for the BackUp corner.

func (BlockSpace) CornerFrontDown

func (bs BlockSpace) CornerFrontDown(origin Vec3) Vec

CornerFrontDown returns the screen coordinate for the FrontDown corner.

func (BlockSpace) CornerFrontUp

func (bs BlockSpace) CornerFrontUp(origin Vec3) Vec

CornerFrontUp returns the screen coordinate for the FrontUp corner.

func (BlockSpace) CornerLeftDown

func (bs BlockSpace) CornerLeftDown(origin Vec3) Vec

CornerLeftDown returns the screen coordinate for the LeftDown corner.

func (BlockSpace) CornerLeftUp

func (bs BlockSpace) CornerLeftUp(origin Vec3) Vec

CornerLeftUp returns the screen coordinate for the LeftUp corner.

func (BlockSpace) CornerRightDown

func (bs BlockSpace) CornerRightDown(origin Vec3) Vec

CornerRightDown returns the screen coordinate for the RightDown corner.

func (BlockSpace) CornerRightUp

func (bs BlockSpace) CornerRightUp(origin Vec3) Vec

CornerRightUp returns the screen coordinate for the RightUp corner.

func (BlockSpace) Corners

func (bs BlockSpace) Corners(origin Vec3) BlockCorners

Corners returns the screen coordinates for all of the Block corners.

type Blocks

type Blocks []Block

Blocks is a slice of blocks.

func (*Blocks) Add

func (blocks *Blocks) Add(bs ...Block)

Add appends one or more blocks to the slice of Blocks.

func (*Blocks) AddNewBlock

func (blocks *Blocks) AddNewBlock(pos, size Vec3, ic BlockColor)

AddNewBlock creates a new Block and appends it to the slice.

func (Blocks) Draw

func (blocks Blocks) Draw(dst draw.Image, origin Vec3)

Draw all blocks.

func (Blocks) DrawBounds

func (blocks Blocks) DrawBounds(dst draw.Image, origin Vec3)

DrawBounds for all blocks.

func (Blocks) DrawPolygons

func (blocks Blocks) DrawPolygons(dst draw.Image, origin Vec3)

DrawPolygons draws all of the blocks on the dst image. (using the shape, top and left polygons at the given origin)

func (Blocks) DrawRectangles

func (blocks Blocks) DrawRectangles(dst draw.Image, origin Vec3)

DrawRectangles for all blocks.

func (Blocks) DrawWireframes

func (blocks Blocks) DrawWireframes(dst draw.Image, origin Vec3)

DrawWireframes for all blocks.

func (Blocks) Sort

func (blocks Blocks) Sort()

Sort blocks to be drawn starting from max X, max Y and min Z.

type Box

type Box struct {
	Min Vec3
	Max Vec3
}

Box is a 3D cuboid with a min and max Vec3

func B

func B(minX, minY, minZ, maxX, maxY, maxZ float64) Box

B returns a new Box with given the Min and Max coordinates.

func NewBox

func NewBox(min, max Vec3) Box

NewBox creates a new Box.

func (Box) Behind

func (b Box) Behind(a Box) bool

Behind checks if b is in front of the a box.

func (Box) Overlaps

func (b Box) Overlaps(a Box) bool

Overlaps checks if two boxes overlap or not.

type CIELab

type CIELab struct {
	L float64
	A float64
	B float64
}

CIELab represents a color in CIE-L*ab.

func (CIELab) DeltaC

func (c1 CIELab) DeltaC(c2 CIELab) float64

DeltaC calculates Delta C* for two CIE-L*ab colors.

CIE-a*1, CIE-b*1 //Color #1 CIE-L*ab values CIE-a*2, CIE-b*2 //Color #2 CIE-L*ab values

Delta C* = sqrt( ( CIE-a*2 ^ 2 ) + ( CIE-b*2 ^ 2 ) )

- sqrt( ( CIE-a*1 ^ 2 ) + ( CIE-b*1 ^ 2 ) )

func (CIELab) DeltaE

func (c1 CIELab) DeltaE(c2 CIELab) float64

DeltaE calculates Delta E* for two CIE-L*ab colors.

CIE-L*1, CIE-a*1, CIE-b*1 //Color #1 CIE-L*ab values CIE-L*2, CIE-a*2, CIE-b*2 //Color #2 CIE-L*ab values

Delta E* = sqrt( ( ( CIE-L*1 - CIE-L*2 ) ^ 2 )

+ ( ( CIE-a*1 - CIE-a*2 ) ^ 2 )
+ ( ( CIE-b*1 - CIE-b*2 ) ^ 2 ) )

func (CIELab) DeltaH

func (c1 CIELab) DeltaH(c2 CIELab) float64

DeltaH calculates Delta H* for two CIE-L*ab colors.

CIE-a*1, CIE-b*1 //Color #1 CIE-L*ab values CIE-a*2, CIE-b*2 //Color #2 CIE-L*ab values

xDE = sqrt( ( CIE-a*2 ^ 2 ) + ( CIE-b*2 ^ 2 ) )

- sqrt( ( CIE-a*1 ^ 2 ) + ( CIE-b*1 ^ 2 ) )

Delta H* = sqrt( ( CIE-a*2 - CIE-a*1 ) ^ 2

+ ( CIE-b*2 - CIE-b*1 ) ^ 2 - ( xDE ^ 2 ) )

type Circle

type Circle struct {
	Center Vec
	Radius float64
}

Circle is a 2D circle. It is defined by two properties:

- Center vector
- Radius float64

func C

func C(center Vec, radius float64) Circle

C returns a new Circle with the given radius and center coordinates.

Note that a negative radius is valid.

func (Circle) Area

func (c Circle) Area() float64

Area returns the area of the Circle.

func (Circle) Contains

func (c Circle) Contains(u Vec) bool

Contains checks whether a vector `u` is contained within this Circle (including it's perimeter).

func (Circle) Intersect

func (c Circle) Intersect(d Circle) Circle

Intersect returns the maximal Circle which is covered by both `c` and `d`.

If `c` and `d` don't overlap, this function returns a zero-sized circle at the centerpoint between the two Circle's centers.

func (Circle) IntersectRect

func (c Circle) IntersectRect(r Rect) Vec

IntersectRect returns a minimal required Vector, such that moving the circle by that vector would stop the Circle and the Rect intersecting. This function returns a zero-vector if the Circle and Rect do not overlap, and if only the perimeters touch.

This function will return a non-zero vector if:

- The Rect contains the Circle, partially or fully
- The Circle contains the Rect, partially of fully

func (Circle) Moved

func (c Circle) Moved(delta Vec) Circle

Moved returns the Circle moved by the given vector delta.

func (Circle) Norm

func (c Circle) Norm() Circle

Norm returns the Circle in normalized form - this sets the radius to its absolute value.

func (Circle) Resized

func (c Circle) Resized(radiusDelta float64) Circle

Resized returns the Circle resized by the given delta. The Circles center is use as the anchor.

func (Circle) String

func (c Circle) String() string

String returns the string representation of the Circle.

func (Circle) Union

func (c Circle) Union(d Circle) Circle

Union returns the minimal Circle which covers both `c` and `d`.

type Degrees

type Degrees float64

Degrees of arc.

func (Degrees) Radians

func (d Degrees) Radians() float64

Radians convert degrees to radians.

type Domain

type Domain []float64

Domain of values.

func (Domain) Max

func (d Domain) Max() float64

Max value in the Domain.

func (Domain) Min

func (d Domain) Min() float64

Min value in the Domain.

type DrawTarget

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

DrawTarget draws to a draw.Image, projected through a Matrix.

func NewDrawTarget

func NewDrawTarget(dst draw.Image) *DrawTarget

NewDrawTarget creates a new draw target.

func (*DrawTarget) At

func (dt *DrawTarget) At(x, y int) color.Color

At retrieves the color at (x, y).

func (*DrawTarget) Bounds

func (dt *DrawTarget) Bounds() image.Rectangle

Bounds of the draw target.

func (*DrawTarget) Center

func (dt *DrawTarget) Center() Vec

Center vector of the draw target.

func (*DrawTarget) ColorModel

func (dt *DrawTarget) ColorModel() color.Model

ColorModel of the draw target.

func (*DrawTarget) MakePicture

func (dt *DrawTarget) MakePicture(pic Picture) TargetPicture

MakePicture creates a TargetPicture for the provided Picture.

func (*DrawTarget) MakeTriangles

func (dt *DrawTarget) MakeTriangles(t Triangles) TargetTriangles

MakeTriangles creates TargetTriangles for the given Triangles

func (*DrawTarget) Set

func (dt *DrawTarget) Set(x, y int, c color.Color)

Set the color at (x, y). (Projected through the draw target Matrix)

func (*DrawTarget) SetMatrix

func (dt *DrawTarget) SetMatrix(mat Matrix)

SetMatrix sets the matrix of the draw target.

type Drawer

type Drawer struct {
	Triangles Triangles
	Picture   Picture
	// contains filtered or unexported fields
}

Drawer glues all the fundamental interfaces (Target, Triangles, Picture) into a coherent and the only intended usage pattern.

Drawer makes it possible to draw any combination of Triangles and Picture onto any Target efficiently.

To create a Drawer, just assign it's Triangles and Picture fields:

d := gfx.Drawer{Triangles: t, Picture: p}

If Triangles is nil, nothing will be drawn. If Picture is nil, Triangles will be drawn without a Picture.

Whenever you change the Triangles, call Dirty to notify Drawer that Triangles changed. You don't need to notify Drawer about a change of the Picture.

Note, that Drawer caches the results of MakePicture from Targets it's drawn to for each Picture it's set to. What it means is that using a Drawer with an unbounded number of Pictures leads to a memory leak, since Drawer caches them and never forgets. In such a situation, create a new Drawer for each Picture.

func (*Drawer) Dirty

func (d *Drawer) Dirty()

Dirty marks the Triangles of this Drawer as changed. If not called, changes will not be visible when drawing.

func (*Drawer) Draw

func (d *Drawer) Draw(t Target)

Draw efficiently draws Triangles with Picture onto the provided Target.

If Triangles is nil, nothing will be drawn. If Picture is nil, Triangles will be drawn without a Picture.

type EndShape

type EndShape int

EndShape specifies the shape of an end of a line or a curve.

const (
	// NoEndShape leaves a line point with no special end shape.
	NoEndShape EndShape = iota

	// SharpEndShape is a sharp triangular end shape.
	SharpEndShape

	// RoundEndShape is a circular end shape.
	RoundEndShape
)

type Error

type Error string

Error is a string that implements the error interface.

func (Error) Error

func (e Error) Error() string

Error implements the error interface.

type Float64Scaler

type Float64Scaler interface {
	ScaleFloat64(float64) float64
}

Float64Scaler can scale a float64 to another float64.

type GeoPoint

type GeoPoint struct {
	Lon float64
	Lat float64
}

GeoPoint represents a geographic point with Lat/Lon.

func GP

func GP(lat, lon float64) GeoPoint

GP creates a new GeoPoint

func NewGeoPointFromTileNumbers

func NewGeoPointFromTileNumbers(zoom, x, y int) GeoPoint

NewGeoPointFromTileNumbers creates a new GeoPoint based on the given tile numbers. https://wiki.openstreetmap.org/wiki/Slippy_map_tilenames#Tile_numbers_to_lon..2Flat.

func (GeoPoint) GeoTile

func (gp GeoPoint) GeoTile(zoom int) GeoTile

GeoTile for the GeoPoint at the given zoom level.

func (GeoPoint) In

func (gp GeoPoint) In(gt GeoTile, tileSize int) Vec

In returns a Vec for the position of the GeoPoint in a GeoTile.

func (GeoPoint) Vec

func (gp GeoPoint) Vec(tileSize, zoom int) Vec

Vec returns a vector for the geo point based on the given tileSize and zoom level.

type GeoTile

type GeoTile struct {
	Zoom int
	X    int
	Y    int
}

GeoTile consists of a Zoom level, X and Y values.

func GT

func GT(zoom, x, y int) GeoTile

GT creates a new GeoTile.

func (GeoTile) AddXY

func (gt GeoTile) AddXY(x, y int) GeoTile

AddXY adds x and y.

func (GeoTile) Bounds

func (gt GeoTile) Bounds(dst image.Image, gp GeoPoint, tileSize int) image.Rectangle

Bounds returns an image.Rectangle for the GeoTile based on the dst, gp and tileSize.

func (GeoTile) Draw

func (gt GeoTile) Draw(dst draw.Image, gp GeoPoint, src image.Image)

Draw the tile on dst.

func (GeoTile) E

func (gt GeoTile) E() GeoTile

E is the tile to the east.

func (GeoTile) GeoPoint

func (gt GeoTile) GeoPoint() GeoPoint

GeoPoint for the GeoTile.

func (GeoTile) GetImage

func (gt GeoTile) GetImage(format string) (image.Image, error)

GetImage for the tile.

func (GeoTile) N

func (gt GeoTile) N() GeoTile

N is the tile to the north.

func (GeoTile) NE

func (gt GeoTile) NE() GeoTile

NE is the tile to the northeast.

func (GeoTile) NW

func (gt GeoTile) NW() GeoTile

NW is the tile to the northwest.

func (GeoTile) Neighbors

func (gt GeoTile) Neighbors() GeoTiles

Neighbors returns the neighboring tiles.

func (GeoTile) Rawurl

func (gt GeoTile) Rawurl(format string) string

Rawurl formats a URL string with Zoom, X and Y.

func (GeoTile) S

func (gt GeoTile) S() GeoTile

S is the tile to the south.

func (GeoTile) SE

func (gt GeoTile) SE() GeoTile

SE is the tile to the southeast.

func (GeoTile) SW

func (gt GeoTile) SW() GeoTile

SW is the tile to the southwest.

func (GeoTile) Vec

func (gt GeoTile) Vec(gp GeoPoint, tileSize int) Vec

Vec returns the Vec for the GeoPoint in the GeoTile.

func (GeoTile) W

func (gt GeoTile) W() GeoTile

W is the tile to the west.

type GeoTileServer

type GeoTileServer struct {
	Format string
}

GeoTileServer represents a tile server.

func GTS

func GTS(format string) GeoTileServer

GTS creates a GeoTileServer.

func (GeoTileServer) DrawNeighbors

func (gts GeoTileServer) DrawNeighbors(dst draw.Image, gt GeoTile, gp GeoPoint) error

DrawNeighbors on dst.

func (GeoTileServer) DrawTile

func (gts GeoTileServer) DrawTile(dst draw.Image, gt GeoTile, gp GeoPoint) error

DrawTile on dst.

func (GeoTileServer) DrawTileAndNeighbors

func (gts GeoTileServer) DrawTileAndNeighbors(dst draw.Image, gt GeoTile, gp GeoPoint) error

DrawTileAndNeighbors on dst.

func (GeoTileServer) GetImage

func (gts GeoTileServer) GetImage(gt GeoTile) (image.Image, error)

GetImage for the given GeoTile from the tile server.

type GeoTiles

type GeoTiles []GeoTile

GeoTiles is a slice of GeoTile.

type HSL

type HSL struct {
	Hue        float64
	Saturation float64
	Lightness  float64
}

HSL is the hue, saturation and lightness color representation. - Hue [0,360] - Saturation [0,1] - Lightness [0,1]

func ColorToHSL

func ColorToHSL(c color.Color) HSL

ColorToHSL converts a color into HSL.

func (HSL) Components

func (hsl HSL) Components() (h, s, l float64)

Components in HSL.

func (HSL) RGBA

func (hsl HSL) RGBA() color.RGBA

RGBA converts a HSL color value to color.RGBA.

type HSV

type HSV struct {
	Hue        float64
	Saturation float64
	Value      float64
}

HSV is the hue, saturation and value color representation. - Hue [0,360] - Saturation [0,1] - Value [0,1]

func ColorToHSV

func ColorToHSV(c color.Color) HSV

ColorToHSV converts a color into HSV.

func (HSV) Components

func (hsv HSV) Components() (h, s, v float64)

Components in HSV.

func (HSV) RGBA

func (hsv HSV) RGBA() color.RGBA

RGBA converts a HSV color value to color.RGBA.

type HTTP

type HTTP struct {
	*http.Client
	UserAgent string
}

HTTP is the HTTP client and user agent used by the gfx package.

type HunterLab

type HunterLab struct {
	L float64
	A float64
	B float64
}

HunterLab represents a color in Hunter-Lab.

func (HunterLab) XYZ

func (h HunterLab) XYZ(ref XYZ) XYZ

XYZ converts from HunterLab to XYZ.

Reference-X, Y and Z refer to specific illuminants and observers. Common reference values are available below in this same page.

var_Ka = ( 175.0 / 198.04 ) * ( Reference-Y + Reference-X ) var_Kb = ( 70.0 / 218.11 ) * ( Reference-Y + Reference-Z )

Y = ( ( Hunter-L / Reference-Y ) ^ 2 ) * 100.0 X = ( Hunter-a / var_Ka * sqrt( Y / Reference-Y ) + ( Y / Reference-Y ) ) * Reference-X Z = - ( Hunter-b / var_Kb * sqrt( Y / Reference-Y ) - ( Y / Reference-Y ) ) * Reference-Z

type IMDraw

type IMDraw struct {
	Color     color.Color
	Picture   Vec
	Intensity float64
	Precision int
	EndShape  EndShape
	// contains filtered or unexported fields
}

IMDraw is an immediate-mode-like shape drawer and BasicTarget. IMDraw supports TrianglesPosition, TrianglesColor, TrianglesPicture and PictureColor.

IMDraw, other than a regular BasicTarget, is used to draw shapes. To draw shapes, you first need to Push some points to IMDraw:

imd := gfx.NewIMDraw(pic) // use nil pic if you only want to draw primitive shapes
imd.Push(gfx.V(100, 100))
imd.Push(gfx.V(500, 100))

Once you have Pushed some points, you can use them to draw a shape, such as a line:

imd.Line(20) // draws a 20 units thick line

Set exported fields to change properties of Pushed points:

imd.Color = gfx.RGB(1, 0, 0)
imd.Push(gfx.V(200, 200))
imd.Circle(400, 0)

Here is the list of all available point properties (need to be set before Pushing a point):

- Color     - applies to all
- Picture   - coordinates, only applies to filled polygons
- Intensity - picture intensity, only applies to filled polygons
- Precision - curve drawing precision, only applies to circles and ellipses
- EndShape  - shape of the end of a line, only applies to lines and outlines

And here's the list of all shapes that can be drawn (all, except for line, can be filled or outlined):

- Line
- Polygon
- Circle
- Circle arc
- Ellipse
- Ellipse arc

func NewIMDraw

func NewIMDraw(pic Picture) *IMDraw

NewIMDraw creates a new empty IMDraw. An optional Picture can be used to draw with a Picture.

If you just want to draw primitive shapes, pass nil as the Picture.

func (*IMDraw) Circle

func (imd *IMDraw) Circle(radius, thickness float64)

Circle draws a circle of the specified radius around each Pushed point. If the thickness is 0, the circle will be filled, otherwise a circle outline of the specified thickness will be drawn.

func (*IMDraw) CircleArc

func (imd *IMDraw) CircleArc(radius, low, high, thickness float64)

CircleArc draws a circle arc of the specified radius around each Pushed point. If the thickness is 0, the arc will be filled, otherwise will be outlined. The arc starts at the low angle and continues to the high angle. If low<high, the arc will be drawn counterclockwise. Otherwise it will be clockwise. The angles are not normalized by any means.

imd.CircleArc(40, 0, 8*math.Pi, 0)

This line will fill the whole circle 4 times.

func (*IMDraw) Clear

func (imd *IMDraw) Clear()

Clear removes all drawn shapes from the IM. This does not remove Pushed points.

func (*IMDraw) Draw

func (imd *IMDraw) Draw(t Target)

Draw draws all currently drawn shapes inside the IM onto another Target.

Note, that IMDraw's matrix have no effect here.

func (*IMDraw) Ellipse

func (imd *IMDraw) Ellipse(radius Vec, thickness float64)

Ellipse draws an ellipse of the specified radius in each axis around each Pushed points. If the thickness is 0, the ellipse will be filled, otherwise an ellipse outline of the specified thickness will be drawn.

func (*IMDraw) EllipseArc

func (imd *IMDraw) EllipseArc(radius Vec, low, high, thickness float64)

EllipseArc draws an ellipse arc of the specified radius in each axis around each Pushed point. If the thickness is 0, the arc will be filled, otherwise will be outlined. The arc starts at the low angle and continues to the high angle. If low<high, the arc will be drawn counterclockwise. Otherwise it will be clockwise. The angles are not normalized by any means.

imd.EllipseArc(gfx.V(100, 50), 0, 8*math.Pi, 0)

This line will fill the whole ellipse 4 times.

func (*IMDraw) Line

func (imd *IMDraw) Line(thickness float64)

Line draws a polyline of the specified thickness between the Pushed points.

func (*IMDraw) MakePicture

func (imd *IMDraw) MakePicture(p Picture) TargetPicture

MakePicture returns a specialized copy of the provided Picture that draws onto this IMDraw.

func (*IMDraw) MakeTriangles

func (imd *IMDraw) MakeTriangles(t Triangles) TargetTriangles

MakeTriangles returns a specialized copy of the provided Triangles that draws onto this IMDraw.

func (*IMDraw) Polygon

func (imd *IMDraw) Polygon(thickness float64)

Polygon draws a polygon from the Pushed points. If the thickness is 0, the convex polygon will be filled. Otherwise, an outline of the specified thickness will be drawn. The outline does not have to be convex.

Note, that the filled polygon does not have to be strictly convex. The way it's drawn is that a triangle is drawn between each two adjacent points and the first Pushed point. You can use this property to draw certain kinds of concave polygons.

func (*IMDraw) Push

func (imd *IMDraw) Push(pts ...Vec)

Push adds some points to the IM queue. All Pushed points will have the same properties except for the position.

func (*IMDraw) Rectangle

func (imd *IMDraw) Rectangle(thickness float64)

Rectangle draws a rectangle between each two subsequent Pushed points. Drawing a rectangle between two points means drawing a rectangle with sides parallel to the axes of the coordinate system, where the two points specify it's two opposite corners.

If the thickness is 0, rectangles will be filled, otherwise will be outlined with the given thickness.

func (*IMDraw) Reset

func (imd *IMDraw) Reset()

Reset restores all point properties to defaults and removes all Pushed points.

This does not affect matrix set by SetMatrix.

func (*IMDraw) SetMatrix

func (imd *IMDraw) SetMatrix(m Matrix)

SetMatrix sets a Matrix that all further points will be transformed by.

type Layer

type Layer struct {
	Tileset *Tileset
	Width   int // Width of the layer in number of tiles.
	Data    LayerData
}

Layer represents a layer of paletted tiles.

func NewLayer

func NewLayer(tileset *Tileset, width int, data LayerData) *Layer

NewLayer creates a new layer.

func (*Layer) AlphaAt

func (l *Layer) AlphaAt(x, y int) uint8

AlphaAt returns the alpha value at (x, y).

func (*Layer) At

func (l *Layer) At(x, y int) color.Color

At returns the color at (x, y).

func (*Layer) Bounds

func (l *Layer) Bounds() image.Rectangle

Bounds returns the bounds of the paletted layer.

func (*Layer) ColorIndexAt

func (l *Layer) ColorIndexAt(x, y int) uint8

ColorIndexAt returns the palette index of the pixel at (x, y).

func (*Layer) ColorModel

func (l *Layer) ColorModel() color.Model

ColorModel returns the color model for the paletted layer.

func (*Layer) ColorPalette

func (l *Layer) ColorPalette() color.Palette

ColorPalette retrieves the layer palette.

func (*Layer) DataAt

func (l *Layer) DataAt(dx, dy int) int

DataAt returns the data at (dx, dy).

func (*Layer) GfxPalette

func (l *Layer) GfxPalette() Palette

GfxPalette retrieves the layer palette.

func (*Layer) Index

func (l *Layer) Index(x, y int) int

Index returns the tile index at (x, y). (Short for TileIndexAt)

func (*Layer) NRGBAAt

func (l *Layer) NRGBAAt(x, y int) color.NRGBA

NRGBAAt returns the color.RGBA at (x, y).

func (*Layer) Put

func (l *Layer) Put(dx, dy, index int)

Put changes the tile index at (dx, dy). (Short for SetTileIndex)

func (*Layer) SetTileIndex

func (l *Layer) SetTileIndex(dx, dy, index int)

SetTileIndex changes the tile index at (dx, dy).

func (*Layer) TileAt

func (l *Layer) TileAt(x, y int) image.PalettedImage

TileAt returns the tile image at (x, y).

func (*Layer) TileIndexAt

func (l *Layer) TileIndexAt(x, y int) int

TileIndexAt returns the tile index at (x, y).

func (*Layer) TileSize

func (l *Layer) TileSize() image.Point

TileSize returns the tileset tile size.

type LayerData

type LayerData []int

LayerData is the data for a layer.

func (LayerData) Size

func (ld LayerData) Size(cols int) image.Point

Size returns the size of the layer data given the number of columns.

type LinearScaler

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

LinearScaler can scale domain values to a range values.

func NewLinearScaler

func NewLinearScaler() LinearScaler

NewLinearScaler creates a new linear scaler.

func (LinearScaler) Domain

func (ls LinearScaler) Domain(d ...float64) LinearScaler

Domain returns a LinearScaler with the given domain.

func (LinearScaler) Range

func (ls LinearScaler) Range(r ...float64) LinearScaler

Range returns a LinearScaler with the given range.

func (LinearScaler) ScaleFloat64

func (ls LinearScaler) ScaleFloat64(x float64) float64

ScaleFloat64 from domain to range.

OLD PERCENT = (x - OLD MIN) / (OLD MAX - OLD MIN) NEW X = ((NEW MAX - NEW MIN) * OLD PERCENT) + NEW MIN

type Matrix

type Matrix [6]float64

Matrix is a 2x3 affine matrix that can be used for all kinds of spatial transforms, such as movement, scaling and rotations.

Matrix has a handful of useful methods, each of which adds a transformation to the matrix. For example:

gfx.IM.Moved(gfx.V(100, 200)).Rotated(gfx.ZV, math.Pi/2)

This code creates a Matrix that first moves everything by 100 units horizontally and 200 units vertically and then rotates everything by 90 degrees around the origin.

Layout is: [0] [2] [4] [1] [3] [5]

0   0   1  (implicit row)

func (Matrix) Chained

func (m Matrix) Chained(next Matrix) Matrix

Chained adds another Matrix to this one. All tranformations by the next Matrix will be applied after the transformations of this Matrix.

func (Matrix) Moved

func (m Matrix) Moved(delta Vec) Matrix

Moved moves everything by the delta vector.

func (Matrix) Project

func (m Matrix) Project(u Vec) Vec

Project applies all transformations added to the Matrix to a vector u and returns the result.

Time complexity is O(1).

func (Matrix) Rotated

func (m Matrix) Rotated(around Vec, angle float64) Matrix

Rotated rotates everything around a given point by the given angle in radians.

func (Matrix) RotatedDegrees

func (m Matrix) RotatedDegrees(around Vec, degrees float64) Matrix

RotatedDegrees rotates everything around a given point by the given number of degrees.

func (Matrix) Scaled

func (m Matrix) Scaled(around Vec, scale float64) Matrix

Scaled scales everything around a given point by the scale factor.

func (Matrix) ScaledXY

func (m Matrix) ScaledXY(around Vec, scale Vec) Matrix

ScaledXY scales everything around a given point by the scale factor in each axis respectively.

func (Matrix) String

func (m Matrix) String() string

String returns a string representation of the Matrix.

m := gfx.IM
fmt.Println(m) // Matrix(1 0 0 | 0 1 0)

func (Matrix) Unproject

func (m Matrix) Unproject(u Vec) Vec

Unproject does the inverse operation to Project.

Time complexity is O(1).

type Palette

type Palette []color.NRGBA

Palette is a slice of colors.

func (Palette) AsColorPalette

func (p Palette) AsColorPalette() color.Palette

AsColorPalette converts the Palette to a color.Palette.

func (Palette) At

func (p Palette) At(t float64) color.Color

At returns the color at the given float64 value (range 0-1)

func (Palette) CmplxPhaseAt

func (p Palette) CmplxPhaseAt(z complex128) color.Color

CmplxPhaseAt returns the color at the phase of the given complex128 value.

func (Palette) Color

func (p Palette) Color(n int) color.NRGBA

Color returns the color at index n.

func (Palette) Convert

func (p Palette) Convert(c color.Color) color.Color

Convert returns the palette color closest to c in Euclidean R,G,B space.

func (Palette) Index

func (p Palette) Index(c color.Color) int

Index returns the index of the palette color closest to c in Euclidean R,G,B,A space.

func (Palette) Len

func (p Palette) Len() int

Len returns the number of colors in the palette.

func (Palette) Random

func (p Palette) Random() color.NRGBA

Random color from the palette.

func (Palette) Sort

func (p Palette) Sort(less func(i, j int) bool)

Sort palette.

func (Palette) SortByHue

func (p Palette) SortByHue()

SortByHue sorts based on (HSV) Hue.

func (Palette) Tile

func (p Palette) Tile(src image.Image) *Paletted

Tile returns a new image based on the input image, but with colors from the palette.

type PaletteLookup

type PaletteLookup map[PaletteName]Palette

PaletteLookup is a map of PaletteName to Palette.

type PaletteName

type PaletteName string

PaletteName is a palette name.

type Paletted

type Paletted struct {
	// Pix holds the image's pixels, as palette indices. The pixel at
	// (x, y) starts at Pix[(y-Rect.Min.Y)*Stride + (x-Rect.Min.X)*1].
	Pix []uint8
	// Stride is the Pix stride (in bytes) between vertically adjacent pixels.
	Stride int
	// Rect is the image's bounds.
	Rect image.Rectangle
	// Palette is the image's palette.
	Palette Palette
}

Paletted is an in-memory image of uint8 indices into a given palette.

func NewPaletted

func NewPaletted(w, h int, p Palette, colors ...color.Color) *Paletted

NewPaletted returns a new paletted image with the given width, height and palette.

func NewPalettedImage

func NewPalettedImage(r image.Rectangle, p Palette) *Paletted

NewPalettedImage returns a new paletted image with the given bounds and palette.

func NewResizedPalettedImage

func NewResizedPalettedImage(src PalettedImage, w, h int) *Paletted

NewResizedPalettedImage returns an image with the provided dimensions.

func NewScaledPalettedImage

func NewScaledPalettedImage(src PalettedImage, s float64) *Paletted

NewScaledPalettedImage returns a paletted image scaled by the provided scaling factor.

func NewTile

func NewTile(p Palette, cols int, pix []uint8) *Paletted

NewTile returns a new paletted image with the given pix, stride and palette.

func (*Paletted) AlphaAt

func (p *Paletted) AlphaAt(x, y int) uint8

AlphaAt returns the alpha value at (x, y).

func (*Paletted) At

func (p *Paletted) At(x, y int) color.Color

At returns the color at (x, y).

func (*Paletted) Bounds

func (p *Paletted) Bounds() image.Rectangle

Bounds returns the bounds of the paletted image.

func (*Paletted) ColorIndexAt

func (p *Paletted) ColorIndexAt(x, y int) uint8

ColorIndexAt returns the color index at (x, y).

func (*Paletted) ColorModel

func (p *Paletted) ColorModel() color.Model

ColorModel returns the color model of the paletted image.

func (*Paletted) ColorPalette

func (p *Paletted) ColorPalette() color.Palette

ColorPalette returns the color palette of the paletted image.

func (*Paletted) GfxPalette

func (p *Paletted) GfxPalette() Palette

GfxPalette returns the gfx palette of the paletted image.

func (*Paletted) Index

func (p *Paletted) Index(x, y int) uint8

Index returns the color index at (x, y). (Short for ColorIndexAt)

func (*Paletted) NRGBAAt

func (p *Paletted) NRGBAAt(x, y int) color.NRGBA

NRGBAAt returns the color.NRGBA at (x, y).

func (*Paletted) Opaque

func (p *Paletted) Opaque() bool

Opaque scans the entire image and reports whether it is fully opaque.

func (*Paletted) PixOffset

func (p *Paletted) PixOffset(x, y int) int

PixOffset returns the index of the first element of Pix that corresponds to the pixel at (x, y).

func (*Paletted) Pixels

func (p *Paletted) Pixels() []uint8

Pixels returns the pixels of the paletted image as a []uint8.

func (*Paletted) Put

func (p *Paletted) Put(x, y int, index uint8)

Put changes the color index at (x, y). (Short for SetColorIndex)

func (*Paletted) Set

func (p *Paletted) Set(x, y int, c color.Color)

Set changes the color at (x, y).

func (*Paletted) SetColorIndex

func (p *Paletted) SetColorIndex(x, y int, index uint8)

SetColorIndex changes the color index at (x, y).

func (*Paletted) SubImage

func (p *Paletted) SubImage(r image.Rectangle) image.Image

SubImage returns an image representing the portion of the image p visible through r. The returned value shares pixels with the original image.

type PalettedDrawImage

type PalettedDrawImage interface {
	SetColorIndex(int, int, uint8)
	PalettedImage
}

PalettedDrawImage interface is implemented by *Paletted

type PalettedImage

type PalettedImage interface {
	GfxPalette() Palette
	ColorPalette() color.Palette
	NRGBAAt(int, int) color.NRGBA
	AlphaAt(int, int) uint8
	image.PalettedImage
}

PalettedImage interface is implemented by *Paletted

type Palettes

type Palettes []Palette

Palettes is a slice of Palette.

type Picture

type Picture interface {
	// Bounds returns the rectangle of the Picture. All data is located witih this rectangle.
	// Querying properties outside the rectangle should return default value of that property.
	Bounds() Rect
}

Picture represents a rectangular area of raster data, such as a color. It has Bounds which specify the rectangle where data is located.

type PictureColor

type PictureColor interface {
	Picture
	Color(at Vec) color.NRGBA
}

PictureColor specifies Picture with Color property, so that every position inside the Picture's Bounds has a color.

Positions outside the Picture's Bounds must return full transparent (Alpha(0)).

type Points

type Points []image.Point

Points are a list of points.

func (Points) Polygon

func (pts Points) Polygon() Polygon

Polygon based on the points.

type Polygon

type Polygon []Vec

Polygon is represented by a list of vectors.

func (Polygon) Bounds

func (p Polygon) Bounds() image.Rectangle

Bounds return the bounds of the polygon rectangle.

func (Polygon) EachPixel

func (p Polygon) EachPixel(m image.Image, fn func(x, y int))

EachPixel calls the provided function for each pixel in the polygon rectangle bounds.

func (Polygon) Fill

func (p Polygon) Fill(dst draw.Image, c color.Color) (drawCount int)

Fill polygon on the image with the given color.

func (Polygon) Outline

func (p Polygon) Outline(dst draw.Image, thickness float64, c color.Color)

Outline draws an outline of the polygon on dst.

func (Polygon) Project

func (p Polygon) Project(m Matrix) Polygon

Project creates a new Polygon with all vertexes projected through the given Matrix.

func (Polygon) Rect

func (p Polygon) Rect() Rect

Rect is the polygon rectangle.

type Polyline

type Polyline []Polygon

Polyline is a slice of polygons forming a line.

func NewPolyline

func NewPolyline(p Polygon, t float64) Polyline

NewPolyline constructs a slice of line polygons.

type Range

type Range []float64

Range of values.

func (Range) First

func (r Range) First() float64

First value in the Range.

func (Range) Last

func (r Range) Last() float64

Last value in the Range.

type ReadFunc

type ReadFunc func(r io.Reader) error

ReadFunc is a func that takes a io.Reader and returns an error.

func DecodeJSONFunc

func DecodeJSONFunc(v interface{}) ReadFunc

DecodeJSONFunc returns a function that takes a reader, and decodes into the given value.

type Rect

type Rect struct {
	Min, Max Vec
}

Rect is a 2D rectangle aligned with the axes of the coordinate system. It is defined by two points, Min and Max.

The invariant should hold, that Max's components are greater or equal than Min's components respectively.

func BoundsToRect

func BoundsToRect(ir image.Rectangle) Rect

BoundsToRect converts an image.Rectangle to a Rect.

func NewRect

func NewRect(min, max Vec) Rect

NewRect creates a new Rect.

func R

func R(minX, minY, maxX, maxY float64) Rect

R returns a new Rect given the Min and Max coordinates.

Note that the returned rectangle is not automatically normalized.

func (Rect) Area

func (r Rect) Area() float64

Area returns the area of r. If r is not normalized, area may be negative.

func (Rect) Bounds

func (r Rect) Bounds() image.Rectangle

Bounds returns the bounds of the rectangle.

func (Rect) Center

func (r Rect) Center() Vec

Center returns the position of the center of the Rect.

func (Rect) CenterOrigin

func (r Rect) CenterOrigin(v Vec, z float64) Vec3

CenterOrigin returns a Vec3 based on Rect.Center() scaled by v, and its Z component set to the provided z.

func (Rect) Contains

func (r Rect) Contains(u Vec) bool

Contains checks whether a vector u is contained within this Rect (including it's borders).

func (Rect) Draw

func (r Rect) Draw(dst draw.Image, src image.Image)

Draw draws Rect to src over dst, at the zero point.

func (Rect) DrawColor

func (r Rect) DrawColor(dst draw.Image, c color.Color)

DrawColor draws Rect with a uniform color on dst.

func (Rect) DrawColorOver

func (r Rect) DrawColorOver(dst draw.Image, c color.Color)

DrawColorOver draws Rect with a uniform color over dst.

func (Rect) EachVec

func (r Rect) EachVec(dir Vec, fn func(p Vec))

EachVec calls the provided function for each vec in the given direction.

func (Rect) H

func (r Rect) H() float64

H returns the height of the Rect.

func (Rect) Intersect

func (r Rect) Intersect(s Rect) Rect

Intersect returns the maximal Rect which is covered by both r and s. Rects r and s must be normalized.

If r and s don't overlap, this function returns R(0, 0, 0, 0).

func (Rect) IntersectCircle

func (r Rect) IntersectCircle(c Circle) Vec

IntersectCircle returns a minimal required Vector, such that moving the circle by that vector would stop the Circle and the Rect intersecting. This function returns a zero-vector if the Circle and Rect do not overlap, and if only the perimeters touch.

This function will return a non-zero vector if:

- The Rect contains the Circle, partially or fully
- The Circle contains the Rect, partially of fully

func (Rect) Moved

func (r Rect) Moved(delta Vec) Rect

Moved returns the Rect moved (both Min and Max) by the given vector delta.

func (Rect) Norm

func (r Rect) Norm() Rect

Norm returns the Rect in normal form, such that Max is component-wise greater or equal than Min.

func (Rect) Overlaps

func (r Rect) Overlaps(s Rect) bool

Overlaps checks whether one Rect overlaps another Rect.

func (Rect) Resized

func (r Rect) Resized(anchor, size Vec) Rect

Resized returns the Rect resized to the given size while keeping the position of the given anchor.

r.Resized(r.Min, size)      // resizes while keeping the position of the lower-left corner
r.Resized(r.Max, size)      // same with the top-right corner
r.Resized(r.Center(), size) // resizes around the center

This function does not make sense for resizing a rectangle of zero area and will panic. Use ResizedMin in the case of zero area.

func (Rect) ResizedMin

func (r Rect) ResizedMin(size Vec) Rect

ResizedMin returns the Rect resized to the given size while keeping the position of the Rect's Min.

Sizes of zero area are safe here.

func (Rect) Size

func (r Rect) Size() Vec

Size returns the vector of width and height of the Rect.

func (Rect) String

func (r Rect) String() string

String returns the string representation of the Rect.

r := gfx.R(100, 50, 200, 300)
r.String()     // returns "gfx.R(100, 50, 200, 300)"
fmt.Println(r) // gfx.R(100, 50, 200, 300)

func (Rect) Union

func (r Rect) Union(s Rect) Rect

Union returns the minimal Rect which covers both r and s. Rects r and s must be normalized.

func (Rect) W

func (r Rect) W() float64

W returns the width of the Rect.

type SignedDistance

type SignedDistance struct {
	Vec
}

SignedDistance holds 2D signed distance functions based on https://iquilezles.org/www/articles/distfunctions2d/distfunctions2d.htm

func (SignedDistance) Annular

func (sd SignedDistance) Annular(v, r float64) float64

Annular signed distance function shape

func (SignedDistance) Circle

func (sd SignedDistance) Circle(r float64) float64

Circle primitive

func (SignedDistance) CircleFunc

CircleFunc creates a SignedDistanceFunc for a circle with the given radius.

func (SignedDistance) EquilateralTriangle

func (sd SignedDistance) EquilateralTriangle(s float64) float64

EquilateralTriangle primitive

func (SignedDistance) EquilateralTriangleFunc

func (SignedDistance) EquilateralTriangleFunc(s float64) SignedDistanceFunc

EquilateralTriangleFunc creates a SignedDistanceFunc for an equilateral triangle with the given size.

func (SignedDistance) IsoscelesTriangle

func (sd SignedDistance) IsoscelesTriangle(q Vec) float64

IsoscelesTriangle primitive

func (SignedDistance) IsoscelesTriangleFunc

func (SignedDistance) IsoscelesTriangleFunc(q Vec) SignedDistanceFunc

IsoscelesTriangleFunc creates a SignedDistanceFunc for an isosceles triangle with the given size.

func (SignedDistance) Line

func (sd SignedDistance) Line(a, b Vec) float64

Line primitive

func (SignedDistance) LineFunc

func (SignedDistance) LineFunc(a, b Vec) SignedDistanceFunc

LineFunc cleates a SignedDistanceFunc for a line with the given start and end.

func (SignedDistance) OpIntersection

func (sd SignedDistance) OpIntersection(x, y float64) float64

OpIntersection basic boolean operation for intersection.

func (SignedDistance) OpMoved

func (sd SignedDistance) OpMoved(d Vec, sdf SignedDistanceFunc) float64

OpMoved moves result of sdf by the given delta. (Relative to the identity matrix)

func (SignedDistance) OpRepeat

func (sd SignedDistance) OpRepeat(c Vec, sdf SignedDistanceFunc) float64

OpRepeat repeats based on the given c vector.

func (SignedDistance) OpSmoothIntersection

func (sd SignedDistance) OpSmoothIntersection(x, y, k float64) float64

OpSmoothIntersection smooth operation for intersection.

func (SignedDistance) OpSmoothSubtraction

func (sd SignedDistance) OpSmoothSubtraction(x, y, k float64) float64

OpSmoothSubtraction smooth operation for subtraction.

func (SignedDistance) OpSmoothUnion

func (sd SignedDistance) OpSmoothUnion(x, y, k float64) float64

OpSmoothUnion smooth operation for union.

func (SignedDistance) OpSubtraction

func (sd SignedDistance) OpSubtraction(x, y float64) float64

OpSubtraction basic boolean operation for subtraction.

func (SignedDistance) OpSymX

func (sd SignedDistance) OpSymX(sdf SignedDistanceFunc) float64

OpSymX symmetry operation for X.

func (SignedDistance) OpSymXY

func (sd SignedDistance) OpSymXY(sdf SignedDistanceFunc) float64

OpSymXY symmetry operation for X and Y.

func (SignedDistance) OpSymY

func (sd SignedDistance) OpSymY(sdf SignedDistanceFunc) float64

OpSymY symmetry operation for Y.

func (SignedDistance) OpTx

OpTx translates using the given matrix.

func (SignedDistance) OpUnion

func (sd SignedDistance) OpUnion(x, y float64) float64

OpUnion basic boolean operation for union.

func (SignedDistance) Rectangle

func (sd SignedDistance) Rectangle(b Vec) float64

Rectangle primitive

func (SignedDistance) RectangleFunc

func (SignedDistance) RectangleFunc(b Vec) SignedDistanceFunc

RectangleFunc creates a SignedDistanceFunc for a rectangle with the given size.

func (SignedDistance) Rhombus

func (sd SignedDistance) Rhombus(b Vec) float64

Rhombus primitive

func (SignedDistance) RhombusFunc

func (SignedDistance) RhombusFunc(b Vec) SignedDistanceFunc

RhombusFunc creates a SignedDistanceFunc for a rhombus with the given size.

func (SignedDistance) Rounded

func (sd SignedDistance) Rounded(v, r float64) float64

Rounded signed distance function shape

type SignedDistanceFunc

type SignedDistanceFunc func(SignedDistance) float64

SignedDistanceFunc is a func that takes a SignedDistance and returns a float64.

type SimplexNoise

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

SimplexNoise is a speed-improved simplex noise algorithm for 2D, 3D and 4D.

Based on example code by Stefan Gustavson (stegu@itn.liu.se). Optimisations by Peter Eastman (peastman@drizzle.stanford.edu). Better rank ordering method by Stefan Gustavson in 2012.

This could be speeded up even further, but it's useful as it is.

Version 2012-03-09

This code was placed in the public domain by its original author, Stefan Gustavson. You may use it as you see fit, but attribution is appreciated.

func NewSimplexNoise

func NewSimplexNoise(seed int64) *SimplexNoise

NewSimplexNoise creates a new simplex noise instance with the given seed

func (*SimplexNoise) Noise2D

func (sn *SimplexNoise) Noise2D(xin, yin float64) float64

Noise2D performs 2D simplex noise

func (*SimplexNoise) Noise3D

func (sn *SimplexNoise) Noise3D(xin, yin, zin float64) float64

Noise3D performs 3D simplex noise

func (*SimplexNoise) Noise4D

func (sn *SimplexNoise) Noise4D(x, y, z, w float64) float64

Noise4D performs 4D simplex noise, better simplex rank ordering method 2012-03-09

type Target

type Target interface {
	// MakeTriangles generates a specialized copy of the provided Triangles.
	//
	// When calling Draw method on the returned TargetTriangles, the TargetTriangles will be
	// drawn onto the Target that generated them.
	//
	// Note, that not every Target has to recognize all possible types of Triangles. Some may
	// only recognize TrianglesPosition and TrianglesColor and ignore all other properties (if
	// present) when making new TargetTriangles. This varies from Target to Target.
	MakeTriangles(Triangles) TargetTriangles

	// MakePicture generates a specialized copy of the provided Picture.
	//
	// When calling Draw method on the returned TargetPicture, the TargetPicture will be drawn
	// onto the Target that generated it together with the TargetTriangles supplied to the Draw
	// method.
	MakePicture(Picture) TargetPicture
}

Target is something that can be drawn onto, such as a window, a canvas, and so on.

You can notice, that there are no "drawing" methods in a Target. That's because all drawing happens indirectly through Triangles and Picture instances generated via MakeTriangles and MakePicture method.

type TargetPicture

type TargetPicture interface {
	Picture

	// Draw draws the supplied TargetTriangles (which must be generated by the same Target as
	// this TargetPicture) with this TargetPicture. The TargetTriangles should utilize the data
	// from this TargetPicture in some way.
	Draw(TargetTriangles)
}

TargetPicture is a Picture generated by a Target using MakePicture method. This Picture can be drawn onto that (no other) Target together with a TargetTriangles generated by the same Target.

The TargetTriangles specify where, shape and how the Picture should be drawn.

type TargetTriangles

type TargetTriangles interface {
	Triangles

	// Draw draws Triangles onto an associated Target.
	Draw()
}

TargetTriangles are Triangles generated by a Target with MakeTriangles method. They can be drawn onto that (no other) Target.

type Tiles

type Tiles []PalettedImage

Tiles is a slice of paletted images.

type Tileset

type Tileset struct {
	Palette Palette     // Palette of the tileset.
	Size    image.Point // Size is the size of each tile.
	Tiles   Tiles       // Images contains all of the images in the tileset.
}

Tileset is a paletted tileset.

func GetTileset

func GetTileset(p Palette, tileSize image.Point, rawurl string) (*Tileset, error)

GetTileset retrieves a remote tileset using GetPNG.

func NewTileset

func NewTileset(p Palette, s image.Point, td TilesetData) *Tileset

NewTileset creates a new paletted tileset.

func NewTilesetFromImage

func NewTilesetFromImage(p Palette, tileSize image.Point, src image.Image) *Tileset

NewTilesetFromImage creates a new paletted tileset based on the provided palette, tile size and image.

type TilesetData

type TilesetData [][]uint8

TilesetData is the raw data in a tileset

type Triangle

type Triangle [3]Vertex

Triangle is an array of three vertexes

func NewTriangle

func NewTriangle(i int, td *TrianglesData) Triangle

NewTriangle creates a new triangle.

func T

func T(a, b, c Vertex) Triangle

T constructs a new triangle based on three vertexes.

Example
t := T(
	Vx(V(1, 2), ColorRed),
	Vx(V(3, 4), ColorGreen, V(1, 1)),
	Vx(V(5, 6), ColorBlue, 0.5),
)

Log("%v\n%v\n%v", t[0], t[1], t[2])
Output:

{gfx.V(1, 2) {255 0 0 255} gfx.V(0, 0) 0}
{gfx.V(3, 4) {0 255 0 255} gfx.V(1, 1) 0}
{gfx.V(5, 6) {0 0 255 255} gfx.V(0, 0) 0.5}

func (Triangle) Bounds

func (t Triangle) Bounds() image.Rectangle

Bounds returns the bounds of the triangle.

func (Triangle) Centroid

func (t Triangle) Centroid() Vec

Centroid returns the centroid O of the triangle.

func (Triangle) Color

func (t Triangle) Color(u Vec) color.Color

Color returns the color at vector u.

func (Triangle) Colors

func (t Triangle) Colors() (color.NRGBA, color.NRGBA, color.NRGBA)

Colors returns the three colors.

func (Triangle) Contains

func (t Triangle) Contains(u Vec) bool

Contains returns true if the given vector is inside the triangle.

func (Triangle) Draw

func (t Triangle) Draw(dst draw.Image) (drawCount int)

Draw the triangle to dst.

func (Triangle) DrawColor

func (t Triangle) DrawColor(dst draw.Image, c color.Color) (drawCount int)

DrawColor draws the triangle on dst using the given color.

func (Triangle) DrawColorOver

func (t Triangle) DrawColorOver(dst draw.Image, c color.Color) (drawCount int)

DrawColorOver draws the triangle over dst using the given color.

func (Triangle) DrawOver

func (t Triangle) DrawOver(dst draw.Image) (drawCount int)

DrawOver draws the first color in the triangle over dst.

func (Triangle) DrawWireframe

func (t Triangle) DrawWireframe(dst draw.Image, c color.Color) (drawCount int)

DrawWireframe draws the triangle as a wireframe on dst.

func (Triangle) EachPixel

func (t Triangle) EachPixel(tf TriangleFunc)

EachPixel calls the given TriangleFunc for each pixel in the triangle.

func (Triangle) Positions

func (t Triangle) Positions() (Vec, Vec, Vec)

Positions returns the three positions.

func (Triangle) Rect

func (t Triangle) Rect() Rect

Rect returns the triangle Rect.

type TriangleFunc

type TriangleFunc func(u Vec, t Triangle)

TriangleFunc is a function type that is called by Triangle.EachPixel

type Triangles

type Triangles interface {
	// Len returns the number of vertices. The number of triangles is the number of vertices
	// divided by 3.
	Len() int

	// SetLen resizes Triangles to len vertices. If Triangles B were obtained by calling Slice
	// method on Triangles A, the relationship between A and B is undefined after calling SetLen
	// on either one of them.
	SetLen(len int)

	// Slice returns a sub-Triangles of this Triangles, covering vertices in range [i, j).
	//
	// If Triangles B were obtained by calling Slice(4, 9) on Triangles A, then A and B must
	// share the same underlying data. Modifying B must change the contents of A in range
	// [4, 9). The vertex with index 0 at B is the vertex with index 4 in A, and so on.
	//
	// Returned Triangles must have the same underlying type.
	Slice(i, j int) Triangles

	// Update copies vertex properties from the supplied Triangles into this Triangles.
	//
	// Properties not supported by these Triangles should be ignored. Properties not supported by
	// the supplied Triangles should be left untouched.
	//
	// The two Triangles must have the same Len.
	Update(Triangles)

	// Copy creates an exact independent copy of this Triangles (with the same underlying type).
	Copy() Triangles
}

Triangles represents a list of vertices, where each three vertices form a triangle. (First, second and third is the first triangle, fourth, fifth and sixth is the second triangle, etc.)

type TrianglesColor

type TrianglesColor interface {
	Triangles
	Color(i int) color.NRGBA
}

TrianglesColor specifies Triangles with Color property.

type TrianglesData

type TrianglesData []Vertex

TrianglesData specifies a list of Triangles vertices with three common properties: TrianglesPosition, TrianglesColor and TrianglesPicture.

func MakeTrianglesData

func MakeTrianglesData(len int) *TrianglesData

MakeTrianglesData creates Vertexes of length len initialized with default property values.

Prefer this function to make(Vertexes, len), because make zeros them, while this function does the correct intialization.

func (*TrianglesData) Color

func (td *TrianglesData) Color(i int) color.NRGBA

Color returns the color property of i-th vertex.

func (*TrianglesData) Copy

func (td *TrianglesData) Copy() Triangles

Copy returns an exact independent copy of this Vertexes.

func (*TrianglesData) Len

func (td *TrianglesData) Len() int

Len returns the number of vertices in Vertexes.

func (*TrianglesData) Picture

func (td *TrianglesData) Picture(i int) (pic Vec, intensity float64)

Picture returns the picture property of i-th vertex.

func (*TrianglesData) Position

func (td *TrianglesData) Position(i int) Vec

Position returns the position property of i-th vertex.

func (*TrianglesData) SetLen

func (td *TrianglesData) SetLen(length int)

SetLen resizes Vertexes to len, while keeping the original content.

If len is greater than Vertexes's current length, the new data is filled with default values ((0, 0), white, (0, 0), 0).

func (*TrianglesData) Slice

func (td *TrianglesData) Slice(i, j int) Triangles

Slice returns a sub-Triangles of this TrianglesData.

func (*TrianglesData) Update

func (td *TrianglesData) Update(t Triangles)

Update copies vertex properties from the supplied Triangles into this Vertexes.

TrianglesPosition, TrianglesColor and TrianglesTexture are supported.

type TrianglesPicture

type TrianglesPicture interface {
	Triangles
	Picture(i int) (pic Vec, intensity float64)
}

TrianglesPicture specifies Triangles with Picture propery.

The first value returned from Picture method is Picture coordinates. The second one specifies the weight of the Picture. Value of 0 means, that Picture should be completely ignored, 1 means that is should be fully included and anything in between means anything in between.

type TrianglesPosition

type TrianglesPosition interface {
	Triangles
	Position(i int) Vec
}

TrianglesPosition specifies Triangles with Position property.

type Vec

type Vec struct {
	X, Y float64
}

Vec is a 2D vector type with X and Y coordinates.

Create vectors with the V constructor:

u := gfx.V(1, 2)
v := gfx.V(8, -3)

Use various methods to manipulate them:

  w := u.Add(v)
  fmt.Println(w)        // gfx.V(9, -1)
  fmt.Println(u.Sub(v)) // gfx.V(-7, 5)
  u = gfx.V(2, 3)
  v = gfx.V(8, 1)
  if u.X < 0 {
	     fmt.Println("this won't happen")
  }
  x := u.Unit().Dot(v.Unit())

func BoundsCenter

func BoundsCenter(ir image.Rectangle) Vec

BoundsCenter returns the vector in the center of an image.Rectangle

func Centroid

func Centroid(a, b, c Vec) Vec

Centroid returns the centroid O of three vectors.

Example
Dump(
	Centroid(V(1, 1), V(6, 1), V(3, 4)),
	Centroid(V(0, 0), V(10, 0), V(5, 10)),
)
Output:

gfx.V(3.3333333333333335, 2)
gfx.V(5, 3.3333333333333335)

func CubicBezierCurve

func CubicBezierCurve(p0, p1, p2, p3 Vec, inc float64) []Vec

CubicBezierCurve returns a slice of vectors representing a cubic bezier curve

func IV

func IV(x, y int) Vec

IV returns a new 2d vector based on the given int x, y pair.

func PV

func PV(p image.Point) Vec

PV returns a new 2D vector based on the given image.Point.

func Unit

func Unit(angle float64) Vec

Unit returns a vector of length 1 facing the given angle.

func V

func V(x, y float64) Vec

V returns a new 2D vector with the given coordinates.

func (Vec) Abs

func (u Vec) Abs() Vec

Abs returns the absolute vector of the vector u.

func (Vec) Add

func (u Vec) Add(v Vec) Vec

Add returns the sum of vectors u and v.

func (Vec) AddXY

func (u Vec) AddXY(x, y float64) Vec

AddXY returns the sum of x and y added to v.

func (Vec) Angle

func (u Vec) Angle() float64

Angle returns the angle between the vector u and the x-axis. The result is in range [-Pi, Pi].

func (Vec) B

func (u Vec) B(v Vec) image.Rectangle

B creates a new image.Rectangle for the vectors u and v.

func (Vec) Bounds

func (u Vec) Bounds(l, t, r, b float64) image.Rectangle

Bounds returns the bounds around the vector based on the provided Left, Top, Right, Bottom values.

func (Vec) Cross

func (u Vec) Cross(v Vec) float64

Cross return the cross product of vectors u and v.

func (Vec) Dot

func (u Vec) Dot(v Vec) float64

Dot returns the dot product of vectors u and v.

func (Vec) Eq

func (u Vec) Eq(v Vec) bool

Eq checks the equality of two vectors.

func (Vec) In

func (u Vec) In(p Polygon) bool

In returns true if the vector is inside the given polygon.

func (Vec) Len

func (u Vec) Len() float64

Len returns the length of the vector u.

func (Vec) Lerp

func (u Vec) Lerp(v Vec, t float64) Vec

Lerp returns a linear interpolation between vectors u and v.

This function basically returns a point along the line between a and b and t chooses which one. If t is 0, then a will be returned, if t is 1, b will be returned. Anything between 0 and 1 will return the appropriate point between a and b and so on.

func (Vec) Map

func (u Vec) Map(f func(float64) float64) Vec

Map applies the function f to both x and y components of the vector u and returns the modified vector.

u := gfx.V(10.5, -1.5)
v := u.Map(math.Floor)   // v is gfx.V(10, -2), both components of u floored

func (Vec) Max

func (u Vec) Max(v Vec) Vec

Max returns the maximum vector of u and v.

func (Vec) Min

func (u Vec) Min(v Vec) Vec

Min returns the minimum vector of u and v.

func (Vec) Mod

func (u Vec) Mod(v Vec) Vec

Mod returns the floating-point remainder vector of x and y.

func (Vec) Normal

func (u Vec) Normal() Vec

Normal returns a vector normal to u. Equivalent to u.Rotated(math.Pi / 2), but faster.

func (Vec) Project

func (u Vec) Project(v Vec) Vec

Project returns a projection (or component) of vector u in the direction of vector v.

Behaviour is undefined if v is a zero vector.

func (Vec) Pt

func (u Vec) Pt() image.Point

Pt returns the image.Point for the vector.

func (Vec) R

func (u Vec) R(v Vec) Rect

R creates a new Rect for the vectors u and v.

Note that the returned rectangle is not automatically normalized.

func (Vec) Rect

func (u Vec) Rect(l, t, r, b float64) Rect

Rect constructs a Rect around the vector based on the provided Left, Top, Right, Bottom values.

func (Vec) Rotated

func (u Vec) Rotated(angle float64) Vec

Rotated returns the vector u rotated by the given angle in radians.

func (Vec) Scaled

func (u Vec) Scaled(c float64) Vec

Scaled returns the vector u multiplied by c.

func (Vec) ScaledXY

func (u Vec) ScaledXY(v Vec) Vec

ScaledXY returns the vector u multiplied by the vector v component-wise.

func (Vec) String

func (u Vec) String() string

String returns the string representation of the vector u.

u := gfx.V(4.5, -1.3)
u.String()     // returns "gfx.V(4.5, -1.3)"
fmt.Println(u) // gfx.V(4.5, -1.3)

func (Vec) Sub

func (u Vec) Sub(v Vec) Vec

Sub returns the difference betweeen vectors u and v.

func (Vec) To

func (u Vec) To(v Vec) Vec

To returns the vector from u to v. Equivalent to v.Sub(u).

func (Vec) Unit

func (u Vec) Unit() Vec

Unit returns a vector of length 1 facing the direction of u (has the same angle).

func (Vec) Vec3

func (u Vec) Vec3(z float64) Vec3

Vec3 converts the vector into a Vec3.

func (Vec) XY

func (u Vec) XY() (x, y float64)

XY returns the components of the vector in two return values.

type Vec3

type Vec3 struct {
	X, Y, Z float64
}

Vec3 is a 3D vector type with X, Y and Z coordinates.

Create vectors with the V3 constructor:

u := gfx.V3(1, 2, 3)
v := gfx.V3(8, -3, 4)

func BoundsCenterOrigin

func BoundsCenterOrigin(ir image.Rectangle, v Vec, z float64) Vec3

BoundsCenterOrigin returns the center origin for the given image.Rectangle and z value.

func IV3

func IV3(x, y, z int) Vec3

IV3 returns a new 3D vector based on the given int x, y, z values.

func V3

func V3(x, y, z float64) Vec3

V3 is shorthand for Vec3{X: x, Y: y, Z: z}.

func (Vec3) Add

func (u Vec3) Add(v Vec3) Vec3

Add returns the sum of vectors u and v.

func (Vec3) AddXYZ

func (u Vec3) AddXYZ(x, y, z float64) Vec3

AddXYZ returns the sum of x, y and z added to u.

func (Vec3) Dist

func (u Vec3) Dist(v Vec3) float64

Dist returns the euclidian distance between two vectors.

func (Vec3) Div

func (u Vec3) Div(s float64) Vec3

Div returns the vector v/s.

func (Vec3) Dot

func (u Vec3) Dot(v Vec3) float64

Dot returns the dot product of vectors u and v.

func (Vec3) Eq

func (u Vec3) Eq(v Vec3) bool

Eq checks the equality of two vectors.

func (Vec3) Len

func (u Vec3) Len() float64

Len returns the length (euclidian norm) of a vector.

func (Vec3) Lerp

func (u Vec3) Lerp(v Vec3, t float64) Vec3

Lerp returns the linear interpolation between v and w by amount t. The amount t is usually a value between 0 and 1. If t=0 v will be returned; if t=1 w will be returned.

func (Vec3) Map

func (u Vec3) Map(f func(float64) float64) Vec3

Map applies the function f to the x, y and z components of the vector u and returns the modified vector.

func (Vec3) Scaled

func (u Vec3) Scaled(s float64) Vec3

Scaled returns the vector u multiplied by c.

func (Vec3) ScaledXYZ

func (u Vec3) ScaledXYZ(v Vec3) Vec3

ScaledXYZ returns the component-wise multiplication of two vectors.

func (Vec3) SqDist

func (u Vec3) SqDist(v Vec3) float64

SqDist returns the square of the euclidian distance between two vectors.

func (Vec3) SqLen

func (u Vec3) SqLen() float64

SqLen returns the square of the length (euclidian norm) of a vector.

func (Vec3) String

func (u Vec3) String() string

String returns the string representation of the vector u.

func (Vec3) Sub

func (u Vec3) Sub(v Vec3) Vec3

Sub returns the difference betweeen vectors u and v.

func (Vec3) Unit

func (u Vec3) Unit() Vec3

Unit returns the normalized vector of a vector.

func (Vec3) Vec

func (u Vec3) Vec() Vec

Vec returns a Vec with X, Y coordinates.

func (Vec3) XYZ

func (u Vec3) XYZ() (x, y, z float64)

XYZ returns the components of the vector in three return values.

type Vertex

type Vertex struct {
	Position  Vec
	Color     color.NRGBA
	Picture   Vec
	Intensity float64
}

Vertex holds Position, Color, Picture and Intensity.

func NewVertex

func NewVertex(pos Vec, args ...interface{}) Vertex

NewVertex returns a new vertex with the given position.

func Vx

func Vx(pos Vec, args ...interface{}) Vertex

Vx returns a new vertex with the given coordinates.

Example
vx := Vx(V(6, 122), ColorWhite, V(1, 1), 0.5)

Dump(vx)
Output:

{Position:gfx.V(6, 122) Color:{R:255 G:255 B:255 A:255} Picture:gfx.V(1, 1) Intensity:0.5}

type XYZ

type XYZ struct {
	X float64
	Y float64
	Z float64
}

XYZ color space.

func ColorToXYZ

func ColorToXYZ(c color.Color) XYZ

ColorToXYZ converts a color into XYZ.

R, G and B (Standard RGB) input range = 0 ÷ 255 X, Y and Z output refer to a D65/2° standard illuminant.

func (XYZ) CIELab

func (xyz XYZ) CIELab(ref XYZ) CIELab

CIELab converts from XYZ to CIE-L*ab.

Reference-X, Y and Z refer to specific illuminants and observers. Common reference values are available below in this same page.

var_X = X / Reference-X var_Y = Y / Reference-Y var_Z = Z / Reference-Z

if ( var_X > 0.008856 ) var_X = var_X ^ ( 1/3 ) else var_X = ( 7.787 * var_X ) + ( 16 / 116 ) if ( var_Y > 0.008856 ) var_Y = var_Y ^ ( 1/3 ) else var_Y = ( 7.787 * var_Y ) + ( 16 / 116 ) if ( var_Z > 0.008856 ) var_Z = var_Z ^ ( 1/3 ) else var_Z = ( 7.787 * var_Z ) + ( 16 / 116 )

CIE-L* = ( 116 * var_Y ) - 16 CIE-a* = 500 * ( var_X - var_Y ) CIE-b* = 200 * ( var_Y - var_Z )

func (XYZ) HunterLab

func (xyz XYZ) HunterLab(ref XYZ) HunterLab

HunterLab converts from XYZ to HunterLab.

Reference-X, Y and Z refer to specific illuminants and observers. Common reference values are available below in this same page.

var_Ka = ( 175.0 / 198.04 ) * ( Reference-Y + Reference-X ) var_Kb = ( 70.0 / 218.11 ) * ( Reference-Y + Reference-Z )

Hunter-L = 100.0 * sqrt( Y / Reference-Y ) Hunter-a = var_Ka * ( ( ( X / Reference-X ) - ( Y / Reference-Y ) ) / sqrt( Y / Reference-Y ) ) Hunter-b = var_Kb * ( ( ( Y / Reference-Y ) - ( Z / Reference-Z ) ) / sqrt( Y / Reference-Y ) )

type XYZReference

type XYZReference struct {
	A   XYZ // Incandescent/tungsten
	B   XYZ // Old direct sunlight at noon
	C   XYZ // Old daylight
	D50 XYZ // ICC profile PCS
	D55 XYZ // Mid-morning daylight
	D65 XYZ // Daylight, sRGB, Adobe-RGB
	D75 XYZ // North sky daylight
	E   XYZ // Equal energy
	F1  XYZ // Daylight Fluorescent
	F2  XYZ // Cool fluorescent
	F3  XYZ // White Fluorescent
	F4  XYZ // Warm White Fluorescent
	F5  XYZ // Daylight Fluorescent
	F6  XYZ // Lite White Fluorescent
	F7  XYZ // Daylight fluorescent, D65 simulator
	F8  XYZ // Sylvania F40, D50 simulator
	F9  XYZ // Cool White Fluorescent
	F10 XYZ // Ultralume 50, Philips TL85
	F11 XYZ // Ultralume 40, Philips TL84
	F12 XYZ // Ultralume 30, Philips TL83
}

XYZReference values of a perfect reflecting diffuser.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL