color

Documentation

Overview

Package color provides types and functions to manipulate colors.

The types defined here are compatible with the standard library package "image/color", but are designed to work well with the GPU.

The first difference with the standard library is that most of them are based on float32 (instead of uint32), so they can be directly passed to GPU shaders.

The second difference is that they make an explicit distinction between linear and standard (sRGB) color spaces, while the standard library only makes distinction between alpha-premultiplied and alpha-postmultiplied. Both distinction are equally important for correct color handling.

Linear and sRGB

Structs prefixed by "L" are in linear color space, while structs prefixed by "S" are in standard (sRGB) color space.

For the importance of this distinction, see:

http://blog.johnnovak.net/2016/09/21/what-every-coder-should-know-about-gamma/

Alpha Pre-Multipled and Post-Multiplied

Structs ending with "nA" are alpha post-multplied; all others are alpha pre-multiplied.

In an alpha-premultiplied color, the three RGB component have been scaled by alpha; valid values are therefore within [0, alpha]. This is the most useful choice for alpha-blending.

For the importance of alpha pre-multipled, see:

https://blogs.msdn.microsoft.com/shawnhar/2009/11/06/premultiplied-alpha/

Index

• type Color
• type Index
• type LRGB
  • func LRGBof(c Color) LRGB
  • func (c LRGB) Linear() (r, g, b, a float32)
  • func (c LRGB) RGBA() (r, g, b, a uint32)
  • func (c LRGB) Standard() (r, g, b, a float32)
• type LRGBA
  • func LRGBAof(c Color) LRGBA
  • func (c LRGBA) Linear() (r, g, b, a float32)
  • func (c LRGBA) RGBA() (r, g, b, a uint32)
  • func (c LRGBA) Standard() (r, g, b, a float32)
• type LRGBnA
  • func LRGBnAof(c Color) LRGBnA
  • func (c LRGBnA) Linear() (r, g, b, a float32)
  • func (c LRGBnA) RGBA() (r, g, b, a uint32)
  • func (c LRGBnA) Standard() (r, g, b, a float32)
• type Palette
  • func PaletteFrom(path string) Palette
• type SRGB
  • func SRGBof(c Color) SRGB
  • func (c SRGB) Linear() (r, g, b, a float32)
  • func (c SRGB) RGBA() (r, g, b, a uint32)
  • func (c SRGB) Standard() (r, g, b, a float32)
• type SRGB8
  • func SRGB8of(c Color) SRGB8
  • func (c SRGB8) Linear() (r, g, b, a float32)
  • func (c SRGB8) RGBA() (r, g, b, a uint32)
  • func (c SRGB8) Standard() (r, g, b, a float32)
• type SRGBA
  • func SRGBAof(c Color) SRGBA
  • func (c SRGBA) Linear() (r, g, b, a float32)
  • func (c SRGBA) RGBA() (r, g, b, a uint32)
  • func (c SRGBA) Standard() (r, g, b, a float32)
• type SRGBA8
  • func SRGBA8of(c Color) SRGBA8
  • func (c SRGBA8) Linear() (r, g, b, a float32)
  • func (c SRGBA8) RGBA() (r, g, b, a uint32)
  • func (c SRGBA8) Standard() (r, g, b, a float32)
• type SRGBnA
  • func SRGBnAof(c Color) SRGBnA
  • func (c SRGBnA) Linear() (r, g, b, a float32)
  • func (c SRGBnA) RGBA() (r, g, b, a uint32)
  • func (c SRGBnA) Standard() (r, g, b, a float32)
• type SRGBnA8
  • func SRGBnA8of(c Color) SRGBnA8
  • func (c SRGBnA8) Linear() (r, g, b, a float32)
  • func (c SRGBnA8) RGBA() (r, g, b, a uint32)
  • func (c SRGBnA8) Standard() (r, g, b, a float32)

Types

type Color

type Color interface {
	// Linear returns the red, green, blue and alpha values in linear color space.
	// The red, gren and blue values have been alpha-premultiplied in linear
	// space. Each value ranges within [0, 1] and can be used directly by GPU
	// shaders.
	Linear() (r, g, b, a float32)

	// Standard returns the red, green, blue and alpha values in standard (sRGB)
	// color space. The red, gren and blue values have been alpha-premultiplied in
	// linear space. Each value ranges within [0, 1].
	Standard() (r, g, b, a float32)
}

Color can convert itself to alpha-premultipled RGBA as 32 bit floats, in both linear and standard (sRGB) color spaces.

type Index

type Index uint8

An Index is used to refer to colors inside a palette.

type LRGB

type LRGB struct {
	R float32
	G float32
	B float32
}

LRGB represents a color in linear color space. Each value ranges within [0, 1], and can be used directly by GPU shaders.

func LRGBof

func LRGBof(c Color) LRGB

LRGBof converts any color to linear color space with no alpha.

func (LRGB) Linear

func (c LRGB) Linear() (r, g, b, a float32)

Linear implements the Colour interface.

func (LRGB) RGBA

func (c LRGB) RGBA() (r, g, b, a uint32)

RGBA implements the image.Color interface: it returns the four components scaled by 0xFFFF.

func (LRGB) Standard

func (c LRGB) Standard() (r, g, b, a float32)

Standard implements the Colour interface.

type LRGBA

type LRGBA struct {
	R float32
	G float32
	B float32
	A float32
}

LRGBA represents a color in alpha-premultiplied linear color space. Each value ranges within [0, 1], and can be used directly by GPU shaders.

An alpha-premultiplied color component c has been scaled by alpha (a), so has valid values 0 <= c <= a.

Note that additive blending can also be achieved when alpha is set to 0 while the color components are non-null.

func LRGBAof

func LRGBAof(c Color) LRGBA

LRGBAof converts any color to alpha-premultiplied, linear color space.

func (LRGBA) Linear

func (c LRGBA) Linear() (r, g, b, a float32)

Linear implements the Colour interface.

func (LRGBA) RGBA

func (c LRGBA) RGBA() (r, g, b, a uint32)

RGBA implements the image.Color interface: it returns the four components scaled by 0xFFFF.

func (LRGBA) Standard

func (c LRGBA) Standard() (r, g, b, a float32)

Standard implements the Colour interface.

type LRGBnA

type LRGBnA struct {
	R float32
	G float32
	B float32
	A float32
}

LRGBnA represents a color in *non* alpha-premultiplied linear color space. Each value ranges within [0, 1], and can be used directly by GPU shaders.

Note: prefer RGBA for use in shaders.

func LRGBnAof

func LRGBnAof(c Color) LRGBnA

LRGBnAof converts any color to non alpha-premultiplied linear color space.

func (LRGBnA) Linear

func (c LRGBnA) Linear() (r, g, b, a float32)

Linear implements the Colour interface.

func (LRGBnA) RGBA

func (c LRGBnA) RGBA() (r, g, b, a uint32)

RGBA implements the image.Color interface: it returns the four components scaled by 0xFFFF.

func (LRGBnA) Standard

func (c LRGBnA) Standard() (r, g, b, a float32)

Standard implements the Colour interface.

type Palette

type Palette struct {
	ByName map[string]Index
	Colors []LRGBA
}

A Palette is an ordered list of colors (defined by their LRGBA values), and a name-to-index dictionary.

func PaletteFrom

func PaletteFrom(path string) Palette

PaletteFrom returns a new Palette created from the file at the specified path.

type SRGB

type SRGB struct {
	R float32
	G float32
	B float32
}

SRGB represents a color in sRGB color space. Each value ranges within [0, 1], and can be used directly by GPU shaders.

func SRGBof

func SRGBof(c Color) SRGB

SRGBof converts any color to sRGB color space with no alpha.

func (SRGB) Linear

func (c SRGB) Linear() (r, g, b, a float32)

Linear implements the Colour interface.

func (SRGB) RGBA

func (c SRGB) RGBA() (r, g, b, a uint32)

RGBA implements the image.Color interface: it returns the four components scaled by 0xFFFF.

func (SRGB) Standard

func (c SRGB) Standard() (r, g, b, a float32)

Standard implements the Colour interface.

type SRGB8

type SRGB8 struct {
	R uint8
	G uint8
	B uint8
}

SRGB8 represents a 24-bit color in sRGB color space. There is 8 bits for each components.

func SRGB8of

func SRGB8of(c Color) SRGB8

SRGB8of converts any color to sRGB color space.

func (SRGB8) Linear

func (c SRGB8) Linear() (r, g, b, a float32)

Linear implements the Colour interface.

func (SRGB8) RGBA

func (c SRGB8) RGBA() (r, g, b, a uint32)

RGBA implements the image.Color interface.

func (SRGB8) Standard

func (c SRGB8) Standard() (r, g, b, a float32)

Standard implements the Colour interface.

type SRGBA

type SRGBA struct {
	R float32
	G float32
	B float32
	A float32
}

SRGBA represents a color in alpha-premultiplied sRGB color space. Each value ranges within [0, 1].

An alpha-premultiplied color component c has been scaled by alpha (a), so has valid values 0 <= c <= a.

Note that additive blending can also be achieved when alpha is set to 0 while the color components are non-null.

func SRGBAof

func SRGBAof(c Color) SRGBA

SRGBAof converts any color to sRGB alpha-premultiplied color space.

func (SRGBA) Linear

func (c SRGBA) Linear() (r, g, b, a float32)

Linear implements the Colour interface: it returns the color converted to linear color space.

func (SRGBA) RGBA

func (c SRGBA) RGBA() (r, g, b, a uint32)

RGBA implements the image.Color interface: it returns the four components scaled by 0xFFFF.

func (SRGBA) Standard

func (c SRGBA) Standard() (r, g, b, a float32)

Standard implements the Colour interface.

type SRGBA8

type SRGBA8 struct {
	R uint8
	G uint8
	B uint8
	A uint8
}

SRGBA8 represents a 32-bit color in alpha-premultiplied sRGB color space. There is 8 bits for each components.

An alpha-premultiplied color component c has been scaled by alpha (a), so has valid values 0 <= c <= a.

Note that additive blending can also be achieved when alpha is set to 0 while the color components are non-null.

func SRGBA8of

func SRGBA8of(c Color) SRGBA8

SRGBA8of converts any color to alpha-premultiplied sRGB color space.

func (SRGBA8) Linear

func (c SRGBA8) Linear() (r, g, b, a float32)

Linear implements the Colour interface.

func (SRGBA8) RGBA

func (c SRGBA8) RGBA() (r, g, b, a uint32)

RGBA implements the image.Color interface.

func (SRGBA8) Standard

func (c SRGBA8) Standard() (r, g, b, a float32)

Standard implements the Colour interface.

type SRGBnA

type SRGBnA struct {
	R float32
	G float32
	B float32
	A float32
}

SRGBnA represents a color in *non* alpha-premultiplied sRGB color space. Each value ranges within [0, 1].

An alpha-premultiplied color component c has been scaled by alpha (a), so has valid values 0 <= c <= a.

Note that additive blending can also be achieved when alpha is set to 0 while the color components are non-null.

func SRGBnAof

func SRGBnAof(c Color) SRGBnA

SRGBnAof converts any color to sRGB non alpha-premultiplied sRGB color space.

func (SRGBnA) Linear

func (c SRGBnA) Linear() (r, g, b, a float32)

Linear implements the Colour interface: it returns the color converted to alpha-premultipled linear color space.

func (SRGBnA) RGBA

func (c SRGBnA) RGBA() (r, g, b, a uint32)

RGBA implements the image.Color interface: it returns the four components scaled by 0xFFFF.

func (SRGBnA) Standard

func (c SRGBnA) Standard() (r, g, b, a float32)

Standard implements the Colour interface.

type SRGBnA8

type SRGBnA8 struct {
	R uint8
	G uint8
	B uint8
	A uint8
}

SRGBnA8 represents a 32-bit color in *non* alpha-premultiplied sRGB color space. There is 8 bits for each compnent.

func SRGBnA8of

func SRGBnA8of(c Color) SRGBnA8

SRGBnA8of converts any color to non alpha-premultiplied sRGB color space.

func (SRGBnA8) Linear

func (c SRGBnA8) Linear() (r, g, b, a float32)

Linear implements the Colour interface.

func (SRGBnA8) RGBA

func (c SRGBnA8) RGBA() (r, g, b, a uint32)

RGBA implements the image.Color interface: it returns the four components scaled by 0xFFFF.

func (SRGBnA8) Standard

func (c SRGBnA8) Standard() (r, g, b, a float32)

Standard implements the Colour interface.