color.NRGBA -> color.RGBA

Author: peterhellberg

README.md

@@ -297,7 +297,7 @@ func main() {
 
 ## Colors
 
-You can construct new colors using `gfx.ColorNRGBA` and `gfx.ColorWithAlpha`.
+You can construct new colors using `gfx.ColorRGBA` and `gfx.ColorWithAlpha`.
 
 ### Default colors
 

colors.go

@@ -4,8 +4,8 @@ import "image/color"
 
 // Standard colors transparent, opaque, black, white, red, green, blue, cyan, magenta, and yellow.
 var (
-	ColorTransparent = ColorNRGBA(0, 0, 0, 0)
-	ColorOpaque      = ColorNRGBA(0xFF, 0xFF, 0xFF, 0xFF)
+	ColorTransparent = ColorRGBA(0, 0, 0, 0)
+	ColorOpaque      = ColorRGBA(0xFF, 0xFF, 0xFF, 0xFF)
 	ColorBlack       = Palette1Bit.Color(0)
 	ColorWhite       = Palette1Bit.Color(1)
 	ColorRed         = Palette3Bit.Color(1)
@@ -16,7 +16,7 @@ var (
 	ColorYellow      = Palette3Bit.Color(6)
 
 	// ColorByName is a map of all the default colors by name.
-	ColorByName = map[string]color.NRGBA{
+	ColorByName = map[string]color.RGBA{
 		"Transparent": ColorTransparent,
 		"Opaque":      ColorOpaque,
 		"Black":       ColorBlack,
@@ -32,9 +32,9 @@ var (
 
 // BlockColor contains a Light, Medium and Dark color.
 type BlockColor struct {
-	Light  color.NRGBA
-	Medium color.NRGBA
-	Dark   color.NRGBA
+	Light  color.RGBA
+	Medium color.RGBA
+	Dark   color.RGBA
 }
 
 // Block colors, each containing a Light, Medium and Dark color.
@@ -104,26 +104,26 @@ var (
 	}
 )
 
-// ColorWithAlpha creates a new color.NRGBA based
+// ColorWithAlpha creates a new color.RGBA based
 // on the provided color.Color and alpha arguments.
-func ColorWithAlpha(c color.Color, a uint8) color.NRGBA {
-	nc := color.NRGBAModel.Convert(c).(color.NRGBA)
+func ColorWithAlpha(c color.Color, a uint8) color.RGBA {
+	nc := color.RGBAModel.Convert(c).(color.RGBA)
 
 	nc.A = a
 
 	return nc
 }
 
-// ColorNRGBA constructs a color.NRGBA.
-func ColorNRGBA(r, g, b, a uint8) color.NRGBA {
-	return color.NRGBA{r, g, b, a}
-}
-
 // ColorRGBA constructs a color.RGBA.
 func ColorRGBA(r, g, b, a uint8) color.RGBA {
 	return color.RGBA{r, g, b, a}
 }
 
+// ColorNRGBA constructs a color.NRGBA.
+func ColorNRGBA(r, g, b, a uint8) color.NRGBA {
+	return color.NRGBA{r, g, b, a}
+}
+
 // LerpColors performs linear interpolation between two colors.
 func LerpColors(c0, c1 color.Color, t float64) color.Color {
 	switch {

colors_test.go

@@ -6,7 +6,7 @@ import (
 )
 
 func TestColorWithAlpha(t *testing.T) {
-	c := ColorWithAlpha(ColorNRGBA(255, 0, 0, 255), 128)
+	c := ColorWithAlpha(ColorRGBA(255, 0, 0, 255), 128)
 
 	if got, want := c.A, uint8(128); got != want {
 		t.Fatalf("c.A = %d, want %d", got, want)

doc.go

@@ -220,7 +220,7 @@ There is rudimentary support for making animations using gfx.Animation, the anim
 
 Colors
 
-You can construct new colors using gfx.ColorNRGBA and gfx.ColorWithAlpha.
+You can construct new colors using gfx.ColorRGBA and gfx.ColorWithAlpha.
 
 Default colors
 

draw_test.go

@@ -5,15 +5,15 @@ import "testing"
 func TestDrawOver(t *testing.T) {
 	src := NewImage(3, 3)
 
-	src.SetNRGBA(1, 1, ColorNRGBA(75, 0, 130, 64))
+	src.SetRGBA(1, 1, ColorRGBA(75, 0, 130, 64))
 
 	dst := NewImage(3, 3, ColorMagenta)
 
 	DrawOver(dst, dst.Bounds(), src, ZP)
 }
 
 func TestDrawSrc(t *testing.T) {
-	src := NewImage(3, 3, ColorNRGBA(0, 255, 0, 64))
+	src := NewImage(3, 3, ColorRGBA(0, 255, 0, 64))
 	dst := NewImage(3, 3, ColorMagenta)
 
 	DrawSrc(dst, dst.Bounds(), src, ZP)

image.go

@@ -13,8 +13,8 @@ import (
 var ZP = image.ZP
 
 // NewImage creates an image of the given size (optionally filled with a color)
-func NewImage(w, h int, colors ...color.Color) *image.NRGBA {
-	m := NewNRGBA(IR(0, 0, w, h))
+func NewImage(w, h int, colors ...color.Color) *image.RGBA {
+	m := NewRGBA(IR(0, 0, w, h))
 
 	if len(colors) > 0 {
 		DrawColor(m, m.Bounds(), colors[0])

imdraw.go

@@ -59,7 +59,7 @@ var _ BasicTarget = (*IMDraw)(nil)
 
 type point struct {
 	pos       Vec
-	col       color.NRGBA
+	col       color.RGBA
 	pic       Vec
 	in        float64
 	precision int
@@ -123,7 +123,7 @@ func (imd *IMDraw) Draw(t Target) {
 // the position.
 func (imd *IMDraw) Push(pts ...Vec) {
 	opts := point{
-		col:       imd.Color.(color.NRGBA),
+		col:       imd.Color.(color.RGBA),
 		pic:       imd.Picture,
 		in:        imd.Intensity,
 		precision: imd.Precision,
@@ -317,7 +317,7 @@ func (imd *IMDraw) outlineRectangle(thickness float64) {
 	for i := 0; i+1 < len(points); i++ {
 		a, b := points[i], points[i+1]
 		mid := a
-		mid.col = mixNRGBA(a.col, b.col)
+		mid.col = mixRGBA(a.col, b.col)
 		mid.in = (a.in + b.in) / 2
 
 		imd.pushPt(a.pos, a)
@@ -613,8 +613,8 @@ func (imd *IMDraw) polyline(thickness float64, closed bool) {
 	imd.restorePoints(points)
 }
 
-func mixNRGBA(c1, c2 color.NRGBA) color.NRGBA {
-	return color.NRGBA{
+func mixRGBA(c1, c2 color.RGBA) color.RGBA {
+	return color.RGBA{
 		c1.R/2 + c2.R/2,
 		c1.G/2 + c2.G/2,
 		c1.B/2 + c2.B/2,

interfaces.go

@@ -85,7 +85,7 @@ type TrianglesPosition interface {
 // TrianglesColor specifies Triangles with Color property.
 type TrianglesColor interface {
 	Triangles
-	Color(i int) color.NRGBA
+	Color(i int) color.RGBA
 }
 
 // TrianglesPicture specifies Triangles with Picture propery.
@@ -125,7 +125,7 @@ type TargetPicture interface {
 // Positions outside the Picture's Bounds must return full transparent (Alpha(0)).
 type PictureColor interface {
 	Picture
-	Color(at Vec) color.NRGBA
+	Color(at Vec) color.RGBA
 }
 
 // Float64Scaler can scale a float64 to another float64.

layer.go

@@ -43,15 +43,15 @@ func NewLayer(tileset *Tileset, width int, data LayerData) *Layer {
 
 // At returns the color at (x, y).
 func (l *Layer) At(x, y int) color.Color {
-	return l.NRGBAAt(x, y)
+	return l.RGBAAt(x, y)
 }
 
-// NRGBAAt returns the color.NRGBA at (x, y).
-func (l *Layer) NRGBAAt(x, y int) color.NRGBA {
+// RGBAAt returns the color.RGBA at (x, y).
+func (l *Layer) RGBAAt(x, y int) color.RGBA {
 	if i := l.TileIndexAt(x, y); i > -1 {
 		s := l.Tileset.Size
 
-		return l.Tileset.Tiles[i].NRGBAAt(x%s.X, y%s.Y)
+		return l.Tileset.Tiles[i].RGBAAt(x%s.X, y%s.Y)
 	}
 
 	return ColorTransparent
@@ -90,7 +90,7 @@ func (l *Layer) Bounds() image.Rectangle {
 
 // ColorModel returns the color model for the paletted layer.
 func (l *Layer) ColorModel() color.Model {
-	return color.NRGBAModel
+	return color.RGBAModel
 }
 
 // ColorIndexAt returns the palette index of the pixel at (x, y).

layer_test.go

@@ -57,15 +57,15 @@ func TestLayerAt(t *testing.T) {
 	}
 }
 
-func TestLayerNRGBAAt(t *testing.T) {
+func TestLayerRGBAAt(t *testing.T) {
 	l := newTestLayer()
 
-	if got, want := l.NRGBAAt(-1, 100), ColorTransparent; got != want {
-		t.Fatalf("l.NRGBAAt(-1, 100) = %v, want %v", got, want)
+	if got, want := l.RGBAAt(-1, 100), ColorTransparent; got != want {
+		t.Fatalf("l.RGBAAt(-1, 100) = %v, want %v", got, want)
 	}
 
-	if got, want := l.NRGBAAt(2, 2), ColorNRGBA(66, 110, 93, 255); got != want {
-		t.Fatalf("l.NRGBAAt(2, 2) = %v, want %v", got, want)
+	if got, want := l.RGBAAt(2, 2), ColorRGBA(66, 110, 93, 255); got != want {
+		t.Fatalf("l.RGBAAt(2, 2) = %v, want %v", got, want)
 	}
 }
 
@@ -98,7 +98,7 @@ func TestLayerBounds(t *testing.T) {
 func TestLayerColorModel(t *testing.T) {
 	l := newTestLayer()
 
-	if l.ColorModel() != color.NRGBAModel {
+	if l.ColorModel() != color.RGBAModel {
 		t.Fatalf("unexpected color model")
 	}
 }