all: fix typos (#2558)

Signed-off-by: Pierre Curto <pierre.curto@gmail.com>

audio/audio_test.go

@@ -64,7 +64,7 @@ func TestGC(t *testing.T) {
 			t.Error(err)
 		}
 		// 200[ms] should be enough all the bytes are consumed.
-		// TODO: This is a darty hack. Would it be possible to use virtual time?
+		// TODO: This is a dirty hack. Would it be possible to use virtual time?
 		time.Sleep(200 * time.Millisecond)
 	}
 	t.Errorf("time out")

audio/error_ios.go

@@ -32,7 +32,7 @@ import (
 	"fmt"
 )
 
-// addErrorInfoForContextCreation adds an additional infomation to the error when creating an audio context.
+// addErrorInfoForContextCreation adds an additional information to the error when creating an audio context.
 // See also hajimehoshi/oto#93.
 func addErrorInfoForContextCreation(err error) error {
 	if err == nil {

audio/internal/convert/resampling.go

@@ -113,7 +113,7 @@ func (r *Resampling) src(i int64) (float64, float64, error) {
 	if i < 0 {
 		return 0, 0, nil
 	}
-	if r.size/4 <= int64(i) {
+	if r.size/4 <= i {
 		return 0, 0, nil
 	}
 	nextPos := int64(i) / resamplingBufferSize

audio/wav/decode.go

@@ -102,7 +102,7 @@ func (s *stream) Seek(offset int64, whence int) (int64, error) {
 	return n - s.headerSize, nil
 }
 
-// DecodeWithSampleRate decodes WAV (RIFF) data to playable stream.
+// DecodeWithoutResampling decodes WAV (RIFF) data to playable stream.
 //
 // The format must be 1 or 2 channels, 8bit or 16bit little endian PCM.
 // The format is converted into 2 channels and 16bit.

blend.go

@@ -164,7 +164,7 @@ func (b BlendFactor) internalBlendFactor(source bool) graphicsdriver.BlendFactor
 	}
 }
 
-// BlendFactor is an operation for source and destination color values.
+// BlendOperation is an operation for source and destination color values.
 type BlendOperation byte
 
 const (

cmd/ebitenmobile/gomobile.go

@@ -147,7 +147,7 @@ import (
 		return tmp, err
 	}
 
-	// To record gomobile to go.sum for Go 1.16 and later, go-get gomobile instaed of golang.org/x/mobile (#1487).
+	// To record gomobile to go.sum for Go 1.16 and later, go-get gomobile instead of golang.org/x/mobile (#1487).
 	// This also records gobind as gomobile depends on gobind indirectly.
 	// Using `...` doesn't work on Windows since mobile/internal/mobileinit cannot be compiled on Windows w/o Cgo (#1493).
 	if err := runGo("get", "golang.org/x/mobile/cmd/gomobile@"+h); err != nil {

colorm/colorm.go

@@ -66,7 +66,7 @@ func (c *ColorM) Apply(clr color.Color) color.Color {
 }
 
 // Concat multiplies a color matrix with the other color matrix.
-// This is same as muptiplying the matrix other and the matrix c in this order.
+// This is same as multiplying the matrix other and the matrix c in this order.
 func (c *ColorM) Concat(other ColorM) {
 	o := other.impl
 	if o == nil {

colorm/colorm_test.go

@@ -195,32 +195,32 @@ func TestColorMApply(t *testing.T) {
 	}{
 		{
 			ColorM: colorm.ColorM{},
-			In:     color.RGBA{1, 2, 3, 4},
+			In:     color.RGBA{R: 1, G: 2, B: 3, A: 4},
-			Out:    color.RGBA{1, 2, 3, 4},
+			Out:    color.RGBA{R: 1, G: 2, B: 3, A: 4},
 			Delta:  0x101,
 		},
 		{
 			ColorM: mono,
-			In:     color.NRGBA{0xff, 0xff, 0xff, 0},
+			In:     color.NRGBA{R: 0xff, G: 0xff, B: 0xff},
 			Out:    color.Transparent,
 			Delta:  0x101,
 		},
 		{
 			ColorM: mono,
-			In:     color.RGBA{0xff, 0, 0, 0xff},
+			In:     color.RGBA{R: 0xff, A: 0xff},
-			Out:    color.RGBA{0x4c, 0x4c, 0x4c, 0xff},
+			Out:    color.RGBA{R: 0x4c, G: 0x4c, B: 0x4c, A: 0xff},
 			Delta:  0x101,
 		},
 		{
 			ColorM: shiny,
-			In:     color.RGBA{0x80, 0x90, 0xa0, 0xb0},
+			In:     color.RGBA{R: 0x80, G: 0x90, B: 0xa0, A: 0xb0},
-			Out:    color.RGBA{0xb0, 0xb0, 0xb0, 0xb0},
+			Out:    color.RGBA{R: 0xb0, G: 0xb0, B: 0xb0, A: 0xb0},
 			Delta:  1,
 		},
 		{
 			ColorM: shift,
-			In:     color.RGBA{0x00, 0x00, 0x00, 0x00},
+			In:     color.RGBA{},
-			Out:    color.RGBA{0x40, 0x40, 0x40, 0x80},
+			Out:    color.RGBA{R: 0x40, G: 0x40, B: 0x40, A: 0x80},
 			Delta:  0x101,
 		},
 	}

colorm/draw_test.go

@@ -190,7 +190,7 @@ func TestColorMAndScale(t *testing.T) {
 	const w, h = 16, 16
 	src := ebiten.NewImage(w, h)
 
-	src.Fill(color.RGBA{0x80, 0x80, 0x80, 0x80})
+	src.Fill(color.RGBA{R: 0x80, G: 0x80, B: 0x80, A: 0x80})
 	vs := []ebiten.Vertex{
 		{
 			SrcX:   0,
@@ -255,17 +255,17 @@ func TestColorMAndScale(t *testing.T) {
 			switch format {
 			case ebiten.ColorScaleModeStraightAlpha:
 				want = color.RGBA{
-					byte(math.Floor(0xff * (0.5/alphaBeforeScale + 0.25) * alphaBeforeScale * 0.5 * 0.75)),
+					R: byte(math.Floor(0xff * (0.5/alphaBeforeScale + 0.25) * alphaBeforeScale * 0.5 * 0.75)),
-					byte(math.Floor(0xff * (0.5/alphaBeforeScale + 0.25) * alphaBeforeScale * 0.25 * 0.75)),
+					G: byte(math.Floor(0xff * (0.5/alphaBeforeScale + 0.25) * alphaBeforeScale * 0.25 * 0.75)),
-					byte(math.Floor(0xff * (0.5/alphaBeforeScale + 0.25) * alphaBeforeScale * 0.5 * 0.75)),
+					B: byte(math.Floor(0xff * (0.5/alphaBeforeScale + 0.25) * alphaBeforeScale * 0.5 * 0.75)),
-					byte(math.Floor(0xff * alphaBeforeScale * 0.75)),
+					A: byte(math.Floor(0xff * alphaBeforeScale * 0.75)),
 				}
 			case ebiten.ColorScaleModePremultipliedAlpha:
 				want = color.RGBA{
-					byte(math.Floor(0xff * (0.5/alphaBeforeScale + 0.25) * alphaBeforeScale * 0.5)),
+					R: byte(math.Floor(0xff * (0.5/alphaBeforeScale + 0.25) * alphaBeforeScale * 0.5)),
-					byte(math.Floor(0xff * (0.5/alphaBeforeScale + 0.25) * alphaBeforeScale * 0.25)),
+					G: byte(math.Floor(0xff * (0.5/alphaBeforeScale + 0.25) * alphaBeforeScale * 0.25)),
-					byte(math.Floor(0xff * (0.5/alphaBeforeScale + 0.25) * alphaBeforeScale * 0.5)),
+					B: byte(math.Floor(0xff * (0.5/alphaBeforeScale + 0.25) * alphaBeforeScale * 0.5)),
-					byte(math.Floor(0xff * alphaBeforeScale * 0.75)),
+					A: byte(math.Floor(0xff * alphaBeforeScale * 0.75)),
 				}
 			}
 			if !sameColors(got, want, 2) {
@@ -291,7 +291,7 @@ func TestColorMCopy(t *testing.T) {
 		for j := 0; j < h; j++ {
 			for i := 0; i < w; i++ {
 				got := dst.At(i, j).(color.RGBA)
-				want := color.RGBA{byte(k), byte(k), byte(k), byte(k)}
+				want := color.RGBA{R: byte(k), G: byte(k), B: byte(k), A: byte(k)}
 				if !sameColors(got, want, 1) {
 					t.Fatalf("dst.At(%d, %d), k: %d: got %v, want %v", i, j, k, got, want)
 				}

colorscale.go

@@ -29,7 +29,7 @@ type ColorScale struct {
 	r_1, g_1, b_1, a_1 float32
 }
 
-// String returns a string represeting the color scale.
+// String returns a string representing the color scale.
 func (c *ColorScale) String() string {
 	return fmt.Sprintf("(%f,%f,%f,%f)", c.r_1+1, c.g_1+1, c.b_1+1, c.a_1+1)
 }

cursor.go

@@ -23,9 +23,9 @@ type CursorModeType = ui.CursorMode
 
 // CursorModeTypes
 const (
-	CursorModeVisible  CursorModeType = CursorModeType(ui.CursorModeVisible)
+	CursorModeVisible  CursorModeType = ui.CursorModeVisible
-	CursorModeHidden   CursorModeType = CursorModeType(ui.CursorModeHidden)
+	CursorModeHidden   CursorModeType = ui.CursorModeHidden
-	CursorModeCaptured CursorModeType = CursorModeType(ui.CursorModeCaptured)
+	CursorModeCaptured CursorModeType = ui.CursorModeCaptured
 )
 
 // CursorShapeType represents a shape of a mouse cursor.
@@ -33,10 +33,10 @@ type CursorShapeType = ui.CursorShape
 
 // CursorShapeTypes
 const (
-	CursorShapeDefault   CursorShapeType = CursorShapeType(ui.CursorShapeDefault)
+	CursorShapeDefault   CursorShapeType = ui.CursorShapeDefault
-	CursorShapeText      CursorShapeType = CursorShapeType(ui.CursorShapeText)
+	CursorShapeText      CursorShapeType = ui.CursorShapeText
-	CursorShapeCrosshair CursorShapeType = CursorShapeType(ui.CursorShapeCrosshair)
+	CursorShapeCrosshair CursorShapeType = ui.CursorShapeCrosshair
-	CursorShapePointer   CursorShapeType = CursorShapeType(ui.CursorShapePointer)
+	CursorShapePointer   CursorShapeType = ui.CursorShapePointer
-	CursorShapeEWResize  CursorShapeType = CursorShapeType(ui.CursorShapeEWResize)
+	CursorShapeEWResize  CursorShapeType = ui.CursorShapeEWResize
-	CursorShapeNSResize  CursorShapeType = CursorShapeType(ui.CursorShapeNSResize)
+	CursorShapeNSResize  CursorShapeType = ui.CursorShapeNSResize
 )

genevents.go

@@ -113,7 +113,7 @@ var (
 			Type:    "float32",
 		},
 		{
-			Comment: "Deltay is the change in Y since last touch event. This value is expressed in device independent pixels.",
+			Comment: "DeltaY is the change in Y since last touch event. This value is expressed in device independent pixels.",
 			Type:    "float32",
 		},
 		{

genkeys.go

@@ -403,7 +403,7 @@ import (
 )
 
 // A Key represents a keyboard key.
-// These keys represent pysical keys of US keyboard.
+// These keys represent physical keys of US keyboard.
 // For example, KeyQ represents Q key on US keyboards and ' (quote) key on Dvorak keyboards.
 type Key int
 

graphics.go

@@ -21,7 +21,7 @@ import (
 	"github.com/hajimehoshi/ebiten/v2/internal/ui"
 )
 
-// Filter represents the type of texture filter to be used when an image is maginified or minified.
+// Filter represents the type of texture filter to be used when an image is magnified or minified.
 type Filter int
 
 const (
@@ -126,7 +126,7 @@ func (c CompositeMode) blend() Blend {
 	}
 }
 
-// GraphicsLibrary represets graphics libraries supported by the engine.
+// GraphicsLibrary represents graphics libraries supported by the engine.
 type GraphicsLibrary int
 
 const (

image.go

@@ -279,7 +279,7 @@ type Vertex struct {
 
 	// SrcX and SrcY represents a point on a source image.
 	// Be careful that SrcX/SrcY coordinates are on the image's bounds.
-	// This means that a upper-left point of a sub-image might not be (0, 0).
+	// This means that an upper-left point of a sub-image might not be (0, 0).
 	SrcX float32
 	SrcY float32
 
@@ -292,7 +292,7 @@ type Vertex struct {
 	//   Vertex colors are converted to premultiplied-alpha internally and
 	//   interpolated linearly respecting alpha.
 	// - DrawTrianglesShader: arbitrary floating point values sent to the shader.
-	//   These are interpolated linearly and independently from each other.
+	//   These are interpolated linearly and independently of each other.
 	ColorR float32
 	ColorG float32
 	ColorB float32
@@ -303,7 +303,7 @@ type Vertex struct {
 type Address int
 
 const (
-	// AddressUnsafe means there is no guarantee when the texture coodinates are out of range.
+	// AddressUnsafe means there is no guarantee when the texture coordinates are out of range.
 	AddressUnsafe Address = Address(builtinshader.AddressUnsafe)
 
 	// AddressClampToZero means that out-of-range texture coordinates return 0 (transparent).
@@ -321,7 +321,7 @@ const (
 	FillAll FillRule = iota
 
 	// EvenOdd means that triangles are rendered based on the even-odd rule.
-	// If and only if the number of overlappings is odd, the region is rendered.
+	// If and only if the number of overlaps is odd, the region is rendered.
 	EvenOdd
 )
 
@@ -333,7 +333,7 @@ const (
 	// straight-alpha encoded color multiplier.
 	ColorScaleModeStraightAlpha ColorScaleMode = iota
 
-	// ColorScaleModeStraightAlpha indicates color scales in vertices are
+	// ColorScaleModePremultipliedAlpha indicates color scales in vertices are
 	// premultiplied-alpha encoded color multiplier.
 	ColorScaleModePremultipliedAlpha
 )
@@ -872,7 +872,7 @@ func (i *Image) ReadPixels(pixels []byte) {
 // At can't be called outside the main loop (ebiten.Run's updating function) starts.
 func (i *Image) At(x, y int) color.Color {
 	r, g, b, a := i.at(x, y)
-	return color.RGBA{r, g, b, a}
+	return color.RGBA{R: r, G: g, B: b, A: a}
 }
 
 // RGBA64At implements the standard image.RGBA64Image's RGBA64At.
@@ -888,7 +888,7 @@ func (i *Image) At(x, y int) color.Color {
 // RGBA64At can't be called outside the main loop (ebiten.Run's updating function) starts.
 func (i *Image) RGBA64At(x, y int) color.RGBA64 {
 	r, g, b, a := i.at(x, y)
-	return color.RGBA64{uint16(r) * 0x101, uint16(g) * 0x101, uint16(b) * 0x101, uint16(a) * 0x101}
+	return color.RGBA64{R: uint16(r) * 0x101, G: uint16(g) * 0x101, B: uint16(b) * 0x101, A: uint16(a) * 0x101}
 }
 
 func (i *Image) at(x, y int) (r, g, b, a byte) {
@@ -928,14 +928,14 @@ func (i *Image) Set(x, y int, clr color.Color) {
 }
 
 // Dispose disposes the image data.
-// After disposing, most of image functions do nothing and returns meaningless values.
+// After disposing, most of the image functions do nothing and returns meaningless values.
 //
 // Calling Dispose is not mandatory. GC automatically collects internal resources that no objects refer to.
 // However, calling Dispose explicitly is helpful if memory usage matters.
 //
 // If the image is a sub-image, Dispose does nothing.
 //
-// When the image is disposed, Dipose does nothing.
+// When the image is disposed, Dispose does nothing.
 func (i *Image) Dispose() {
 	i.copyCheck()
 
@@ -1011,7 +1011,7 @@ type NewImageOptions struct {
 //
 // The rendering origin position is (0, 0) of the given bounds.
 // If DrawImage is called on a new image created by NewImageOptions,
-// for example, the center of scaling and rotating is (0, 0), that might not be a upper-left position.
+// for example, the center of scaling and rotating is (0, 0), that might not be an upper-left position.
 //
 // If options is nil, the default setting is used.
 //
@@ -1122,7 +1122,7 @@ func NewImageFromImageWithOptions(source image.Image, options *NewImageFromImage
 	return i
 }
 
-// colorMToScale returns a new color matrix and color sclaes that equal to the given matrix in terms of the effect.
+// colorMToScale returns a new color matrix and color scales that equal to the given matrix in terms of the effect.
 //
 // If the given matrix is merely a scaling matrix, colorMToScale returns
 // an identity matrix and its scaling factors in premultiplied-alpha format.

image_test.go

@@ -121,7 +121,7 @@ func TestImagePixels(t *testing.T) {
 	for j := 0; j < h; j++ {
 		for i := 0; i < w; i++ {
 			idx := 4 * (j*w + i)
-			got := color.RGBA{pix[idx], pix[idx+1], pix[idx+2], pix[idx+3]}
+			got := color.RGBA{R: pix[idx], G: pix[idx+1], B: pix[idx+2], A: pix[idx+3]}
 			want := color.RGBAModel.Convert(img.At(i, j))
 			if got != want {
 				t.Errorf("(%d, %d): got %v; want %v", i, j, got, want)
@@ -131,8 +131,8 @@ func TestImagePixels(t *testing.T) {
 }
 
 func TestImageComposition(t *testing.T) {
-	img2Color := color.NRGBA{0x24, 0x3f, 0x6a, 0x88}
+	img2Color := color.NRGBA{R: 0x24, G: 0x3f, B: 0x6a, A: 0x88}
-	img3Color := color.NRGBA{0x85, 0xa3, 0x08, 0xd3}
+	img3Color := color.NRGBA{R: 0x85, G: 0xa3, B: 0x08, A: 0xd3}
 
 	// TODO: Rename this to img0
 	img1, _, err := openEbitenImage()
@@ -178,7 +178,7 @@ func TestImageComposition(t *testing.T) {
 }
 
 func TestImageSelf(t *testing.T) {
-	// Note that mutex usages: without defer, unlocking is not called when panicing.
+	// Note that mutex usages: without defer, unlocking is not called when panicking.
 	defer func() {
 		if r := recover(); r == nil {
 			t.Errorf("DrawImage must panic but not")
@@ -267,7 +267,7 @@ func TestImageDotByDotInversion(t *testing.T) {
 }
 
 func TestImageWritePixels(t *testing.T) {
-	// Create a dummy image so that the shared texture is used and origImg's position is shfited.
+	// Create a dummy image so that the shared texture is used and origImg's position is shifted.
 	dummyImg := ebiten.NewImageFromImage(image.NewRGBA(image.Rect(0, 0, 16, 16)))
 	defer dummyImg.Dispose()
 
@@ -306,7 +306,7 @@ func TestImageWritePixels(t *testing.T) {
 	for j := 0; j < img0.Bounds().Dy(); j++ {
 		for i := 0; i < img0.Bounds().Dx(); i++ {
 			got := img0.At(i, j)
-			want := color.RGBA{0x80, 0x80, 0x80, 0x80}
+			want := color.RGBA{R: 0x80, G: 0x80, B: 0x80, A: 0x80}
 			if got != want {
 				t.Errorf("img0 At(%d, %d): got %v; want %v", i, j, got, want)
 			}
@@ -356,7 +356,7 @@ func TestImageBlendLighter(t *testing.T) {
 
 	w, h := img0.Bounds().Dx(), img0.Bounds().Dy()
 	img1 := ebiten.NewImage(w, h)
-	img1.Fill(color.RGBA{0x01, 0x02, 0x03, 0x04})
+	img1.Fill(color.RGBA{R: 0x01, G: 0x02, B: 0x03, A: 0x04})
 	op := &ebiten.DrawImageOptions{}
 	op.Blend = ebiten.BlendLighter
 	img1.DrawImage(img0, op)
@@ -429,7 +429,7 @@ func TestImageFill(t *testing.T) {
 	for j := 0; j < h; j++ {
 		for i := 0; i < w; i++ {
 			got := img.At(i, j)
-			want := color.RGBA{0x80, 0x80, 0x80, 0x80}
+			want := color.RGBA{R: 0x80, G: 0x80, B: 0x80, A: 0x80}
 			if got != want {
 				t.Errorf("img At(%d, %d): got %v; want %v", i, j, got, want)
 			}
@@ -445,7 +445,7 @@ func TestImageClear(t *testing.T) {
 	for j := 0; j < h; j++ {
 		for i := 0; i < w; i++ {
 			got := img.At(i, j)
-			want := color.RGBA{0xff, 0xff, 0xff, 0xff}
+			want := color.RGBA{R: 0xff, G: 0xff, B: 0xff, A: 0xff}
 			if got != want {
 				t.Errorf("img At(%d, %d): got %v; want %v", i, j, got, want)
 			}
@@ -493,8 +493,8 @@ func TestImageEdge(t *testing.T) {
 	}
 	img0.WritePixels(pixels)
 	img1 := ebiten.NewImage(img1Width, img1Height)
-	red := color.RGBA{0xff, 0, 0, 0xff}
+	red := color.RGBA{R: 0xff, A: 0xff}
-	transparent := color.RGBA{0, 0, 0, 0}
+	transparent := color.RGBA{}
 
 	angles := []float64{}
 	for a := 0; a < 1440; a++ {
@@ -616,7 +616,7 @@ func TestImageTooManyFill(t *testing.T) {
 	dst := ebiten.NewImage(width, 1)
 	for i := 0; i < width; i++ {
 		c := indexToColor(i)
-		src.Fill(color.RGBA{c, c, c, 0xff})
+		src.Fill(color.RGBA{R: c, G: c, B: c, A: 0xff})
 		op := &ebiten.DrawImageOptions{}
 		op.GeoM.Translate(float64(i), 0)
 		dst.DrawImage(src, op)
@@ -625,7 +625,7 @@ func TestImageTooManyFill(t *testing.T) {
 	for i := 0; i < width; i++ {
 		c := indexToColor(i)
 		got := dst.At(i, 0).(color.RGBA)
-		want := color.RGBA{c, c, c, 0xff}
+		want := color.RGBA{R: c, G: c, B: c, A: 0xff}
 		if !sameColors(got, want, 1) {
 			t.Errorf("dst.At(%d, %d): got %v, want: %v", i, 0, got, want)
 		}
@@ -671,7 +671,7 @@ func TestImageLinearGraduation(t *testing.T) {
 func TestImageOutside(t *testing.T) {
 	src := ebiten.NewImage(5, 10) // internal texture size is 8x16.
 	dst := ebiten.NewImage(4, 4)
-	src.Fill(color.RGBA{0xff, 0, 0, 0xff})
+	src.Fill(color.RGBA{R: 0xff, A: 0xff})
 
 	cases := []struct {
 		X, Y, Width, Height int
@@ -701,7 +701,7 @@ func TestImageOutside(t *testing.T) {
 		for j := 0; j < 4; j++ {
 			for i := 0; i < 4; i++ {
 				got := dst.At(i, j).(color.RGBA)
-				want := color.RGBA{0, 0, 0, 0}
+				want := color.RGBA{}
 				if got != want {
 					t.Errorf("src(x: %d, y: %d, w: %d, h: %d), dst At(%d, %d): got %v, want: %v", c.X, c.Y, c.Width, c.Height, i, j, got, want)
 				}
@@ -714,7 +714,7 @@ func TestImageOutsideUpperLeft(t *testing.T) {
 	src := ebiten.NewImage(4, 4)
 	dst1 := ebiten.NewImage(16, 16)
 	dst2 := ebiten.NewImage(16, 16)
-	src.Fill(color.RGBA{0xff, 0, 0, 0xff})
+	src.Fill(color.RGBA{R: 0xff, A: 0xff})
 
 	op := &ebiten.DrawImageOptions{}
 	op.GeoM.Rotate(math.Pi / 4)
@@ -756,7 +756,7 @@ func TestImageSize1(t *testing.T) {
 	src.Fill(color.White)
 	dst.DrawImage(src, nil)
 	got := src.At(0, 0).(color.RGBA)
-	want := color.RGBA{0xff, 0xff, 0xff, 0xff}
+	want := color.RGBA{R: 0xff, G: 0xff, B: 0xff, A: 0xff}
 	if !sameColors(got, want, 1) {
 		t.Errorf("got: %v, want: %v", got, want)
 	}
@@ -788,7 +788,7 @@ func Skip_TestImageSize4096(t *testing.T) {
 	for i := 4095; i < 4096; i++ {
 		j := 4095
 		got := dst.At(i, j).(color.RGBA)
-		want := color.RGBA{uint8(i + j), uint8((i + j) >> 8), uint8((i + j) >> 16), 0xff}
+		want := color.RGBA{R: uint8(i + j), G: uint8((i + j) >> 8), B: uint8((i + j) >> 16), A: 0xff}
 		if got != want {
 			t.Errorf("At(%d, %d): got: %v, want: %v", i, j, got, want)
 		}
@@ -796,7 +796,7 @@ func Skip_TestImageSize4096(t *testing.T) {
 	for j := 4095; j < 4096; j++ {
 		i := 4095
 		got := dst.At(i, j).(color.RGBA)
-		want := color.RGBA{uint8(i + j), uint8((i + j) >> 8), uint8((i + j) >> 16), 0xff}
+		want := color.RGBA{R: uint8(i + j), G: uint8((i + j) >> 8), B: uint8((i + j) >> 16), A: 0xff}
 		if got != want {
 			t.Errorf("At(%d, %d): got: %v, want: %v", i, j, got, want)
 		}
@@ -848,7 +848,7 @@ loop:
 				got := dst.At(0, i+j).(color.RGBA)
 				want := color.RGBA{}
 				if j < 0 {
-					want = color.RGBA{0xff, 0, 0, 0xff}
+					want = color.RGBA{R: 0xff, A: 0xff}
 				}
 				if got != want {
 					t.Errorf("At(%d, %d) (height=%d, scale=%d/%d): got: %v, want: %v", 0, i+j, h, i, h, got, want)
@@ -874,7 +874,7 @@ func TestImageSprites(t *testing.T) {
 	)
 
 	src := ebiten.NewImage(4, 4)
-	src.Fill(color.RGBA{0xff, 0xff, 0xff, 0xff})
+	src.Fill(color.RGBA{R: 0xff, G: 0xff, B: 0xff, A: 0xff})
 	dst := ebiten.NewImage(width, height)
 	for j := 0; j < height/4; j++ {
 		for i := 0; i < width/4; i++ {
@@ -887,7 +887,7 @@ func TestImageSprites(t *testing.T) {
 	for j := 0; j < height/4; j++ {
 		for i := 0; i < width/4; i++ {
 			got := dst.At(i*4, j*4).(color.RGBA)
-			want := color.RGBA{0xff, 0xff, 0xff, 0xff}
+			want := color.RGBA{R: 0xff, G: 0xff, B: 0xff, A: 0xff}
 			if !sameColors(got, want, 1) {
 				t.Errorf("dst.At(%d, %d): got %v, want: %v", i*4, j*4, got, want)
 			}
@@ -1017,7 +1017,7 @@ func TestImageMipmapColor(t *testing.T) {
 		op.ColorScale.Scale(0, 1, 1, 1)
 		img0.DrawImage(img1, op)
 
-		want := color.RGBA{0, 0xff, 0xff, 0xff}
+		want := color.RGBA{G: 0xff, B: 0xff, A: 0xff}
 		got := img0.At(128, 0)
 		if got != want {
 			t.Errorf("want: %v, got: %v", want, got)
@@ -1032,14 +1032,14 @@ func TestImageMiamapAndDrawTriangle(t *testing.T) {
 	img2 := ebiten.NewImage(128, 128)
 
 	// Fill img1 red and create img1's mipmap
-	img1.Fill(color.RGBA{0xff, 0, 0, 0xff})
+	img1.Fill(color.RGBA{R: 0xff, A: 0xff})
 	op := &ebiten.DrawImageOptions{}
 	op.GeoM.Scale(0.25, 0.25)
 	op.Filter = ebiten.FilterLinear
 	img0.DrawImage(img1, op)
 
 	// Call DrawTriangle on img1 and fill it with green
-	img2.Fill(color.RGBA{0, 0xff, 0, 0xff})
+	img2.Fill(color.RGBA{G: 0xff, A: 0xff})
 	vs := []ebiten.Vertex{
 		{
 			DstX:   0,
@@ -1104,7 +1104,7 @@ func TestImageMiamapAndDrawTriangle(t *testing.T) {
 
 func TestImageSubImageAt(t *testing.T) {
 	img := ebiten.NewImage(16, 16)
-	img.Fill(color.RGBA{0xff, 0, 0, 0xff})
+	img.Fill(color.RGBA{R: 0xff, A: 0xff})
 
 	got := img.SubImage(image.Rect(1, 1, 16, 16)).At(0, 0).(color.RGBA)
 	want := color.RGBA{}
@@ -1113,7 +1113,7 @@ func TestImageSubImageAt(t *testing.T) {
 	}
 
 	got = img.SubImage(image.Rect(1, 1, 16, 16)).At(1, 1).(color.RGBA)
-	want = color.RGBA{0xff, 0, 0, 0xff}
+	want = color.RGBA{R: 0xff, A: 0xff}
 	if got != want {
 		t.Errorf("got: %v, want: %v", got, want)
 	}
@@ -1121,7 +1121,7 @@ func TestImageSubImageAt(t *testing.T) {
 
 func TestImageSubImageSize(t *testing.T) {
 	img := ebiten.NewImage(16, 16)
-	img.Fill(color.RGBA{0xff, 0, 0, 0xff})
+	img.Fill(color.RGBA{R: 0xff, A: 0xff})
 
 	got := img.SubImage(image.Rect(1, 1, 16, 16)).Bounds().Dx()
 	want := 15
@@ -1136,11 +1136,11 @@ func TestImageDrawImmediately(t *testing.T) {
 	img1 := ebiten.NewImage(w, h)
 	// Do not manipulate img0 here.
 
-	img0.Fill(color.RGBA{0xff, 0, 0, 0xff})
+	img0.Fill(color.RGBA{R: 0xff, A: 0xff})
 	for j := 0; j < h; j++ {
 		for i := 0; i < w; i++ {
 			got := img0.At(i, j).(color.RGBA)
-			want := color.RGBA{0xff, 0, 0, 0xff}
+			want := color.RGBA{R: 0xff, A: 0xff}
 			if got != want {
 				t.Errorf("img0.At(%d, %d): got %v, want: %v", i, j, got, want)
 			}
@@ -1152,7 +1152,7 @@ func TestImageDrawImmediately(t *testing.T) {
 	for j := 0; j < h; j++ {
 		for i := 0; i < w; i++ {
 			got := img0.At(i, j).(color.RGBA)
-			want := color.RGBA{0xff, 0, 0, 0xff}
+			want := color.RGBA{R: 0xff, A: 0xff}
 			if got != want {
 				t.Errorf("img0.At(%d, %d): got %v, want: %v", i, j, got, want)
 			}
@@ -1198,9 +1198,9 @@ func TestImageLinearFilterGlitch(t *testing.T) {
 				got := dst.At(i, j).(color.RGBA)
 				var want color.RGBA
 				if j < 3 {
-					want = color.RGBA{0xff, 0xff, 0xff, 0xff}
+					want = color.RGBA{R: 0xff, G: 0xff, B: 0xff, A: 0xff}
 				} else {
-					want = color.RGBA{0, 0, 0, 0xff}
+					want = color.RGBA{A: 0xff}
 				}
 				if got != want {
 					t.Errorf("dst.At(%d, %d): filter: %d, got: %v, want: %v", i, j, f, got, want)
@@ -1245,9 +1245,9 @@ func TestImageLinearFilterGlitch2(t *testing.T) {
 			got := dst.At(i, j).(color.RGBA)
 			var want color.RGBA
 			if i+j < 100 {
-				want = color.RGBA{0, 0, 0, 0xff}
+				want = color.RGBA{A: 0xff}
 			} else {
-				want = color.RGBA{0xff, 0xff, 0xff, 0xff}
+				want = color.RGBA{R: 0xff, G: 0xff, B: 0xff, A: 0xff}
 			}
 			if !sameColors(got, want, 1) {
 				t.Errorf("dst.At(%d, %d): got: %v, want: %v", i, j, got, want)
@@ -1329,7 +1329,7 @@ func TestImageAddressRepeat(t *testing.T) {
 	for j := 0; j < h; j++ {
 		for i := 0; i < w; i++ {
 			got := dst.At(i, j).(color.RGBA)
-			want := color.RGBA{byte(i%4) * 0x10, byte(j%4) * 0x10, 0, 0xff}
+			want := color.RGBA{R: byte(i%4) * 0x10, G: byte(j%4) * 0x10, A: 0xff}
 			if !sameColors(got, want, 1) {
 				t.Errorf("dst.At(%d, %d): got %v, want: %v", i, j, got, want)
 			}
@@ -1410,7 +1410,7 @@ func TestImageAddressRepeatNegativePosition(t *testing.T) {
 	for j := 0; j < h; j++ {
 		for i := 0; i < w; i++ {
 			got := dst.At(i, j).(color.RGBA)
-			want := color.RGBA{byte(i%4) * 0x10, byte(j%4) * 0x10, 0, 0xff}
+			want := color.RGBA{R: byte(i%4) * 0x10, G: byte(j%4) * 0x10, A: 0xff}
 			if !sameColors(got, want, 1) {
 				t.Errorf("dst.At(%d, %d): got %v, want: %v", i, j, got, want)
 			}
@@ -1683,8 +1683,8 @@ func TestImageAtAfterDisposingSubImage(t *testing.T) {
 	img.SubImage(image.Rect(0, 0, 16, 16))
 	runtime.GC()
 
-	want := color.RGBA{0xff, 0xff, 0xff, 0xff}
+	want := color.RGBA{R: 0xff, G: 0xff, B: 0xff, A: 0xff}
-	want64 := color.RGBA64{0xffff, 0xffff, 0xffff, 0xffff}
+	want64 := color.RGBA64{R: 0xffff, G: 0xffff, B: 0xffff, A: 0xffff}
 	got := img.At(0, 0)
 	if got != want {
 		t.Errorf("At(0,0) got: %v, want: %v", got, want)
@@ -1726,7 +1726,7 @@ func TestImageSubImageSubImage(t *testing.T) {
 		{
 			X:     4,
 			Y:     4,
-			Color: color.RGBA{0xff, 0xff, 0xff, 0xff},
+			Color: color.RGBA{R: 0xff, G: 0xff, B: 0xff, A: 0xff},
 		},
 		{
 			X:     15,
@@ -1755,7 +1755,7 @@ func TestImageTooSmallMipmap(t *testing.T) {
 	op.Filter = ebiten.FilterLinear
 	dst.DrawImage(src.SubImage(image.Rect(5, 0, 6, 16)).(*ebiten.Image), op)
 	got := dst.At(0, 0).(color.RGBA)
-	want := color.RGBA{0xff, 0xff, 0xff, 0xff}
+	want := color.RGBA{R: 0xff, G: 0xff, B: 0xff, A: 0xff}
 	if got != want {
 		t.Errorf("got: %v, want: %v", got, want)
 	}
@@ -1792,9 +1792,9 @@ func TestImageFillingAndEdges(t *testing.T) {
 	for j := 0; j < dsth; j++ {
 		for i := 0; i < dstw; i++ {
 			got := dst.At(i, j).(color.RGBA)
-			want := color.RGBA{0xff, 0xff, 0xff, 0xff}
+			want := color.RGBA{R: 0xff, G: 0xff, B: 0xff, A: 0xff}
 			if i == 0 || i == dstw-1 || j == 0 || j == dsth-1 {
-				want = color.RGBA{0, 0, 0, 0xff}
+				want = color.RGBA{A: 0xff}
 			}
 			if got != want {
 				t.Errorf("dst.At(%d, %d): got: %v, want: %v", i, j, got, want)
@@ -1807,7 +1807,7 @@ func TestImageDrawTrianglesAndMutateArgs(t *testing.T) {
 	const w, h = 16, 16
 	dst := ebiten.NewImage(w, h)
 	src := ebiten.NewImage(w, h)
-	clr := color.RGBA{0xff, 0, 0, 0xff}
+	clr := color.RGBA{R: 0xff, A: 0xff}
 	src.Fill(clr)
 
 	vs := []ebiten.Vertex{
@@ -1871,7 +1871,7 @@ func TestImageDrawTrianglesAndMutateArgs(t *testing.T) {
 
 func TestImageWritePixelsOnSubImage(t *testing.T) {
 	dst := ebiten.NewImage(17, 31)
-	dst.Fill(color.RGBA{0xff, 0, 0, 0xff})
+	dst.Fill(color.RGBA{R: 0xff, A: 0xff})
 
 	pix0 := make([]byte, 4*5*3)
 	idx := 0
@@ -1916,13 +1916,13 @@ func TestImageWritePixelsOnSubImage(t *testing.T) {
 	for j := 0; j < 31; j++ {
 		for i := 0; i < 17; i++ {
 			got := dst.At(i, j).(color.RGBA)
-			want := color.RGBA{0xff, 0, 0, 0xff}
+			want := color.RGBA{R: 0xff, A: 0xff}
 			p := image.Pt(i, j)
 			switch {
 			case p.In(r0):
-				want = color.RGBA{0, 0xff, 0, 0xff}
+				want = color.RGBA{G: 0xff, A: 0xff}
 			case p.In(r1):
-				want = color.RGBA{0, 0, 0xff, 0xff}
+				want = color.RGBA{B: 0xff, A: 0xff}
 			}
 			if got != want {
 				t.Errorf("dst.At(%d, %d): got: %v, want: %v", i, j, got, want)
@@ -2120,7 +2120,7 @@ func TestImageDrawTrianglesInterpolatesColors(t *testing.T) {
 		format := format
 		t.Run(fmt.Sprintf("format%d", format), func(t *testing.T) {
 			dst := ebiten.NewImage(w, h)
-			dst.Fill(color.RGBA{0x00, 0x00, 0xff, 0xff})
+			dst.Fill(color.RGBA{B: 0xff, A: 0xff})
 
 			op := &ebiten.DrawTrianglesOptions{}
 			op.ColorScaleMode = format
@@ -2135,9 +2135,9 @@ func TestImageDrawTrianglesInterpolatesColors(t *testing.T) {
 			var want color.RGBA
 			switch format {
 			case ebiten.ColorScaleModeStraightAlpha:
-				want = color.RGBA{0x00, 0x80, 0x80, 0xff}
+				want = color.RGBA{G: 0x80, B: 0x80, A: 0xff}
 			case ebiten.ColorScaleModePremultipliedAlpha:
-				want = color.RGBA{0x80, 0x80, 0x80, 0xff}
+				want = color.RGBA{R: 0x80, G: 0x80, B: 0x80, A: 0xff}
 			}
 
 			if !sameColors(got, want, 2) {
@@ -2195,7 +2195,7 @@ func TestImageDrawTrianglesShaderInterpolatesValues(t *testing.T) {
 			ColorA: 1,
 		},
 	}
-	dst.Fill(color.RGBA{0x00, 0x00, 0xff, 0xff})
+	dst.Fill(color.RGBA{B: 0xff, A: 0xff})
 	op := &ebiten.DrawTrianglesShaderOptions{
 		Images: [4]*ebiten.Image{src, nil, nil, nil},
 	}
@@ -2214,7 +2214,7 @@ func TestImageDrawTrianglesShaderInterpolatesValues(t *testing.T) {
 	got := dst.At(1, 0).(color.RGBA)
 
 	// Shaders get each color value interpolated independently.
-	want := color.RGBA{0x80, 0x80, 0x80, 0xff}
+	want := color.RGBA{R: 0x80, G: 0x80, B: 0x80, A: 0xff}
 
 	if !sameColors(got, want, 2) {
 		t.Errorf("At(1, 0): got: %v, want: %v", got, want)
@@ -2228,13 +2228,13 @@ func TestImageDrawOver(t *testing.T) {
 		h = 240
 	)
 	dst := ebiten.NewImage(w, h)
-	src := image.NewUniform(color.RGBA{0xff, 0, 0, 0xff})
+	src := image.NewUniform(color.RGBA{R: 0xff, A: 0xff})
 	// This must not cause infinite-loop.
 	draw.Draw(dst, dst.Bounds(), src, image.ZP, draw.Over)
 	for j := 0; j < h; j++ {
 		for i := 0; i < w; i++ {
 			got := dst.At(i, j)
-			want := color.RGBA{0xff, 0, 0, 0xff}
+			want := color.RGBA{R: 0xff, A: 0xff}
 			if got != want {
 				t.Errorf("At(%d, %d): got: %v, want: %v", i, j, got, want)
 			}
@@ -2288,7 +2288,7 @@ func TestImageFloatTranslate(t *testing.T) {
 		t.Run(fmt.Sprintf("scale%d", s), func(t *testing.T) {
 			check := func(src *ebiten.Image) {
 				dst := ebiten.NewImage(w*(s+1), h*(s+1))
-				dst.Fill(color.RGBA{0xff, 0, 0, 0xff})
+				dst.Fill(color.RGBA{R: 0xff, A: 0xff})
 
 				op := &ebiten.DrawImageOptions{}
 				op.GeoM.Scale(float64(s), float64(s))
@@ -2302,7 +2302,7 @@ func TestImageFloatTranslate(t *testing.T) {
 						if j > 0 {
 							x = (byte(j) - 1) / byte(s)
 						}
-						want := color.RGBA{x, 0, 0, 0xff}
+						want := color.RGBA{R: x, A: 0xff}
 						if got != want {
 							t.Errorf("At(%d, %d): got: %v, want: %v", i, j, got, want)
 						}
@@ -2354,7 +2354,7 @@ func TestImageColorMCopy(t *testing.T) {
 		for j := 0; j < h; j++ {
 			for i := 0; i < w; i++ {
 				got := dst.At(i, j).(color.RGBA)
-				want := color.RGBA{byte(k), byte(k), byte(k), byte(k)}
+				want := color.RGBA{R: byte(k), G: byte(k), B: byte(k), A: byte(k)}
 				if !sameColors(got, want, 1) {
 					t.Fatalf("dst.At(%d, %d), k: %d: got %v, want %v", i, j, k, got, want)
 				}
@@ -2399,7 +2399,7 @@ func TestImageWritePixelsAndModifyPixels(t *testing.T) {
 	for j := 0; j < h; j++ {
 		for i := 0; i < w; i++ {
 			got := src.At(i, j).(color.RGBA)
-			want := color.RGBA{0xff, 0, 0, 0xff}
+			want := color.RGBA{R: 0xff, A: 0xff}
 			if got != want {
 				t.Errorf("src.At(%d, %d): got: %v, want: %v", i, j, got, want)
 			}
@@ -2412,8 +2412,8 @@ func TestImageCompositeModeMultiply(t *testing.T) {
 	dst := ebiten.NewImage(w, h)
 	src := ebiten.NewImage(w, h)
 
-	dst.Fill(color.RGBA{0x10, 0x20, 0x30, 0x40})
+	dst.Fill(color.RGBA{R: 0x10, G: 0x20, B: 0x30, A: 0x40})
-	src.Fill(color.RGBA{0x50, 0x60, 0x70, 0x80})
+	src.Fill(color.RGBA{R: 0x50, G: 0x60, B: 0x70, A: 0x80})
 
 	op := &ebiten.DrawImageOptions{}
 	op.CompositeMode = ebiten.CompositeModeMultiply
@@ -2507,16 +2507,16 @@ func TestImageClip(t *testing.T) {
 	dst := ebiten.NewImage(w, h)
 	src := ebiten.NewImage(w, h)
 
-	dst.Fill(color.RGBA{0xff, 0, 0, 0xff})
+	dst.Fill(color.RGBA{R: 0xff, A: 0xff})
-	src.Fill(color.RGBA{0, 0xff, 0, 0xff})
+	src.Fill(color.RGBA{G: 0xff, A: 0xff})
 
 	dst.SubImage(image.Rect(4, 5, 12, 14)).(*ebiten.Image).DrawImage(src, nil)
 	for j := 0; j < h; j++ {
 		for i := 0; i < w; i++ {
 			got := dst.At(i, j).(color.RGBA)
-			want := color.RGBA{0xff, 0, 0, 0xff}
+			want := color.RGBA{R: 0xff, A: 0xff}
 			if 4 <= i && i < 12 && 5 <= j && j < 14 {
-				want = color.RGBA{0, 0xff, 0, 0xff}
+				want = color.RGBA{G: 0xff, A: 0xff}
 			}
 			if got != want {
 				t.Errorf("dst.At(%d, %d): got: %v, want: %v", i, j, got, want)
@@ -2534,7 +2534,7 @@ func TestImageSubImageFill(t *testing.T) {
 			got := dst.At(i, j)
 			var want color.RGBA
 			if i == 1 && j == 1 {
-				want = color.RGBA{0xff, 0xff, 0xff, 0xff}
+				want = color.RGBA{R: 0xff, G: 0xff, B: 0xff, A: 0xff}
 			}
 			if got != want {
 				t.Errorf("dst.At(%d, %d): got: %v, want: %v", i, j, got, want)
@@ -2549,7 +2549,7 @@ func TestImageSubImageFill(t *testing.T) {
 			got := dst.At(i, j)
 			var want color.RGBA
 			if 3 <= i && i < 8 && 4 <= j && j < 10 {
-				want = color.RGBA{0xff, 0xff, 0xff, 0xff}
+				want = color.RGBA{R: 0xff, G: 0xff, B: 0xff, A: 0xff}
 			}
 			if got != want {
 				t.Errorf("dst.At(%d, %d): got: %v, want: %v", i, j, got, want)
@@ -2635,13 +2635,13 @@ func TestImageEvenOdd(t *testing.T) {
 			var want color.RGBA
 			switch {
 			case 3 <= i && i < 13 && 3 <= j && j < 13:
-				want = color.RGBA{0, 0, 0xff, 0xff}
+				want = color.RGBA{B: 0xff, A: 0xff}
 			case 2 <= i && i < 14 && 2 <= j && j < 14:
-				want = color.RGBA{0, 0, 0, 0}
+				want = color.RGBA{}
 			case 1 <= i && i < 15 && 1 <= j && j < 15:
-				want = color.RGBA{0xff, 0, 0, 0xff}
+				want = color.RGBA{R: 0xff, A: 0xff}
 			default:
-				want = color.RGBA{0, 0, 0, 0}
+				want = color.RGBA{}
 			}
 			if got != want {
 				t.Errorf("dst.At(%d, %d): got: %v, want: %v", i, j, got, want)
@@ -2670,13 +2670,13 @@ func TestImageEvenOdd(t *testing.T) {
 			var want color.RGBA
 			switch {
 			case 4 <= i && i < 14 && 4 <= j && j < 14:
-				want = color.RGBA{0, 0, 0xff, 0xff}
+				want = color.RGBA{B: 0xff, A: 0xff}
 			case 3 <= i && i < 15 && 3 <= j && j < 15:
-				want = color.RGBA{0, 0, 0, 0}
+				want = color.RGBA{}
 			case 2 <= i && i < 16 && 2 <= j && j < 16:
-				want = color.RGBA{0xff, 0, 0, 0xff}
+				want = color.RGBA{R: 0xff, A: 0xff}
 			default:
-				want = color.RGBA{0, 0, 0, 0}
+				want = color.RGBA{}
 			}
 			if got != want {
 				t.Errorf("dst.At(%d, %d): got: %v, want: %v", i, j, got, want)
@@ -2708,13 +2708,13 @@ func TestImageEvenOdd(t *testing.T) {
 			var want color.RGBA
 			switch {
 			case 3 <= i && i < 13 && 3 <= j && j < 13:
-				want = color.RGBA{0, 0, 0xff, 0xff}
+				want = color.RGBA{B: 0xff, A: 0xff}
 			case 2 <= i && i < 14 && 2 <= j && j < 14:
-				want = color.RGBA{0, 0xff, 0, 0xff}
+				want = color.RGBA{G: 0xff, A: 0xff}
 			case 1 <= i && i < 15 && 1 <= j && j < 15:
-				want = color.RGBA{0xff, 0, 0, 0xff}
+				want = color.RGBA{R: 0xff, A: 0xff}
 			default:
-				want = color.RGBA{0, 0, 0, 0}
+				want = color.RGBA{}
 			}
 			if got != want {
 				t.Errorf("dst.At(%d, %d): got: %v, want: %v", i, j, got, want)
@@ -2799,7 +2799,7 @@ func TestIndicesOverflow(t *testing.T) {
 	for j := 0; j < h; j++ {
 		for i := 0; i < w; i++ {
 			got := dst.At(i, j)
-			want := color.RGBA{0xff, 0xff, 0xff, 0xff}
+			want := color.RGBA{R: 0xff, G: 0xff, B: 0xff, A: 0xff}
 			if got != want {
 				t.Errorf("dst.At(%d, %d): got: %v, want: %v", i, j, got, want)
 			}
@@ -2871,7 +2871,7 @@ func TestVerticesOverflow(t *testing.T) {
 	for j := 0; j < h; j++ {
 		for i := 0; i < w; i++ {
 			got := dst.At(i, j)
-			want := color.RGBA{0xff, 0xff, 0xff, 0xff}
+			want := color.RGBA{R: 0xff, G: 0xff, B: 0xff, A: 0xff}
 			if got != want {
 				t.Errorf("dst.At(%d, %d): got: %v, want: %v", i, j, got, want)
 			}
@@ -2923,7 +2923,7 @@ func TestImageNewImageFromEbitenImage(t *testing.T) {
 	for j := 0; j < h; j++ {
 		for i := 0; i < w; i++ {
 			got := img1.At(i, j)
-			want := color.RGBA{byte(i), byte(j), 0, 0xff}
+			want := color.RGBA{R: byte(i), G: byte(j), A: 0xff}
 			if got != want {
 				t.Errorf("img1.At(%d, %d): got: %v, want: %v", i, j, got, want)
 			}
@@ -2934,7 +2934,7 @@ func TestImageNewImageFromEbitenImage(t *testing.T) {
 	for j := 0; j < h/2; j++ {
 		for i := 0; i < w/2; i++ {
 			got := img2.At(i, j)
-			want := color.RGBA{byte(i + 4), byte(j + 4), 0, 0xff}
+			want := color.RGBA{R: byte(i + 4), G: byte(j + 4), A: 0xff}
 			if got != want {
 				t.Errorf("img1.At(%d, %d): got: %v, want: %v", i, j, got, want)
 			}
@@ -2968,7 +2968,7 @@ func TestImageOptionsUnmanaged(t *testing.T) {
 	for j := 0; j < h; j++ {
 		for i := 0; i < w; i++ {
 			got := img.At(i, j)
-			want := color.RGBA{byte(i), byte(j), 0, 0xff}
+			want := color.RGBA{R: byte(i), G: byte(j), A: 0xff}
 			if got != want {
 				t.Errorf("img.At(%d, %d): got: %v, want: %v", i, j, got, want)
 			}
@@ -3000,7 +3000,7 @@ func TestImageOptionsNegativeBoundsWritePixels(t *testing.T) {
 	for j := offset; j < h+offset; j++ {
 		for i := offset; i < w+offset; i++ {
 			got := img.At(i, j)
-			want := color.RGBA{byte(i - offset), byte(j - offset), 0, 0xff}
+			want := color.RGBA{R: byte(i - offset), G: byte(j - offset), A: 0xff}
 			if got != want {
 				t.Errorf("img.At(%d, %d): got: %v, want: %v", i, j, got, want)
 			}
@@ -3024,9 +3024,9 @@ func TestImageOptionsNegativeBoundsWritePixels(t *testing.T) {
 	for j := offset; j < h+offset; j++ {
 		for i := offset; i < w+offset; i++ {
 			got := img.At(i, j)
-			want := color.RGBA{byte(i - offset), byte(j - offset), 0, 0xff}
+			want := color.RGBA{R: byte(i - offset), G: byte(j - offset), A: 0xff}
 			if image.Pt(i, j).In(sub) {
-				want = color.RGBA{0, 0, 0xff, 0xff}
+				want = color.RGBA{B: 0xff, A: 0xff}
 			}
 			if got != want {
 				t.Errorf("img.At(%d, %d): got: %v, want: %v", i, j, got, want)
@@ -3055,14 +3055,14 @@ func TestImageOptionsNegativeBoundsSet(t *testing.T) {
 	const offset = -8
 	img := ebiten.NewImageWithOptions(image.Rect(offset, offset, w+offset, h+offset), nil)
 	img.WritePixels(pix0)
-	img.Set(-1, -2, color.RGBA{0, 0, 0, 0})
+	img.Set(-1, -2, color.RGBA{})
 
 	for j := offset; j < h+offset; j++ {
 		for i := offset; i < w+offset; i++ {
 			got := img.At(i, j)
-			want := color.RGBA{byte(i - offset), byte(j - offset), 0, 0xff}
+			want := color.RGBA{R: byte(i - offset), G: byte(j - offset), A: 0xff}
 			if i == -1 && j == -2 {
-				want = color.RGBA{0, 0, 0, 0}
+				want = color.RGBA{}
 			}
 			if got != want {
 				t.Errorf("img.At(%d, %d): got: %v, want: %v", i, j, got, want)
@@ -3094,7 +3094,7 @@ func TestImageOptionsNegativeBoundsDrawImage(t *testing.T) {
 			got := dst.At(i, j)
 			var want color.RGBA
 			if -2 <= i && i < 2 && -3 <= j && j < 3 {
-				want = color.RGBA{0xff, 0xff, 0xff, 0xff}
+				want = color.RGBA{R: 0xff, G: 0xff, B: 0xff, A: 0xff}
 			}
 			if got != want {
 				t.Errorf("dst.At(%d, %d): got: %v, want: %v", i, j, got, want)
@@ -3165,7 +3165,7 @@ func TestImageOptionsNegativeBoundsDrawTriangles(t *testing.T) {
 			got := dst.At(i, j)
 			var want color.RGBA
 			if -2 <= i && i < 2 && -3 <= j && j < 3 {
-				want = color.RGBA{0xff, 0xff, 0xff, 0xff}
+				want = color.RGBA{R: 0xff, G: 0xff, B: 0xff, A: 0xff}
 			}
 			if got != want {
 				t.Errorf("dst.At(%d, %d): got: %v, want: %v", i, j, got, want)
@@ -3197,7 +3197,7 @@ func TestImageFromImageOptions(t *testing.T) {
 	for j := r.Min.Y; j < r.Max.Y; j++ {
 		for i := r.Min.X; i < r.Max.X; i++ {
 			got := img.At(i, j)
-			want := color.RGBA{0xff, 0xff, 0xff, 0xff}
+			want := color.RGBA{R: 0xff, G: 0xff, B: 0xff, A: 0xff}
 			if got != want {
 				t.Errorf("img.At(%d, %d): got: %v, want: %v", i, j, got, want)
 			}
@@ -3225,7 +3225,7 @@ func TestImageFromEbitenImageOptions(t *testing.T) {
 	for j := r.Min.Y; j < r.Max.Y; j++ {
 		for i := r.Min.X; i < r.Max.X; i++ {
 			got := img.At(i, j)
-			want := color.RGBA{0xff, 0xff, 0xff, 0xff}
+			want := color.RGBA{R: 0xff, G: 0xff, B: 0xff, A: 0xff}
 			if got != want {
 				t.Errorf("img.At(%d, %d): got: %v, want: %v", i, j, got, want)
 			}
@@ -3237,11 +3237,11 @@ func TestImageFromEbitenImageOptions(t *testing.T) {
 func TestImageOptionsFill(t *testing.T) {
 	r0 := image.Rect(-2, -3, 4, 5)
 	img := ebiten.NewImageWithOptions(r0, nil)
-	img.Fill(color.RGBA{0xff, 0, 0, 0xff})
+	img.Fill(color.RGBA{R: 0xff, A: 0xff})
 	for j := r0.Min.Y; j < r0.Max.Y; j++ {
 		for i := r0.Min.X; i < r0.Max.X; i++ {
 			got := img.At(i, j)
-			want := color.RGBA{0xff, 0, 0, 0xff}
+			want := color.RGBA{R: 0xff, A: 0xff}
 			if got != want {
 				t.Errorf("img.At(%d, %d): got: %v, want: %v", i, j, got, want)
 			}
@@ -3249,13 +3249,13 @@ func TestImageOptionsFill(t *testing.T) {
 	}
 
 	r1 := image.Rect(-1, -2, 3, 4)
-	img.SubImage(r1).(*ebiten.Image).Fill(color.RGBA{0, 0xff, 0, 0xff})
+	img.SubImage(r1).(*ebiten.Image).Fill(color.RGBA{G: 0xff, A: 0xff})
 	for j := r0.Min.Y; j < r0.Max.Y; j++ {
 		for i := r0.Min.X; i < r0.Max.X; i++ {
 			got := img.At(i, j)
-			want := color.RGBA{0xff, 0, 0, 0xff}
+			want := color.RGBA{R: 0xff, A: 0xff}
 			if image.Pt(i, j).In(r1) {
-				want = color.RGBA{0, 0xff, 0, 0xff}
+				want = color.RGBA{G: 0xff, A: 0xff}
 			}
 			if got != want {
 				t.Errorf("img.At(%d, %d): got: %v, want: %v", i, j, got, want)
@@ -3268,27 +3268,27 @@ func TestImageOptionsFill(t *testing.T) {
 func TestImageOptionsClear(t *testing.T) {
 	r0 := image.Rect(-2, -3, 4, 5)
 	img := ebiten.NewImageWithOptions(r0, nil)
-	img.Fill(color.RGBA{0xff, 0, 0, 0xff})
+	img.Fill(color.RGBA{R: 0xff, A: 0xff})
 	img.Clear()
 	for j := r0.Min.Y; j < r0.Max.Y; j++ {
 		for i := r0.Min.X; i < r0.Max.X; i++ {
 			got := img.At(i, j)
-			want := color.RGBA{0, 0, 0, 0}
+			want := color.RGBA{}
 			if got != want {
 				t.Errorf("img.At(%d, %d): got: %v, want: %v", i, j, got, want)
 			}
 		}
 	}
 
-	img.Fill(color.RGBA{0xff, 0, 0, 0xff})
+	img.Fill(color.RGBA{R: 0xff, A: 0xff})
 	r1 := image.Rect(-1, -2, 3, 4)
 	img.SubImage(r1).(*ebiten.Image).Clear()
 	for j := r0.Min.Y; j < r0.Max.Y; j++ {
 		for i := r0.Min.X; i < r0.Max.X; i++ {
 			got := img.At(i, j)
-			want := color.RGBA{0xff, 0, 0, 0xff}
+			want := color.RGBA{R: 0xff, A: 0xff}
 			if image.Pt(i, j).In(r1) {
-				want = color.RGBA{0, 0, 0, 0}
+				want = color.RGBA{}
 			}
 			if got != want {
 				t.Errorf("img.At(%d, %d): got: %v, want: %v", i, j, got, want)
@@ -3300,7 +3300,7 @@ func TestImageOptionsClear(t *testing.T) {
 // Issue #2178
 func TestImageTooManyDrawImage(t *testing.T) {
 	src := ebiten.NewImage(1, 1)
-	src.Fill(color.RGBA{0xff, 0xff, 0xff, 0xff})
+	src.Fill(color.RGBA{R: 0xff, G: 0xff, B: 0xff, A: 0xff})
 
 	const (
 		w = 256
@@ -3319,7 +3319,7 @@ func TestImageTooManyDrawImage(t *testing.T) {
 
 	for j := 0; j < h; j++ {
 		for i := 0; i < w; i++ {
-			if got, want := dst.At(i, j), (color.RGBA{0xff, 0xff, 0xff, 0xff}); got != want {
+			if got, want := dst.At(i, j), (color.RGBA{R: 0xff, G: 0xff, B: 0xff, A: 0xff}); got != want {
 				t.Errorf("dst.At(%d, %d): got: %v, want: %v", i, j, got, want)
 			}
 		}
@@ -3329,7 +3329,7 @@ func TestImageTooManyDrawImage(t *testing.T) {
 // Issue #2178
 func TestImageTooManyDrawTriangles(t *testing.T) {
 	img := ebiten.NewImage(3, 3)
-	img.Fill(color.RGBA{0xff, 0xff, 0xff, 0xff})
+	img.Fill(color.RGBA{R: 0xff, G: 0xff, B: 0xff, A: 0xff})
 	src := img.SubImage(image.Rect(1, 1, 2, 2)).(*ebiten.Image)
 
 	const (
@@ -3392,7 +3392,7 @@ func TestImageTooManyDrawTriangles(t *testing.T) {
 
 	for j := 0; j < h; j++ {
 		for i := 0; i < w; i++ {
-			if got, want := dst.At(i, j), (color.RGBA{0xff, 0xff, 0xff, 0xff}); got != want {
+			if got, want := dst.At(i, j), (color.RGBA{R: 0xff, G: 0xff, B: 0xff, A: 0xff}); got != want {
 				t.Errorf("dst.At(%d, %d): got: %v, want: %v", i, j, got, want)
 			}
 		}
@@ -3401,26 +3401,26 @@ func TestImageTooManyDrawTriangles(t *testing.T) {
 
 func TestImageSetOverSet(t *testing.T) {
 	img := ebiten.NewImage(1, 1)
-	img.Set(0, 0, color.RGBA{0xff, 0xff, 0xff, 0xff})
+	img.Set(0, 0, color.RGBA{R: 0xff, G: 0xff, B: 0xff, A: 0xff})
-	if got, want := img.At(0, 0), (color.RGBA{0xff, 0xff, 0xff, 0xff}); got != want {
+	if got, want := img.At(0, 0), (color.RGBA{R: 0xff, G: 0xff, B: 0xff, A: 0xff}); got != want {
 		t.Errorf("got: %v, want: %v", got, want)
 	}
 
 	// Apply the change by 'Set' by calling DrawImage.
 	dummy := ebiten.NewImage(1, 1)
 	img.DrawImage(dummy, nil)
-	if got, want := img.At(0, 0), (color.RGBA{0xff, 0xff, 0xff, 0xff}); got != want {
+	if got, want := img.At(0, 0), (color.RGBA{R: 0xff, G: 0xff, B: 0xff, A: 0xff}); got != want {
 		t.Errorf("got: %v, want: %v", got, want)
 	}
 
-	img.Set(0, 0, color.RGBA{0x80, 0x80, 0x80, 0x80})
+	img.Set(0, 0, color.RGBA{R: 0x80, G: 0x80, B: 0x80, A: 0x80})
-	if got, want := img.At(0, 0), (color.RGBA{0x80, 0x80, 0x80, 0x80}); got != want {
+	if got, want := img.At(0, 0), (color.RGBA{R: 0x80, G: 0x80, B: 0x80, A: 0x80}); got != want {
 		t.Errorf("got: %v, want: %v", got, want)
 	}
 
 	// Apply the change by 'Set' again.
 	img.DrawImage(dummy, nil)
-	if got, want := img.At(0, 0), (color.RGBA{0x80, 0x80, 0x80, 0x80}); got != want {
+	if got, want := img.At(0, 0), (color.RGBA{R: 0x80, G: 0x80, B: 0x80, A: 0x80}); got != want {
 		t.Errorf("got: %v, want: %v", got, want)
 	}
 }
@@ -3461,10 +3461,10 @@ func TestImageTooManyConstantBuffersInDirectX(t *testing.T) {
 		dst1.DrawTriangles(vs, is, src, op)
 	}
 
-	if got, want := dst0.At(0, 0), (color.RGBA{0xff, 0xff, 0xff, 0xff}); got != want {
+	if got, want := dst0.At(0, 0), (color.RGBA{R: 0xff, G: 0xff, B: 0xff, A: 0xff}); got != want {
 		t.Errorf("got: %v, want: %v", got, want)
 	}
-	if got, want := dst1.At(0, 0), (color.RGBA{0xff, 0xff, 0xff, 0xff}); got != want {
+	if got, want := dst1.At(0, 0), (color.RGBA{R: 0xff, G: 0xff, B: 0xff, A: 0xff}); got != want {
 		t.Errorf("got: %v, want: %v", got, want)
 	}
 }
@@ -3473,7 +3473,7 @@ func TestImageColorMAndScale(t *testing.T) {
 	const w, h = 16, 16
 	src := ebiten.NewImage(w, h)
 
-	src.Fill(color.RGBA{0x80, 0x80, 0x80, 0x80})
+	src.Fill(color.RGBA{R: 0x80, G: 0x80, B: 0x80, A: 0x80})
 	vs := []ebiten.Vertex{
 		{
 			SrcX:   0,
@@ -3537,17 +3537,17 @@ func TestImageColorMAndScale(t *testing.T) {
 			switch format {
 			case ebiten.ColorScaleModeStraightAlpha:
 				want = color.RGBA{
-					byte(math.Floor(0xff * (0.5/alphaBeforeScale + 0.25) * alphaBeforeScale * 0.5 * 0.75)),
+					R: byte(math.Floor(0xff * (0.5/alphaBeforeScale + 0.25) * alphaBeforeScale * 0.5 * 0.75)),
-					byte(math.Floor(0xff * (0.5/alphaBeforeScale + 0.25) * alphaBeforeScale * 0.25 * 0.75)),
+					G: byte(math.Floor(0xff * (0.5/alphaBeforeScale + 0.25) * alphaBeforeScale * 0.25 * 0.75)),
-					byte(math.Floor(0xff * (0.5/alphaBeforeScale + 0.25) * alphaBeforeScale * 0.5 * 0.75)),
+					B: byte(math.Floor(0xff * (0.5/alphaBeforeScale + 0.25) * alphaBeforeScale * 0.5 * 0.75)),
-					byte(math.Floor(0xff * alphaBeforeScale * 0.75)),
+					A: byte(math.Floor(0xff * alphaBeforeScale * 0.75)),
 				}
 			case ebiten.ColorScaleModePremultipliedAlpha:
 				want = color.RGBA{
-					byte(math.Floor(0xff * (0.5/alphaBeforeScale + 0.25) * alphaBeforeScale * 0.5)),
+					R: byte(math.Floor(0xff * (0.5/alphaBeforeScale + 0.25) * alphaBeforeScale * 0.5)),
-					byte(math.Floor(0xff * (0.5/alphaBeforeScale + 0.25) * alphaBeforeScale * 0.25)),
+					G: byte(math.Floor(0xff * (0.5/alphaBeforeScale + 0.25) * alphaBeforeScale * 0.25)),
-					byte(math.Floor(0xff * (0.5/alphaBeforeScale + 0.25) * alphaBeforeScale * 0.5)),
+					B: byte(math.Floor(0xff * (0.5/alphaBeforeScale + 0.25) * alphaBeforeScale * 0.5)),
-					byte(math.Floor(0xff * alphaBeforeScale * 0.75)),
+					A: byte(math.Floor(0xff * alphaBeforeScale * 0.75)),
 				}
 			}
 			if !sameColors(got, want, 2) {
@@ -3878,9 +3878,9 @@ func TestImageAntiAliasAndBlend(t *testing.T) {
 		ebiten.BlendCopy,
 		ebiten.BlendSourceOver,
 	} {
-		dst0.Fill(color.RGBA{0x24, 0x3f, 0x6a, 0x88})
+		dst0.Fill(color.RGBA{R: 0x24, G: 0x3f, B: 0x6a, A: 0x88})
-		dst1.Fill(color.RGBA{0x24, 0x3f, 0x6a, 0x88})
+		dst1.Fill(color.RGBA{R: 0x24, G: 0x3f, B: 0x6a, A: 0x88})
-		src.Fill(color.RGBA{0x85, 0xa3, 0x08, 0xd3})
+		src.Fill(color.RGBA{R: 0x85, G: 0xa3, B: 0x08, A: 0xd3})
 
 		op0 := &ebiten.DrawTrianglesOptions{}
 		op0.Blend = blend
@@ -3947,7 +3947,7 @@ func TestImageColorMScale(t *testing.T) {
 	dst0 := ebiten.NewImage(w, h)
 	dst1 := ebiten.NewImage(w, h)
 	src := ebiten.NewImage(w, h)
-	src.Fill(color.RGBA{0x24, 0x3f, 0x6a, 0x88})
+	src.Fill(color.RGBA{R: 0x24, G: 0x3f, B: 0x6a, A: 0x88})
 
 	// As the ColorM is a diagonal matrix, a built-in shader for a color matrix is NOT used.
 	op := &ebiten.DrawImageOptions{}
@@ -3972,7 +3972,7 @@ func TestImageColorScaleAndColorM(t *testing.T) {
 	dst0 := ebiten.NewImage(w, h)
 	dst1 := ebiten.NewImage(w, h)
 	src := ebiten.NewImage(w, h)
-	src.Fill(color.RGBA{0x24, 0x3f, 0x6a, 0x88})
+	src.Fill(color.RGBA{R: 0x24, G: 0x3f, B: 0x6a, A: 0x88})
 
 	// ColorScale is applied to premultiplied-alpha colors.
 	op := &ebiten.DrawImageOptions{}
@@ -3995,9 +3995,9 @@ func TestImageColorScaleAndColorM(t *testing.T) {
 func TestImageSetAndSubImage(t *testing.T) {
 	const w, h = 16, 16
 	img := ebiten.NewImage(w, h)
-	img.Set(1, 1, color.RGBA{0xff, 0, 0, 0xff})
+	img.Set(1, 1, color.RGBA{R: 0xff, A: 0xff})
 	got := img.SubImage(image.Rect(0, 0, w, h)).At(1, 1).(color.RGBA)
-	want := color.RGBA{0xff, 0, 0, 0xff}
+	want := color.RGBA{R: 0xff, A: 0xff}
 	if got != want {
 		t.Errorf("got: %v, want: %v", got, want)
 	}

input.go

@@ -53,7 +53,7 @@ func InputChars() []rune {
 // If you want to know whether the key started being pressed in the current tick,
 // use inpututil.IsKeyJustPressed
 //
-// Note that a Key represents a pysical key of US keyboard layout.
+// Note that a Key represents a physical key of US keyboard layout.
 // For example, KeyQ represents Q key on US keyboards and ' (quote) key on Dvorak keyboards.
 //
 // Known issue: On Edge browser, some keys don't work well:
@@ -73,7 +73,7 @@ func IsKeyPressed(key Key) bool {
 // KeyName returns a key name for the current keyboard layout.
 // For example, KeyName(KeyQ) returns 'q' for a QWERTY keyboard, and returns 'a' for an AZERTY keyboard.
 //
-// KeyName returns an empty string if 1) the key doesn't have a phisical key name, 2) the platform doesn't support KeyName,
+// KeyName returns an empty string if 1) the key doesn't have a physical key name, 2) the platform doesn't support KeyName,
 // or 3) the main loop doesn't start yet.
 //
 // KeyName is supported by desktops and browsers.
@@ -113,7 +113,7 @@ func IsMouseButtonPressed(mouseButton MouseButton) bool {
 	return theInputState.isMouseButtonPressed(mouseButton)
 }
 
-// GamepadID represents a gamepad's identifier.
+// GamepadID represents a gamepad identifier.
 type GamepadID = gamepad.ID
 
 // GamepadSDLID returns a string with the GUID generated in the same way as SDL.
@@ -132,7 +132,7 @@ func GamepadSDLID(id GamepadID) string {
 
 // GamepadName returns a string with the name.
 // This function may vary in how it returns descriptions for the same device across platforms.
-// for example the following drivers/platforms see a Xbox One controller as the following:
+// for example the following drivers/platforms see an Xbox One controller as the following:
 //
 //   - Windows: "Xbox Controller"
 //   - Chrome: "Xbox 360 Controller (XInput STANDARD GAMEPAD)"
@@ -225,7 +225,7 @@ func GamepadButtonNum(id GamepadID) int {
 //
 // IsGamepadButtonPressed is concurrent-safe.
 //
-// The relationships between physical buttons and buttion IDs depend on environments.
+// The relationships between physical buttons and button IDs depend on environments.
 // There can be differences even between Chrome and Firefox.
 func IsGamepadButtonPressed(id GamepadID, button GamepadButton) bool {
 	g := gamepad.Get(id)
@@ -385,7 +385,7 @@ func TouchIDs() []TouchID {
 //
 // If the touch of the specified ID is not present, TouchPosition returns (0, 0).
 //
-// TouchPosition is cuncurrent-safe.
+// TouchPosition is concurrent-safe.
 func TouchPosition(id TouchID) (int, int) {
 	return theInputState.touchPosition(id)
 }
@@ -427,7 +427,7 @@ func (i *inputState) isKeyPressed(key Key) bool {
 	case KeyMeta:
 		return i.state.KeyPressed[ui.KeyMetaLeft] || i.state.KeyPressed[ui.KeyMetaRight]
 	default:
-		return i.state.KeyPressed[ui.Key(key)]
+		return i.state.KeyPressed[key]
 	}
 }
 

internal/atlas/image.go

@@ -47,7 +47,7 @@ func temporaryBytesSize(size int) int {
 	return l
 }
 
-// alloc allocates the pixels and reutrns it.
+// alloc allocates the pixels and returns it.
 // Be careful that the returned pixels might not be zero-cleared.
 func (t *temporaryBytes) alloc(size int) []byte {
 	if len(t.pixels) < t.pos+size {
@@ -107,7 +107,7 @@ func flushDeferred() {
 }
 
 // baseCountToPutOnAtlas represents the base time duration when the image can be put onto an atlas.
-// Actual time duration is increased in an exponential way for each usages as a rendering target.
+// Actual time duration is increased in an exponential way for each usage as a rendering target.
 const baseCountToPutOnAtlas = 10
 
 func putImagesOnAtlas(graphicsDriver graphicsdriver.Graphics) error {
@@ -163,7 +163,7 @@ var (
 
 	deferred []func()
 
-	// deferredM is a mutext for the slice operations. This must not be used for other usages.
+	// deferredM is a mutex for the slice operations. This must not be used for other usages.
 	deferredM sync.Mutex
 )
 
@@ -218,13 +218,13 @@ type Image struct {
 // moveTo moves its content to the given image dst.
 // After moveTo is called, the image i is no longer available.
 //
-// moveTo is smilar to C++'s move semantics.
+// moveTo is similar to C++'s move semantics.
 func (i *Image) moveTo(dst *Image) {
 	dst.dispose(false)
 	*dst = *i
 
 	// i is no longer available but Dispose must not be called
-	// since i and dst have the same values like node.
+	// since i and dst have the same values as node.
 	runtime.SetFinalizer(i, nil)
 }
 
@@ -421,7 +421,7 @@ func (i *Image) drawTriangles(srcs [graphics.ShaderImageCount]*Image, vertices [
 			vertices[i+2] = (vertices[i+2] + oxf) / swf
 			vertices[i+3] = (vertices[i+3] + oyf) / shf
 		}
-		// srcRegion can be delibarately empty when this is not needed in order to avoid unexpected
+		// srcRegion can be deliberately empty when this is not needed in order to avoid unexpected
 		// performance issue (#1293).
 		if srcRegion.Width != 0 && srcRegion.Height != 0 {
 			srcRegion.X += oxf
@@ -461,7 +461,7 @@ func (i *Image) drawTriangles(srcs [graphics.ShaderImageCount]*Image, vertices [
 			continue
 		}
 		if !src.isOnAtlas() && src.canBePutOnAtlas() {
-			// src might already registered, but assiging it again is not harmful.
+			// src might already registered, but assigning it again is not harmful.
 			imagesToPutOnAtlas[src] = struct{}{}
 		}
 	}

internal/atlas/image_test.go

@@ -134,11 +134,11 @@ func TestEnsureIsolated(t *testing.T) {
 			g := pix[4*(size*j+i)+1]
 			b := pix[4*(size*j+i)+2]
 			a := pix[4*(size*j+i)+3]
-			got := color.RGBA{r, g, b, a}
+			got := color.RGBA{R: r, G: g, B: b, A: a}
 			var want color.RGBA
 			if i < dx0 || dx1 <= i || j < dy0 || dy1 <= j {
 				c := byte(i + j)
-				want = color.RGBA{c, c, c, c}
+				want = color.RGBA{R: c, G: c, B: c, A: c}
 			}
 			if got != want {
 				t.Errorf("at(%d, %d): got: %v, want: %v", i, j, got, want)
@@ -202,7 +202,7 @@ func TestReputOnAtlas(t *testing.T) {
 
 	// Use img1 as a render source.
 	// Use the doubled count since img1 was on a texture atlas and became an isolated image once.
-	// Then, img1 requires longer time to recover to be on a textur atlas again.
+	// Then, img1 requires longer time to recover to be on a texture atlas again.
 	for i := 0; i < atlas.BaseCountToPutOnAtlas*2; i++ {
 		if err := atlas.PutImagesOnAtlasForTesting(ui.GraphicsDriverForTesting()); err != nil {
 			t.Fatal(err)
@@ -222,12 +222,12 @@ func TestReputOnAtlas(t *testing.T) {
 	}
 	for j := 0; j < size; j++ {
 		for i := 0; i < size; i++ {
-			want := color.RGBA{byte(i + j), byte(i + j), byte(i + j), byte(i + j)}
+			want := color.RGBA{R: byte(i + j), G: byte(i + j), B: byte(i + j), A: byte(i + j)}
 			r := pix[4*(size*j+i)]
 			g := pix[4*(size*j+i)+1]
 			b := pix[4*(size*j+i)+2]
 			a := pix[4*(size*j+i)+3]
-			got := color.RGBA{r, g, b, a}
+			got := color.RGBA{R: r, G: g, B: b, A: a}
 			if got != want {
 				t.Errorf("At(%d, %d): got: %v, want: %v", i, j, got, want)
 			}
@@ -246,12 +246,12 @@ func TestReputOnAtlas(t *testing.T) {
 	}
 	for j := 0; j < size; j++ {
 		for i := 0; i < size; i++ {
-			want := color.RGBA{byte(i + j), byte(i + j), byte(i + j), byte(i + j)}
+			want := color.RGBA{R: byte(i + j), G: byte(i + j), B: byte(i + j), A: byte(i + j)}
 			r := pix[4*(size*j+i)]
 			g := pix[4*(size*j+i)+1]
 			b := pix[4*(size*j+i)+2]
 			a := pix[4*(size*j+i)+3]
-			got := color.RGBA{r, g, b, a}
+			got := color.RGBA{R: r, G: g, B: b, A: a}
 			if got != want {
 				t.Errorf("At(%d, %d): got: %v, want: %v", i, j, got, want)
 			}
@@ -338,9 +338,9 @@ func TestExtend(t *testing.T) {
 			g := pix0[4*(w0*j+i)+1]
 			b := pix0[4*(w0*j+i)+2]
 			a := pix0[4*(w0*j+i)+3]
-			got := color.RGBA{r, g, b, a}
+			got := color.RGBA{R: r, G: g, B: b, A: a}
 			c := byte(i + w0*j)
-			want := color.RGBA{c, c, c, c}
+			want := color.RGBA{R: c, G: c, B: c, A: c}
 			if got != want {
 				t.Errorf("at(%d, %d): got: %v, want: %v", i, j, got, want)
 			}
@@ -357,9 +357,9 @@ func TestExtend(t *testing.T) {
 			g := pix1[4*(w1*j+i)+1]
 			b := pix1[4*(w1*j+i)+2]
 			a := pix1[4*(w1*j+i)+3]
-			got := color.RGBA{r, g, b, a}
+			got := color.RGBA{R: r, G: g, B: b, A: a}
 			c := byte(i + w1*j)
-			want := color.RGBA{c, c, c, c}
+			want := color.RGBA{R: c, G: c, B: c, A: c}
 			if got != want {
 				t.Errorf("at(%d, %d): got: %v, want: %v", i, j, got, want)
 			}
@@ -404,9 +404,9 @@ func TestWritePixelsAfterDrawTriangles(t *testing.T) {
 			g := pix[4*(w*j+i)+1]
 			b := pix[4*(w*j+i)+2]
 			a := pix[4*(w*j+i)+3]
-			got := color.RGBA{r, g, b, a}
+			got := color.RGBA{R: r, G: g, B: b, A: a}
 			c := byte(i + w*j)
-			want := color.RGBA{c, c, c, c}
+			want := color.RGBA{R: c, G: c, B: c, A: c}
 			if got != want {
 				t.Errorf("at(%d, %d): got %v, want: %v", i, j, got, want)
 			}
@@ -562,7 +562,7 @@ func Disable_TestMinImageSize(t *testing.T) {
 
 func TestMaxImageSizeJust(t *testing.T) {
 	s := maxImageSizeForTesting
-	// An unmanged image never belongs to an atlas and doesn't have its paddings.
+	// An unmanaged image never belongs to an atlas and doesn't have its paddings.
 	// TODO: Should we allow such this size for ImageTypeRegular?
 	img := atlas.NewImage(s, s, atlas.ImageTypeUnmanaged)
 	defer img.MarkDisposed()
@@ -620,7 +620,7 @@ func TestDisposedAndReputOnAtlas(t *testing.T) {
 		}
 	}
 
-	// Before PutImaegsOnAtlasForTesting, dispose the image.
+	// Before PutImagesOnAtlasForTesting, dispose the image.
 	src.MarkDisposed()
 
 	// Force to dispose the image.
@@ -722,12 +722,12 @@ func TestImageWritePixelsModify(t *testing.T) {
 		}
 		for j := 0; j < size; j++ {
 			for i := 0; i < size; i++ {
-				want := color.RGBA{byte(i + j), byte(i + j), byte(i + j), byte(i + j)}
+				want := color.RGBA{R: byte(i + j), G: byte(i + j), B: byte(i + j), A: byte(i + j)}
 				r := pix[4*(size*j+i)]
 				g := pix[4*(size*j+i)+1]
 				b := pix[4*(size*j+i)+2]
 				a := pix[4*(size*j+i)+3]
-				got := color.RGBA{r, g, b, a}
+				got := color.RGBA{R: r, G: g, B: b, A: a}
 				if got != want {
 					t.Errorf("Type: %d, At(%d, %d): got: %v, want: %v", typ, i, j, got, want)
 				}

internal/atlas/shader_test.go

@@ -51,7 +51,7 @@ func TestShaderFillTwice(t *testing.T) {
 	if err := dst.ReadPixels(g, pix); err != nil {
 		t.Error(err)
 	}
-	if got, want := (color.RGBA{pix[0], pix[1], pix[2], pix[3]}), (color.RGBA{0x80, 0x80, 0x80, 0xff}); got != want {
+	if got, want := (color.RGBA{R: pix[0], G: pix[1], B: pix[2], A: pix[3]}), (color.RGBA{R: 0x80, G: 0x80, B: 0x80, A: 0xff}); got != want {
 		t.Errorf("got: %v, want: %v", got, want)
 	}
 }
@@ -83,7 +83,7 @@ func TestImageDrawTwice(t *testing.T) {
 	if err := dst.ReadPixels(ui.GraphicsDriverForTesting(), pix); err != nil {
 		t.Error(err)
 	}
-	if got, want := (color.RGBA{pix[0], pix[1], pix[2], pix[3]}), (color.RGBA{0x80, 0x80, 0x80, 0xff}); got != want {
+	if got, want := (color.RGBA{R: pix[0], G: pix[1], B: pix[2], A: pix[3]}), (color.RGBA{R: 0x80, G: 0x80, B: 0x80, A: 0xff}); got != want {
 		t.Errorf("got: %v, want: %v", got, want)
 	}
 }

internal/buffered/command.go

@@ -62,7 +62,7 @@ func getDelayedFuncsAndClearSlow() []func() {
 
 // maybeCanAddDelayedCommand returns false if the delayed commands cannot be added.
 // Otherwise, maybeCanAddDelayedCommand's returning value is not determined.
-// For example, maybeCanAddDelayedCommand can return true even when flusing is being processed.
+// For example, maybeCanAddDelayedCommand can return true even when flushing is being processed.
 func maybeCanAddDelayedCommand() bool {
 	return atomic.LoadUint32(&delayedCommandsFlushed) == 0
 }

internal/buffered/image_test.go

@@ -83,7 +83,7 @@ type testResult struct {
 }
 
 var testSetBeforeMainResult = func() testResult {
-	clr := color.RGBA{1, 2, 3, 4}
+	clr := color.RGBA{R: 1, G: 2, B: 3, A: 4}
 	img := ebiten.NewImage(16, 16)
 	img.Set(0, 0, clr)
 
@@ -124,7 +124,7 @@ var testDrawImageBeforeMainResult = func() testResult {
 	}()
 
 	return testResult{
-		want: color.RGBA{0xff, 0xff, 0xff, 0xff},
+		want: color.RGBA{R: 0xff, G: 0xff, B: 0xff, A: 0xff},
 		got:  ch,
 	}
 }()
@@ -185,7 +185,7 @@ var testDrawTrianglesBeforeMainResult = func() testResult {
 	}()
 
 	return testResult{
-		want: color.RGBA{0xff, 0xff, 0xff, 0xff},
+		want: color.RGBA{R: 0xff, G: 0xff, B: 0xff, A: 0xff},
 		got:  ch,
 	}
 }()
@@ -200,10 +200,10 @@ func TestDrawTrianglesBeforeMain(t *testing.T) {
 }
 
 var testSetAndFillBeforeMainResult = func() testResult {
-	clr := color.RGBA{1, 2, 3, 4}
+	clr := color.RGBA{R: 1, G: 2, B: 3, A: 4}
 	img := ebiten.NewImage(16, 16)
 	img.Set(0, 0, clr)
-	img.Fill(color.RGBA{5, 6, 7, 8})
+	img.Fill(color.RGBA{R: 5, G: 6, B: 7, A: 8})
 	img.Set(1, 0, clr)
 
 	ch := make(chan color.RGBA, 1)
@@ -214,7 +214,7 @@ var testSetAndFillBeforeMainResult = func() testResult {
 	}()
 
 	return testResult{
-		want: color.RGBA{5, 6, 7, 8},
+		want: color.RGBA{R: 5, G: 6, B: 7, A: 8},
 		got:  ch,
 	}
 }()
@@ -229,7 +229,7 @@ func TestSetAndFillBeforeMain(t *testing.T) {
 }
 
 var testSetAndWritePixelsBeforeMainResult = func() testResult {
-	clr := color.RGBA{1, 2, 3, 4}
+	clr := color.RGBA{R: 1, G: 2, B: 3, A: 4}
 	img := ebiten.NewImage(16, 16)
 	img.Set(0, 0, clr)
 	pix := make([]byte, 4*16*16)
@@ -250,7 +250,7 @@ var testSetAndWritePixelsBeforeMainResult = func() testResult {
 	}()
 
 	return testResult{
-		want: color.RGBA{5, 6, 7, 8},
+		want: color.RGBA{R: 5, G: 6, B: 7, A: 8},
 		got:  ch,
 	}
 }()
@@ -290,7 +290,7 @@ var testWritePixelsAndModifyBeforeMainResult = func() testResult {
 	}()
 
 	return testResult{
-		want: color.RGBA{1, 2, 3, 4},
+		want: color.RGBA{R: 1, G: 2, B: 3, A: 4},
 		got:  ch,
 	}
 }()

internal/cocoa/api_cocoa_darwin.go

@@ -138,7 +138,7 @@ func (w NSWindow) SetBackgroundColor(color NSColor) {
 	w.Send(sel_setBackgroundColor, color.ID)
 }
 
-func (w NSWindow) IsVisibile() bool {
+func (w NSWindow) IsVisible() bool {
 	return w.Send(sel_isVisible) != 0
 }
 

internal/devicescale/devicescale.go

@@ -40,7 +40,7 @@ func GetAt(x, y int) float64 {
 	return s
 }
 
-// CelarCache clears the cache.
+// ClearCache clears the cache.
 // This should be called when monitors are changed by connecting or disconnecting.
 func ClearCache() {
 	// TODO: This should be called not only when monitors are changed but also a monitor's scales are changed.

internal/devicescale/impl_desktop.go

@@ -35,7 +35,7 @@ func monitorAt(x, y int) *glfw.Monitor {
 
 func impl(x, y int) float64 {
 	// Keep calling GetContentScale until the returned scale is 0 (#2051).
-	// Retry this at most 5 times to avoid an inifinite loop.
+	// Retry this at most 5 times to avoid an infinite loop.
 	for i := 0; i < 5; i++ {
 		// An error can happen e.g. when entering a screensaver on Windows (#2488).
 		sx, _, err := monitorAt(x, y).GetContentScale()

internal/gamepad/gamepad.go

@@ -99,7 +99,7 @@ func (g *gamepads) update() error {
 	}
 
 	// A gamepad can be detected even though there are not. Apparently, some special devices are
-	// recognized as gamepads by OSes. In this case, the number of the 'buttons' can exceeds the
+	// recognized as gamepads by OSes. In this case, the number of the 'buttons' can exceed the
 	// maximum. Skip such devices as a tentative solution (#1173, #2039).
 	g.remove(func(gamepad *Gamepad) bool {
 		return gamepad.ButtonCount() > ButtonCount

internal/gamepad/gamepad_darwin.go

@@ -146,24 +146,24 @@ func (g *nativeGamepadsImpl) addDevice(device _IOHIDDeviceRef, gamepads *gamepad
 	}
 
 	name := "Unknown"
-	if prop := _IOHIDDeviceGetProperty(_IOHIDDeviceRef(device), _CFStringCreateWithCString(kCFAllocatorDefault, kIOHIDProductKey, kCFStringEncodingUTF8)); prop != 0 {
+	if prop := _IOHIDDeviceGetProperty(device, _CFStringCreateWithCString(kCFAllocatorDefault, kIOHIDProductKey, kCFStringEncodingUTF8)); prop != 0 {
 		var cstr [256]byte
 		_CFStringGetCString(_CFStringRef(prop), cstr[:], kCFStringEncodingUTF8)
 		name = strings.TrimRight(string(cstr[:]), "\x00")
 	}
 
 	var vendor uint32
-	if prop := _IOHIDDeviceGetProperty(_IOHIDDeviceRef(device), _CFStringCreateWithCString(kCFAllocatorDefault, kIOHIDVendorIDKey, kCFStringEncodingUTF8)); prop != 0 {
+	if prop := _IOHIDDeviceGetProperty(device, _CFStringCreateWithCString(kCFAllocatorDefault, kIOHIDVendorIDKey, kCFStringEncodingUTF8)); prop != 0 {
 		_CFNumberGetValue(_CFNumberRef(prop), kCFNumberSInt32Type, unsafe.Pointer(&vendor))
 	}
 
 	var product uint32
-	if prop := _IOHIDDeviceGetProperty(_IOHIDDeviceRef(device), _CFStringCreateWithCString(kCFAllocatorDefault, kIOHIDProductIDKey, kCFStringEncodingUTF8)); prop != 0 {
+	if prop := _IOHIDDeviceGetProperty(device, _CFStringCreateWithCString(kCFAllocatorDefault, kIOHIDProductIDKey, kCFStringEncodingUTF8)); prop != 0 {
 		_CFNumberGetValue(_CFNumberRef(prop), kCFNumberSInt32Type, unsafe.Pointer(&product))
 	}
 
 	var version uint32
-	if prop := _IOHIDDeviceGetProperty(_IOHIDDeviceRef(device), _CFStringCreateWithCString(kCFAllocatorDefault, kIOHIDVersionNumberKey, kCFStringEncodingUTF8)); prop != 0 {
+	if prop := _IOHIDDeviceGetProperty(device, _CFStringCreateWithCString(kCFAllocatorDefault, kIOHIDVersionNumberKey, kCFStringEncodingUTF8)); prop != 0 {
 		_CFNumberGetValue(_CFNumberRef(prop), kCFNumberSInt32Type, unsafe.Pointer(&version))
 	}
 
@@ -191,8 +191,8 @@ func (g *nativeGamepadsImpl) addDevice(device _IOHIDDeviceRef, gamepads *gamepad
 	gp := gamepads.add(name, sdlID)
 	gp.native = n
 
-	for i := _CFIndex(0); i < _CFArrayGetCount(_CFArrayRef(elements)); i++ {
+	for i := _CFIndex(0); i < _CFArrayGetCount(elements); i++ {
-		native := (_IOHIDElementRef)(_CFArrayGetValueAtIndex(_CFArrayRef(elements), i))
+		native := (_IOHIDElementRef)(_CFArrayGetValueAtIndex(elements, i))
 		if _CFGetTypeID(_CFTypeRef(native)) != _IOHIDElementGetTypeID() {
 			continue
 		}

internal/gamepad/gamepad_linux.go

@@ -251,7 +251,7 @@ func (g *nativeGamepadsImpl) update(gamepads *gamepads) error {
 			Cookie: uint32(buf[8]) | uint32(buf[9])<<8 | uint32(buf[10])<<16 | uint32(buf[11])<<24,
 			Len:    uint32(buf[12]) | uint32(buf[13])<<8 | uint32(buf[14])<<16 | uint32(buf[15])<<24,
 		}
-		name := unix.ByteSliceToString(buf[16 : 16+e.Len-1]) // len includes the null termiinate.
+		name := unix.ByteSliceToString(buf[16 : 16+e.Len-1]) // len includes the null terminate.
 		buf = buf[16+e.Len:]
 		if !reEvent.MatchString(name) {
 			continue

internal/gamepad/gamepad_nintendosdk.cpp

@@ -14,7 +14,7 @@
 
 //go:build nintendosdk
 
-// The actual implementaiton will be provided by -overlay.
+// The actual implementation will be provided by -overlay.
 
 #include "gamepad_nintendosdk.h"
 

internal/gamepaddb/gamepaddb_test.go

@@ -46,7 +46,7 @@ func TestUpdate(t *testing.T) {
 			Err:   true,
 		},
 		{
-			Input: "00000000000000000000000000000000,foo,pltform:Foo",
+			Input: "00000000000000000000000000000000,foo,platform:Foo",
 			Err:   true,
 		},
 		{

internal/goglfw/api_windows.go

@@ -1651,7 +1651,7 @@ func _SetWindowPos(hWnd windows.HWND, hWndInsertAfter windows.HWND, x, y, cx, cy
 }
 
 func _SetWindowTextW(hWnd windows.HWND, str string) error {
-	// An empty string is also a valid value. Always create a uint16 pointer.
+	// An empty string is also a valid value. Always create an uint16 pointer.
 	lpString, err := windows.UTF16PtrFromString(str)
 	if err != nil {
 		panic("goglfw: str must not include a NUL character")

internal/graphics/vertex.go

@@ -67,7 +67,7 @@ func QuadVertices(dst []float32, sx0, sy0, sx1, sy1 float32, a, b, c, d, tx, ty
 	x := sx1 - sx0
 	y := sy1 - sy0
 	ax, by, cx, dy := a*x, b*y, c*x, d*y
-	u0, v0, u1, v1 := float32(sx0), float32(sy0), float32(sx1), float32(sy1)
+	u0, v0, u1, v1 := sx0, sy0, sx1, sy1
 
 	// This function is very performance-sensitive and implement in a very dumb way.
 	_ = dst[:4*VertexFloatCount]

internal/graphicscommand/command.go

@@ -29,7 +29,7 @@ import (
 //
 // A command for drawing that is created when Image functions are called like DrawTriangles,
 // or Fill.
-// A command is not immediately executed after created. Instaed, it is queued after created,
+// A command is not immediately executed after created. Instead, it is queued after created,
 // and executed only when necessary.
 type command interface {
 	fmt.Stringer
@@ -603,12 +603,12 @@ func (q *commandQueue) prependPreservedUniforms(uniforms []uint32, shader *Shade
 	idx += len(srcs) * 2
 
 	// Set the destination region.
-	uniforms[idx+0] = math.Float32bits(float32(dstRegion.X) / float32(dw))
+	uniforms[idx+0] = math.Float32bits(dstRegion.X / float32(dw))
-	uniforms[idx+1] = math.Float32bits(float32(dstRegion.Y) / float32(dh))
+	uniforms[idx+1] = math.Float32bits(dstRegion.Y / float32(dh))
 	idx += 2
 
-	uniforms[idx+0] = math.Float32bits(float32(dstRegion.Width) / float32(dw))
+	uniforms[idx+0] = math.Float32bits(dstRegion.Width / float32(dw))
-	uniforms[idx+1] = math.Float32bits(float32(dstRegion.Height) / float32(dh))
+	uniforms[idx+1] = math.Float32bits(dstRegion.Height / float32(dh))
 	idx += 2
 
 	if srcs[0] != nil {
@@ -631,12 +631,12 @@ func (q *commandQueue) prependPreservedUniforms(uniforms []uint32, shader *Shade
 	idx += len(offsets) * 2
 
 	// Set the source region of texture0.
-	uniforms[idx+0] = math.Float32bits(float32(srcRegion.X))
+	uniforms[idx+0] = math.Float32bits(srcRegion.X)
-	uniforms[idx+1] = math.Float32bits(float32(srcRegion.Y))
+	uniforms[idx+1] = math.Float32bits(srcRegion.Y)
 	idx += 2
 
-	uniforms[idx+0] = math.Float32bits(float32(srcRegion.Width))
+	uniforms[idx+0] = math.Float32bits(srcRegion.Width)
-	uniforms[idx+1] = math.Float32bits(float32(srcRegion.Height))
+	uniforms[idx+1] = math.Float32bits(srcRegion.Height)
 	idx += 2
 
 	uniforms[idx+0] = math.Float32bits(2 / float32(dw))

internal/graphicscommand/image.go

@@ -37,7 +37,7 @@ type Image struct {
 	internalHeight int
 	screen         bool
 
-	// id is an indentifier for the image. This is used only when dummping the information.
+	// id is an identifier for the image. This is used only when dumping the information.
 	//
 	// This is duplicated with graphicsdriver.Image's ID, but this id is still necessary because this image might not
 	// have its graphicsdriver.Image.

internal/graphicscommand/image_test.go

@@ -74,7 +74,7 @@ func TestClear(t *testing.T) {
 	for j := 0; j < h/2; j++ {
 		for i := 0; i < w/2; i++ {
 			idx := 4 * (i + w*j)
-			got := color.RGBA{pix[idx], pix[idx+1], pix[idx+2], pix[idx+3]}
+			got := color.RGBA{R: pix[idx], G: pix[idx+1], B: pix[idx+2], A: pix[idx+3]}
 			want := color.RGBA{}
 			if got != want {
 				t.Errorf("dst.At(%d, %d) after DrawTriangles: got %v, want: %v", i, j, got, want)
@@ -128,8 +128,8 @@ func TestShader(t *testing.T) {
 	for j := 0; j < h; j++ {
 		for i := 0; i < w; i++ {
 			idx := 4 * (i + w*j)
-			got := color.RGBA{pix[idx], pix[idx+1], pix[idx+2], pix[idx+3]}
+			got := color.RGBA{R: pix[idx], G: pix[idx+1], B: pix[idx+2], A: pix[idx+3]}
-			want := color.RGBA{0xff, 0, 0, 0xff}
+			want := color.RGBA{R: 0xff, A: 0xff}
 			if got != want {
 				t.Errorf("dst.At(%d, %d) after DrawTriangles: got %v, want: %v", i, j, got, want)
 			}

internal/graphicsdriver/directx/pipeline_windows.go

@@ -162,10 +162,10 @@ func (p *pipelineStates) drawTriangles(device *_ID3D12Device, commandList *_ID3D
 		p.constantBufferMaps[frameIndex] = append(p.constantBufferMaps[frameIndex], 0)
 	}
 
-	const bufferSizeAlignement = 256
+	const bufferSizeAlignment = 256
 	bufferSize := uint32(unsafe.Sizeof(uint32(0))) * uint32(len(uniforms))
 	if bufferSize > 0 {
-		bufferSize = ((bufferSize-1)/bufferSizeAlignement + 1) * bufferSizeAlignement
+		bufferSize = ((bufferSize-1)/bufferSizeAlignment + 1) * bufferSizeAlignment
 	}
 
 	cb := p.constantBuffers[frameIndex][idx]

internal/graphicsdriver/metal/graphics_darwin.go

@@ -452,7 +452,7 @@ func (g *Graphics) flushRenderCommandEncoderIfNeeded() {
 }
 
 func (g *Graphics) draw(dst *Image, dstRegions []graphicsdriver.DstRegion, srcs [graphics.ShaderImageCount]*Image, indexOffset int, shader *Shader, uniforms [][]uint32, blend graphicsdriver.Blend, evenOdd bool) error {
-	// When prepareing a stencil buffer, flush the current render command encoder
+	// When preparing a stencil buffer, flush the current render command encoder
 	// to make sure the stencil buffer is cleared when loading.
 	// TODO: What about clearing the stencil buffer by vertices?
 	if g.lastDst != dst || g.lastEvenOdd != evenOdd || evenOdd {
@@ -850,7 +850,7 @@ func (i *Image) WritePixels(args []*graphicsdriver.WritePixelsArgs) error {
 	w := maxX - minX
 	h := maxY - minY
 
-	// Use a temporary texture to send pixels asynchrounsly, whichever the memory is shared (e.g., iOS) or
+	// Use a temporary texture to send pixels asynchronously, whichever the memory is shared (e.g., iOS) or
 	// managed (e.g., macOS). A temporary texture is needed since ReplaceRegion tries to sync the pixel
 	// data between CPU and GPU, and doing it on the existing texture is inefficient (#1418).
 	// The texture cannot be reused until sending the pixels finishes, then create new ones for each call.

internal/graphicsdriver/metal/mtl/mtl_darwin.go

@@ -158,7 +158,7 @@ const (
 	StoreActionCustomSampleDepthStore     StoreAction = 5
 )
 
-// StorageMode defines defines the memory location and access permissions of a resource.
+// StorageMode defines the memory location and access permissions of a resource.
 //
 // Reference: https://developer.apple.com/documentation/metal/mtlstoragemode.
 type StorageMode uint8

internal/graphicsdriver/opengl/gl/procaddr_others.go

@@ -65,7 +65,7 @@ func (c *defaultContext) init() error {
 		}
 	}
 
-	// Try OpenGL first. OpenGL is preferrable as this doesn't cause context losts.
+	// Try OpenGL first. OpenGL is preferable as this doesn't cause context losses.
 	if !preferES {
 		// Usually libGL.so or libGL.so.1 is used. libGL.so.2 might exist only on NetBSD.
 		for _, name := range []string{"libGL.so", "libGL.so.2", "libGL.so.1", "libGL.so.0"} {

internal/graphicsdriver/opengl/graphics.go

@@ -70,7 +70,7 @@ func (g *Graphics) End(present bool) error {
 }
 
 func (g *Graphics) SetTransparent(transparent bool) {
-	// Do nothings.
+	// Do nothing.
 }
 
 func (g *Graphics) checkSize(width, height int) {

internal/jsutil/buf_js.go

@@ -57,7 +57,7 @@ func ensureTemporaryArrayBufferSize(byteLength int) {
 	}
 }
 
-// TemporaryUint8ArrayFromUint8Slice returns a Uint8Array whose length is at least minLength from a uint8 slice.
+// TemporaryUint8ArrayFromUint8Slice returns a Uint8Array whose length is at least minLength from an uint8 slice.
 // Be careful that the length can exceed the given minLength.
 // data must be a slice of a numeric type for initialization, or nil if you don't need initialization.
 func TemporaryUint8ArrayFromUint8Slice(minLength int, data []uint8) js.Value {
@@ -66,7 +66,7 @@ func TemporaryUint8ArrayFromUint8Slice(minLength int, data []uint8) js.Value {
 	return temporaryUint8Array
 }
 
-// TemporaryUint8ArrayFromUint16Slice returns a Uint8Array whose length is at least minLength from a uint16 slice.
+// TemporaryUint8ArrayFromUint16Slice returns a Uint8Array whose length is at least minLength from an uint16 slice.
 // Be careful that the length can exceed the given minLength.
 // data must be a slice of a numeric type for initialization, or nil if you don't need initialization.
 func TemporaryUint8ArrayFromUint16Slice(minLength int, data []uint16) js.Value {

internal/packing/packing.go

@@ -159,7 +159,7 @@ func alloc(n *Node, width, height int) *Node {
 				parent: n,
 			}
 		} else {
-			// Split holizontally
+			// Split horizontally
 			n.child0 = &Node{
 				x:      n.x,
 				y:      n.y,

internal/processtest/testdata/issue1753.go

@@ -58,7 +58,7 @@ func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
 
 		// Dispose the shader. When a new shader is created in the next phase, the underlying shader ID might be reused.
 		// This test checks that the new shader works in this situation.
-		// The actual disposal will happen after this frame and before the next frame in the current implmentation.
+		// The actual disposal will happen after this frame and before the next frame in the current implementation.
 		s.Dispose()
 
 		g.phase++

internal/restorable/image.go

@@ -97,7 +97,7 @@ const (
 	//
 	// Regular non-volatile images need to record drawing history or read its pixels from GPU if necessary so that all
 	// the images can be restored automatically from the context lost. However, such recording the drawing history or
-	// reading pixels from GPU are expensive operations. Volatile images can skip such oprations, but the image content
+	// reading pixels from GPU are expensive operations. Volatile images can skip such operations, but the image content
 	// is cleared every frame instead.
 	ImageTypeVolatile
 )
@@ -168,7 +168,7 @@ func ensureWhiteImage() *Image {
 	return whiteImage
 }
 
-// NewImage creates an white image with the given size.
+// NewImage creates a white image with the given size.
 //
 // The returned image is cleared.
 //
@@ -302,7 +302,7 @@ func (i *Image) WritePixels(pixels []byte, x, y, width, height int) {
 	}
 
 	// TODO: Avoid making other images stale if possible. (#514)
-	// For this purpuse, images should remember which part of that is used for DrawTriangles.
+	// For this purpose, images should remember which part of that is used for DrawTriangles.
 	theImages.makeStaleIfDependingOn(i)
 
 	if pixels != nil {
@@ -550,7 +550,7 @@ func (i *Image) dependsOnShader(shader *Shader) bool {
 	return false
 }
 
-// dependingImages returns all images that is depended by the image.
+// dependingImages returns all images that is depended on the image.
 func (i *Image) dependingImages() map[*Image]struct{} {
 	r := map[*Image]struct{}{}
 	for _, c := range i.drawTrianglesHistory {

internal/restorable/images.go

@@ -235,7 +235,7 @@ func (i *images) restore(graphicsDriver graphicsdriver.Graphics) error {
 		}
 	}
 	for len(images) > 0 {
-		// current repesents images that have no incoming edges.
+		// current represents images that have no incoming edges.
 		current := map[*Image]struct{}{}
 		for i := range images {
 			current[i] = struct{}{}

internal/restorable/images_test.go

@@ -34,7 +34,7 @@ func TestMain(m *testing.M) {
 func pixelsToColor(p *restorable.Pixels, i, j, imageWidth, imageHeight int) color.RGBA {
 	var pix [4]byte
 	p.ReadPixels(pix[:], i, j, 1, 1, imageWidth, imageHeight)
-	return color.RGBA{pix[0], pix[1], pix[2], pix[3]}
+	return color.RGBA{R: pix[0], G: pix[1], B: pix[2], A: pix[3]}
 }
 
 func abs(x int) int {
@@ -60,7 +60,7 @@ func TestRestore(t *testing.T) {
 	img0 := restorable.NewImage(1, 1, restorable.ImageTypeRegular)
 	defer img0.Dispose()
 
-	clr0 := color.RGBA{0x00, 0x00, 0x00, 0xff}
+	clr0 := color.RGBA{A: 0xff}
 	img0.WritePixels([]byte{clr0.R, clr0.G, clr0.B, clr0.A}, 0, 0, 1, 1)
 	if err := restorable.ResolveStaleImages(ui.GraphicsDriverForTesting(), false); err != nil {
 		t.Fatal(err)
@@ -90,7 +90,7 @@ func TestRestoreWithoutDraw(t *testing.T) {
 
 	for j := 0; j < 1024; j++ {
 		for i := 0; i < 1024; i++ {
-			want := color.RGBA{0x00, 0x00, 0x00, 0x00}
+			want := color.RGBA{}
 			got := pixelsToColor(img0.BasePixelsForTesting(), i, j, 1024, 1024)
 			if !sameColors(got, want, 0) {
 				t.Errorf("got %v, want %v", got, want)
@@ -134,7 +134,7 @@ func TestRestoreChain(t *testing.T) {
 			img.Dispose()
 		}
 	}()
-	clr := color.RGBA{0x00, 0x00, 0x00, 0xff}
+	clr := color.RGBA{A: 0xff}
 	imgs[0].WritePixels([]byte{clr.R, clr.G, clr.B, clr.A}, 0, 0, 1, 1)
 	for i := 0; i < num-1; i++ {
 		vs := quadVertices(imgs[i], 1, 1, 0, 0)
@@ -179,11 +179,11 @@ func TestRestoreChain2(t *testing.T) {
 		}
 	}()
 
-	clr0 := color.RGBA{0xff, 0x00, 0x00, 0xff}
+	clr0 := color.RGBA{R: 0xff, A: 0xff}
 	imgs[0].WritePixels([]byte{clr0.R, clr0.G, clr0.B, clr0.A}, 0, 0, w, h)
-	clr7 := color.RGBA{0x00, 0xff, 0x00, 0xff}
+	clr7 := color.RGBA{G: 0xff, A: 0xff}
 	imgs[7].WritePixels([]byte{clr7.R, clr7.G, clr7.B, clr7.A}, 0, 0, w, h)
-	clr8 := color.RGBA{0x00, 0x00, 0xff, 0xff}
+	clr8 := color.RGBA{B: 0xff, A: 0xff}
 	imgs[8].WritePixels([]byte{clr8.R, clr8.G, clr8.B, clr8.A}, 0, 0, w, h)
 
 	is := graphics.QuadIndices()
@@ -232,8 +232,8 @@ func TestRestoreOverrideSource(t *testing.T) {
 		img1.Dispose()
 		img0.Dispose()
 	}()
-	clr0 := color.RGBA{0x00, 0x00, 0x00, 0xff}
+	clr0 := color.RGBA{A: 0xff}
-	clr1 := color.RGBA{0x00, 0x00, 0x01, 0xff}
+	clr1 := color.RGBA{B: 0x01, A: 0xff}
 	img1.WritePixels([]byte{clr0.R, clr0.G, clr0.B, clr0.A}, 0, 0, w, h)
 	is := graphics.QuadIndices()
 	dr := graphicsdriver.Region{
@@ -404,7 +404,7 @@ func TestRestoreComplexGraph(t *testing.T) {
 		for i := 0; i < 4; i++ {
 			want := color.RGBA{}
 			if c.out[i] == '*' {
-				want = color.RGBA{0xff, 0xff, 0xff, 0xff}
+				want = color.RGBA{R: 0xff, G: 0xff, B: 0xff, A: 0xff}
 			}
 			got := pixelsToColor(c.image.BasePixelsForTesting(), i, 0, w, h)
 			if !sameColors(got, want, 1) {
@@ -473,7 +473,7 @@ func TestRestoreRecursive(t *testing.T) {
 		for i := 0; i < 4; i++ {
 			want := color.RGBA{}
 			if c.out[i] == '*' {
-				want = color.RGBA{0xff, 0xff, 0xff, 0xff}
+				want = color.RGBA{R: 0xff, G: 0xff, B: 0xff, A: 0xff}
 			}
 			got := pixelsToColor(c.image.BasePixelsForTesting(), i, 0, w, h)
 			if !sameColors(got, want, 1) {
@@ -492,7 +492,7 @@ func TestWritePixels(t *testing.T) {
 		pix[i] = 0xff
 	}
 	img.WritePixels(pix, 5, 7, 4, 4)
-	// Check the region (5, 7)-(9, 11). Outside state is indeterministic.
+	// Check the region (5, 7)-(9, 11). Outside state is indeterminate.
 	for i := range pix {
 		pix[i] = 0
 	}
@@ -502,8 +502,8 @@ func TestWritePixels(t *testing.T) {
 	for j := 7; j < 11; j++ {
 		for i := 5; i < 9; i++ {
 			idx := 4 * ((j-7)*4 + i - 5)
-			got := color.RGBA{pix[idx], pix[idx+1], pix[idx+2], pix[idx+3]}
+			got := color.RGBA{R: pix[idx], G: pix[idx+1], B: pix[idx+2], A: pix[idx+3]}
-			want := color.RGBA{0xff, 0xff, 0xff, 0xff}
+			want := color.RGBA{R: 0xff, G: 0xff, B: 0xff, A: 0xff}
 			if got != want {
 				t.Errorf("(%d, %d): got: %v, want: %v", i, j, got, want)
 			}
@@ -521,8 +521,8 @@ func TestWritePixels(t *testing.T) {
 	for j := 7; j < 11; j++ {
 		for i := 5; i < 9; i++ {
 			idx := 4 * ((j-7)*4 + i - 5)
-			got := color.RGBA{pix[idx], pix[idx+1], pix[idx+2], pix[idx+3]}
+			got := color.RGBA{R: pix[idx], G: pix[idx+1], B: pix[idx+2], A: pix[idx+3]}
-			want := color.RGBA{0xff, 0xff, 0xff, 0xff}
+			want := color.RGBA{R: 0xff, G: 0xff, B: 0xff, A: 0xff}
 			if got != want {
 				t.Errorf("(%d, %d): got: %v, want: %v", i, j, got, want)
 			}
@@ -562,8 +562,8 @@ func TestDrawTrianglesAndWritePixels(t *testing.T) {
 	if err := img1.ReadPixels(ui.GraphicsDriverForTesting(), pix[:], 0, 0, 1, 1); err != nil {
 		t.Fatal(err)
 	}
-	got := color.RGBA{pix[0], pix[1], pix[2], pix[3]}
+	got := color.RGBA{R: pix[0], G: pix[1], B: pix[2], A: pix[3]}
-	want := color.RGBA{0xff, 0xff, 0xff, 0xff}
+	want := color.RGBA{R: 0xff, G: 0xff, B: 0xff, A: 0xff}
 	if !sameColors(got, want, 1) {
 		t.Errorf("got: %v, want: %v", got, want)
 	}
@@ -606,8 +606,8 @@ func TestDispose(t *testing.T) {
 	if err := img0.ReadPixels(ui.GraphicsDriverForTesting(), pix[:], 0, 0, 1, 1); err != nil {
 		t.Fatal(err)
 	}
-	got := color.RGBA{pix[0], pix[1], pix[2], pix[3]}
+	got := color.RGBA{R: pix[0], G: pix[1], B: pix[2], A: pix[3]}
-	want := color.RGBA{0xff, 0xff, 0xff, 0xff}
+	want := color.RGBA{R: 0xff, G: 0xff, B: 0xff, A: 0xff}
 	if !sameColors(got, want, 1) {
 		t.Errorf("got: %v, want: %v", got, want)
 	}
@@ -631,52 +631,52 @@ func TestWritePixelsPart(t *testing.T) {
 		{
 			i:    0,
 			j:    0,
-			want: color.RGBA{0, 0, 0, 0},
+			want: color.RGBA{},
 		},
 		{
 			i:    3,
 			j:    0,
-			want: color.RGBA{0, 0, 0, 0},
+			want: color.RGBA{},
 		},
 		{
 			i:    0,
 			j:    1,
-			want: color.RGBA{0, 0, 0, 0},
+			want: color.RGBA{},
 		},
 		{
 			i:    1,
 			j:    1,
-			want: color.RGBA{0xff, 0xff, 0xff, 0xff},
+			want: color.RGBA{R: 0xff, G: 0xff, B: 0xff, A: 0xff},
 		},
 		{
 			i:    3,
 			j:    1,
-			want: color.RGBA{0, 0, 0, 0},
+			want: color.RGBA{},
 		},
 		{
 			i:    0,
 			j:    2,
-			want: color.RGBA{0, 0, 0, 0},
+			want: color.RGBA{},
 		},
 		{
 			i:    2,
 			j:    2,
-			want: color.RGBA{0xff, 0xff, 0xff, 0xff},
+			want: color.RGBA{R: 0xff, G: 0xff, B: 0xff, A: 0xff},
 		},
 		{
 			i:    3,
 			j:    2,
-			want: color.RGBA{0, 0, 0, 0},
+			want: color.RGBA{},
 		},
 		{
 			i:    0,
 			j:    3,
-			want: color.RGBA{0, 0, 0, 0},
+			want: color.RGBA{},
 		},
 		{
 			i:    3,
 			j:    3,
-			want: color.RGBA{0, 0, 0, 0},
+			want: color.RGBA{},
 		},
 	}
 	for _, c := range cases {
@@ -717,9 +717,9 @@ func TestWritePixelsOnly(t *testing.T) {
 			var want color.RGBA
 			switch {
 			case idx == 0:
-				want = color.RGBA{5, 6, 7, 8}
+				want = color.RGBA{R: 5, G: 6, B: 7, A: 8}
 			case idx%5 == 0:
-				want = color.RGBA{1, 2, 3, 4}
+				want = color.RGBA{R: 1, G: 2, B: 3, A: 4}
 			}
 			got := pixelsToColor(img0.BasePixelsForTesting(), i, j, w, h)
 			if !sameColors(got, want, 0) {
@@ -734,7 +734,7 @@ func TestWritePixelsOnly(t *testing.T) {
 	if err := restorable.RestoreIfNeeded(ui.GraphicsDriverForTesting()); err != nil {
 		t.Fatal(err)
 	}
-	want := color.RGBA{1, 2, 3, 4}
+	want := color.RGBA{R: 1, G: 2, B: 3, A: 4}
 	got := pixelsToColor(img1.BasePixelsForTesting(), 0, 0, w, h)
 	if !sameColors(got, want, 0) {
 		t.Errorf("got %v, want %v", got, want)
@@ -836,10 +836,10 @@ func TestAllowWritePixelsForPartAfterDrawTriangles(t *testing.T) {
 	}
 	for j := 0; j < h; j++ {
 		for i := 0; i < w; i++ {
-			got := color.RGBA{result[4*(j*w+i)], result[4*(j*w+i)+1], result[4*(j*w+i)+2], result[4*(j*w+i)+3]}
+			got := color.RGBA{R: result[4*(j*w+i)], G: result[4*(j*w+i)+1], B: result[4*(j*w+i)+2], A: result[4*(j*w+i)+3]}
 			var want color.RGBA
 			if i >= 2 || j >= 2 {
-				want = color.RGBA{0xff, 0xff, 0xff, 0xff}
+				want = color.RGBA{R: 0xff, G: 0xff, B: 0xff, A: 0xff}
 			}
 			if got != want {
 				t.Errorf("color at (%d, %d): got: %v, want: %v", i, j, got, want)
@@ -948,8 +948,8 @@ func TestMutateSlices(t *testing.T) {
 	for j := 0; j < h; j++ {
 		for i := 0; i < w; i++ {
 			idx := 4 * (j*w + i)
-			want := color.RGBA{srcPix[idx], srcPix[idx+1], srcPix[idx+2], srcPix[idx+3]}
+			want := color.RGBA{R: srcPix[idx], G: srcPix[idx+1], B: srcPix[idx+2], A: srcPix[idx+3]}
-			got := color.RGBA{dstPix[idx], dstPix[idx+1], dstPix[idx+2], dstPix[idx+3]}
+			got := color.RGBA{R: dstPix[idx], G: dstPix[idx+1], B: dstPix[idx+2], A: dstPix[idx+3]}
 			if !sameColors(got, want, 1) {
 				t.Errorf("(%d, %d): got %v, want %v", i, j, got, want)
 			}
@@ -1005,7 +1005,7 @@ func TestOverlappedPixels(t *testing.T) {
 	for j := 0; j < 3; j++ {
 		for i := 0; i < 3; i++ {
 			idx := 4 * (j*3 + i)
-			got := color.RGBA{result[idx], result[idx+1], result[idx+2], result[idx+3]}
+			got := color.RGBA{R: result[idx], G: result[idx+1], B: result[idx+2], A: result[idx+3]}
 			want := wantColors[3*j+i]
 			if got != want {
 				t.Errorf("color at (%d, %d): got %v, want: %v", i, j, got, want)
@@ -1034,7 +1034,7 @@ func TestOverlappedPixels(t *testing.T) {
 	for j := 0; j < 3; j++ {
 		for i := 0; i < 3; i++ {
 			idx := 4 * (j*3 + i)
-			got := color.RGBA{result[idx], result[idx+1], result[idx+2], result[idx+3]}
+			got := color.RGBA{R: result[idx], G: result[idx+1], B: result[idx+2], A: result[idx+3]}
 			want := wantColors[3*j+i]
 			if got != want {
 				t.Errorf("color at (%d, %d): got %v, want: %v", i, j, got, want)
@@ -1073,7 +1073,7 @@ func TestOverlappedPixels(t *testing.T) {
 	for j := 0; j < 3; j++ {
 		for i := 0; i < 3; i++ {
 			idx := 4 * (j*3 + i)
-			got := color.RGBA{result[idx], result[idx+1], result[idx+2], result[idx+3]}
+			got := color.RGBA{R: result[idx], G: result[idx+1], B: result[idx+2], A: result[idx+3]}
 			want := wantColors[3*j+i]
 			if got != want {
 				t.Errorf("color at (%d, %d): got %v, want: %v", i, j, got, want)
@@ -1094,7 +1094,7 @@ func TestOverlappedPixels(t *testing.T) {
 	for j := 0; j < 3; j++ {
 		for i := 0; i < 3; i++ {
 			idx := 4 * (j*3 + i)
-			got := color.RGBA{result[idx], result[idx+1], result[idx+2], result[idx+3]}
+			got := color.RGBA{R: result[idx], G: result[idx+1], B: result[idx+2], A: result[idx+3]}
 			want := wantColors[3*j+i]
 			if got != want {
 				t.Errorf("color at (%d, %d): got %v, want: %v", i, j, got, want)
@@ -1125,7 +1125,7 @@ func TestDrawTrianglesAndReadPixels(t *testing.T) {
 	if err := dst.ReadPixels(ui.GraphicsDriverForTesting(), pix, 0, 0, w, h); err != nil {
 		t.Fatal(err)
 	}
-	if got, want := (color.RGBA{pix[0], pix[1], pix[2], pix[3]}), (color.RGBA{0x80, 0x80, 0x80, 0x80}); !sameColors(got, want, 1) {
+	if got, want := (color.RGBA{R: pix[0], G: pix[1], B: pix[2], A: pix[3]}), (color.RGBA{R: 0x80, G: 0x80, B: 0x80, A: 0x80}); !sameColors(got, want, 1) {
 		t.Errorf("got: %v, want: %v", got, want)
 	}
 }

internal/restorable/shader_test.go

@@ -73,7 +73,7 @@ func TestShader(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	want := color.RGBA{0xff, 0, 0, 0xff}
+	want := color.RGBA{R: 0xff, A: 0xff}
 	got := pixelsToColor(img.BasePixelsForTesting(), 0, 0, 1, 1)
 	if !sameColors(got, want, 1) {
 		t.Errorf("got %v, want %v", got, want)
@@ -110,7 +110,7 @@ func TestShaderChain(t *testing.T) {
 	}
 
 	for i, img := range imgs {
-		want := color.RGBA{0xff, 0, 0, 0xff}
+		want := color.RGBA{R: 0xff, A: 0xff}
 		got := pixelsToColor(img.BasePixelsForTesting(), 0, 0, 1, 1)
 		if !sameColors(got, want, 1) {
 			t.Errorf("%d: got %v, want %v", i, got, want)
@@ -149,7 +149,7 @@ func TestShaderMultipleSources(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	want := color.RGBA{0x40, 0x80, 0xc0, 0xff}
+	want := color.RGBA{R: 0x40, G: 0x80, B: 0xc0, A: 0xff}
 	got := pixelsToColor(dst.BasePixelsForTesting(), 0, 0, 1, 1)
 	if !sameColors(got, want, 1) {
 		t.Errorf("got %v, want %v", got, want)
@@ -190,7 +190,7 @@ func TestShaderMultipleSourcesOnOneTexture(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	want := color.RGBA{0x40, 0x80, 0xc0, 0xff}
+	want := color.RGBA{R: 0x40, G: 0x80, B: 0xc0, A: 0xff}
 	got := pixelsToColor(dst.BasePixelsForTesting(), 0, 0, 1, 1)
 	if !sameColors(got, want, 1) {
 		t.Errorf("got %v, want %v", got, want)
@@ -210,7 +210,7 @@ func TestShaderDispose(t *testing.T) {
 	}
 	img.DrawTriangles([graphics.ShaderImageCount]*restorable.Image{}, [graphics.ShaderImageCount - 1][2]float32{}, quadVertices(nil, 1, 1, 0, 0), graphics.QuadIndices(), graphicsdriver.BlendCopy, dr, graphicsdriver.Region{}, s, nil, false)
 
-	// Dispose the shader. This should invalidates all the images using this shader i.e., all the images become
+	// Dispose the shader. This should invalidate all the images using this shader i.e., all the images become
 	// stale.
 	s.Dispose()
 
@@ -221,7 +221,7 @@ func TestShaderDispose(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	want := color.RGBA{0xff, 0, 0, 0xff}
+	want := color.RGBA{R: 0xff, A: 0xff}
 	got := pixelsToColor(img.BasePixelsForTesting(), 0, 0, 1, 1)
 	if !sameColors(got, want, 1) {
 		t.Errorf("got %v, want %v", got, want)

internal/shader/syntax_test.go

@@ -308,7 +308,7 @@ func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
 	}
 }
 
-func TestSyntaxUnspportedSyntax(t *testing.T) {
+func TestSyntaxUnsupportedSyntax(t *testing.T) {
 	if _, err := compileToIR([]byte(`package main
 
 func Fragment(position vec4, texCoord vec2, color vec4) vec4 {

internal/shaderir/program.go

@@ -46,7 +46,7 @@ type Func struct {
 
 // VertexFunc takes pseudo params, and the number if len(attributes) + len(varyings) + 1.
 // If 0 <= index < len(attributes), the params are in-params and represent attribute variables.
-// If index == len(attributes), the param is an out-param and repesents the position in vec4 (gl_Position in GLSL)
+// If index == len(attributes), the param is an out-param and represents the position in vec4 (gl_Position in GLSL)
 // If len(attributes) + 1 <= index < len(attributes) + len(varyings) + 1, the params are out-params and represent
 // varying variables.
 type VertexFunc struct {
@@ -55,7 +55,7 @@ type VertexFunc struct {
 
 // FragmentFunc takes pseudo params, and the number is len(varyings) + 2.
 // If index == 0, the param represents the coordinate of the fragment (gl_FragCoord in GLSL).
-// If 0 < index <= len(varyings), the param represents (index-1)th verying variable.
+// If 0 < index <= len(varyings), the param represents (index-1)th varying variable.
 type FragmentFunc struct {
 	Block *Block
 }

internal/ui/egl_nintendosdk.go

@@ -70,7 +70,7 @@ func (e *egl) init(nativeWindowHandle C.NativeWindowType) error {
 
 	// Create new context and set it as current.
 	contextAttribs := []C.EGLint{
-		// Set target garaphics api version.
+		// Set target graphics api version.
 		C.EGL_CONTEXT_MAJOR_VERSION, 2,
 		C.EGL_CONTEXT_MINOR_VERSION, 1,
 		// For debug callback

internal/ui/ui_glfw_darwin.go

@@ -33,13 +33,13 @@ var (
 	class_EbitengineWindowDelegate objc.Class
 )
 
-type windowDelgate struct {
+type windowDelegate struct {
 	isa           objc.Class `objc:"EbitengineWindowDelegate : NSObject <NSWindowDelegate>"`
 	origDelegate  objc.ID
 	origResizable bool
 }
 
-func (w *windowDelgate) pushResizableState(win objc.ID) {
+func (w *windowDelegate) pushResizableState(win objc.ID) {
 	window := cocoa.NSWindow{ID: win}
 	w.origResizable = window.StyleMask()&cocoa.NSWindowStyleMaskResizable != 0
 	if !w.origResizable {
@@ -47,7 +47,7 @@ func (w *windowDelgate) pushResizableState(win objc.ID) {
 	}
 }
 
-func (w *windowDelgate) popResizableState(win objc.ID) {
+func (w *windowDelegate) popResizableState(win objc.ID) {
 	if !w.origResizable {
 		window := cocoa.NSWindow{ID: win}
 		window.SetStyleMask(window.StyleMask() & ^uint(cocoa.NSWindowStyleMaskResizable))
@@ -55,10 +55,10 @@ func (w *windowDelgate) popResizableState(win objc.ID) {
 	w.origResizable = false
 }
 
-func (w *windowDelgate) InitWithOrigDelegate(cmd objc.SEL, origDelegate objc.ID) objc.ID {
+func (w *windowDelegate) InitWithOrigDelegate(cmd objc.SEL, origDelegate objc.ID) objc.ID {
 	self := objc.ID(unsafe.Pointer(w)).SendSuper(sel_init)
 	if self != 0 {
-		w = *(**windowDelgate)(unsafe.Pointer(&self))
+		w = *(**windowDelegate)(unsafe.Pointer(&self))
 		w.origDelegate = origDelegate
 	}
 	return self
@@ -67,56 +67,56 @@ func (w *windowDelgate) InitWithOrigDelegate(cmd objc.SEL, origDelegate objc.ID)
 // The method set of origDelegate_ must sync with GLFWWindowDelegate's implementation.
 // See cocoa_window.m in GLFW.
 
-func (w *windowDelgate) WindowShouldClose(cmd objc.SEL, notification objc.ID) bool {
+func (w *windowDelegate) WindowShouldClose(cmd objc.SEL, notification objc.ID) bool {
 	return w.origDelegate.Send(cmd, notification) != 0
 }
 
-func (w *windowDelgate) WindowDidResize(cmd objc.SEL, notification objc.ID) {
+func (w *windowDelegate) WindowDidResize(cmd objc.SEL, notification objc.ID) {
 	w.origDelegate.Send(cmd, notification)
 }
 
-func (w *windowDelgate) WindowDidMove(cmd objc.SEL, notification objc.ID) {
+func (w *windowDelegate) WindowDidMove(cmd objc.SEL, notification objc.ID) {
 	w.origDelegate.Send(cmd, notification)
 }
 
-func (w *windowDelgate) WindowDidMiniaturize(cmd objc.SEL, notification objc.ID) {
+func (w *windowDelegate) WindowDidMiniaturize(cmd objc.SEL, notification objc.ID) {
 	w.origDelegate.Send(cmd, notification)
 }
 
-func (w *windowDelgate) WindowDidDeminiaturize(cmd objc.SEL, notification objc.ID) {
+func (w *windowDelegate) WindowDidDeminiaturize(cmd objc.SEL, notification objc.ID) {
 	w.origDelegate.Send(cmd, notification)
 }
 
-func (w *windowDelgate) WindowDidBecomeKey(cmd objc.SEL, notification objc.ID) {
+func (w *windowDelegate) WindowDidBecomeKey(cmd objc.SEL, notification objc.ID) {
 	w.origDelegate.Send(cmd, notification)
 }
 
-func (w *windowDelgate) WindowDidResignKey(cmd objc.SEL, notification objc.ID) {
+func (w *windowDelegate) WindowDidResignKey(cmd objc.SEL, notification objc.ID) {
 	w.origDelegate.Send(cmd, notification)
 }
 
-func (w *windowDelgate) WindowDidChangeOcclusionState(cmd objc.SEL, notification objc.ID) {
+func (w *windowDelegate) WindowDidChangeOcclusionState(cmd objc.SEL, notification objc.ID) {
 	w.origDelegate.Send(cmd, notification)
 }
 
-func (w *windowDelgate) WindowWillEnterFullScreen(cmd objc.SEL, notification objc.ID) {
+func (w *windowDelegate) WindowWillEnterFullScreen(cmd objc.SEL, notification objc.ID) {
 	w.pushResizableState(cocoa.NSNotification{ID: notification}.Object())
 }
 
-func (w *windowDelgate) WindowDidEnterFullScreen(cmd objc.SEL, notification objc.ID) {
+func (w *windowDelegate) WindowDidEnterFullScreen(cmd objc.SEL, notification objc.ID) {
 	w.popResizableState(cocoa.NSNotification{ID: notification}.Object())
 }
 
-func (w *windowDelgate) WindowWillExitFullScreen(cmd objc.SEL, notification objc.ID) {
+func (w *windowDelegate) WindowWillExitFullScreen(cmd objc.SEL, notification objc.ID) {
 	w.pushResizableState(cocoa.NSNotification{ID: notification}.Object())
 }
 
-func (w *windowDelgate) WindowDidExitFullScreen(cmd objc.SEL, notification objc.ID) {
+func (w *windowDelegate) WindowDidExitFullScreen(cmd objc.SEL, notification objc.ID) {
 	w.popResizableState(cocoa.NSNotification{ID: notification}.Object())
 	// Do not call setFrame here (#2295). setFrame here causes unexpected results.
 }
 
-func (w *windowDelgate) Selector(cmd string) objc.SEL {
+func (w *windowDelegate) Selector(cmd string) objc.SEL {
 	switch cmd {
 	case "InitWithOrigDelegate":
 		return sel_initWithOrigDelegate
@@ -151,7 +151,7 @@ func (w *windowDelgate) Selector(cmd string) objc.SEL {
 
 func init() {
 	var err error
-	class_EbitengineWindowDelegate, err = objc.RegisterClass(&windowDelgate{})
+	class_EbitengineWindowDelegate, err = objc.RegisterClass(&windowDelegate{})
 	if err != nil {
 		panic(err)
 	}
@@ -278,7 +278,7 @@ func monitorFromWindowByOS(w *glfw.Window) *glfw.Monitor {
 	window := cocoa.NSWindow{ID: objc.ID(w.GetCocoaWindow())}
 	pool := cocoa.NSAutoreleasePool_new()
 	screen := cocoa.NSScreen_mainScreen()
-	if window.ID != 0 && window.IsVisibile() {
+	if window.ID != 0 && window.IsVisible() {
 		// When the window is visible, the window is already initialized.
 		// [NSScreen mainScreen] sometimes tells a lie when the window is put across monitors (#703).
 		screen = window.Screen()

internal/ui/ui_glfw_unix.go

@@ -90,7 +90,7 @@ func videoModeScaleUncached(m *glfw.Monitor) float64 {
 	// Note: GLFW currently returns physical pixel sizes,
 	// but we need to predict the window system-side size of the fullscreen window
 	// for Ebiten's `ScreenSizeInFullscreen` public API.
-	// Also at the moment we need this prior to switching to fullscreen, but that might be replacable.
+	// Also at the moment we need this prior to switching to fullscreen, but that might be replaceable.
 	// So this function computes the ratio of physical per logical pixels.
 	xconn, err := xgb.NewConn()
 	if err != nil {

internal/ui/ui_glfw_windows.go

@@ -135,7 +135,7 @@ func monitorFromWindowByOS(w *glfw.Window) *glfw.Monitor {
 
 func monitorFromWin32Window(w windows.HWND) *glfw.Monitor {
 	// Get the current monitor by the window handle instead of the window position. It is because the window
-	// position is not relaiable in some cases e.g. when the window is put across multiple monitors.
+	// position is not reliable in some cases e.g. when the window is put across multiple monitors.
 
 	m := _MonitorFromWindow(w, _MONITOR_DEFAULTTONEAREST)
 	if m == 0 {

run.go

@@ -120,7 +120,7 @@ type FinalScreenDrawer interface {
 	//
 	// geoM is the default geometry matrix to render the offscreen onto the final screen.
 	// geoM scales the offscreen to fit the final screen without changing the aspect ratio, and
-	// translates the offscreen to put it on the center of the final screen.
+	// translates the offscreen to put it in the center of the final screen.
 	DrawFinalScreen(screen FinalScreen, offscreen *Image, geoM GeoM)
 }
 
@@ -201,7 +201,7 @@ var Termination = ui.RegularTermination
 //
 // If game implements FinalScreenDrawer, its DrawFinalScreen is called after Draw.
 // The argument screen represents the final screen. The argument offscreen is an offscreen modified at Draw.
-// If game does not implement FinalScreenDrawer, the dafault rendering for the final screen is used.
+// If game does not implement FinalScreenDrawer, the default rendering for the final screen is used.
 //
 // game's functions are called on the same goroutine.
 //
@@ -229,7 +229,7 @@ func RunGame(game Game) error {
 	return RunGameWithOptions(game, nil)
 }
 
-// RungameOptions represents options for RunGameWithOptions.
+// RunGameOptions represents options for RunGameWithOptions.
 type RunGameOptions struct {
 	// GraphicsLibrary is a graphics library Ebitengine will use.
 	//
@@ -264,7 +264,7 @@ type RunGameOptions struct {
 //
 // If game implements FinalScreenDrawer, its DrawFinalScreen is called after Draw.
 // The argument screen represents the final screen. The argument offscreen is an offscreen modified at Draw.
-// If game does not implement FinalScreenDrawer, the dafault rendering for the final screen is used.
+// If game does not implement FinalScreenDrawer, the default rendering for the final screen is used.
 //
 // game's functions are called on the same goroutine.
 //
@@ -638,7 +638,7 @@ var screenTransparent int32 = 0
 //
 // SetInitFocused panics if this is called after the main loop.
 //
-// SetInitFocused is cuncurrent-safe.
+// SetInitFocused is concurrent-safe.
 //
 // Deprecated: as of v2.5. Use RunGameWithOptions instead.
 func SetInitFocused(focused bool) {

shader.go

@@ -30,7 +30,7 @@ type Shader struct {
 	shader *ui.Shader
 }
 
-// NewShader compiles a shader program in the shading language Kage, and retruns the result.
+// NewShader compiles a shader program in the shading language Kage, and returns the result.
 //
 // If the compilation fails, NewShader returns an error.
 //

shader_test.go

@@ -45,7 +45,7 @@ func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
 			got := dst.At(i, j).(color.RGBA)
 			var want color.RGBA
 			if i < w/2 && j < h/2 {
-				want = color.RGBA{0xff, 0, 0, 0xff}
+				want = color.RGBA{R: 0xff, A: 0xff}
 			}
 			if got != want {
 				t.Errorf("dst.At(%d, %d): got: %v, want: %v", i, j, got, want)
@@ -78,7 +78,7 @@ func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
 			got := dst.At(i, j).(color.RGBA)
 			var want color.RGBA
 			if i < w/2 && j < h/2 {
-				want = color.RGBA{0xff, 0, 0, 0xff}
+				want = color.RGBA{R: 0xff, A: 0xff}
 			}
 			if got != want {
 				t.Errorf("dst.At(%d, %d): got: %v, want: %v", i, j, got, want)
@@ -104,9 +104,9 @@ func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
 	}
 
 	src0 := ebiten.NewImageWithOptions(rect, &ebiten.NewImageOptions{Unmanaged: true})
-	src0.Fill(color.RGBA{25, 0xff, 25, 0xff})
+	src0.Fill(color.RGBA{R: 25, G: 0xff, B: 25, A: 0xff})
 	src1 := ebiten.NewImageWithOptions(rect, &ebiten.NewImageOptions{Unmanaged: true})
-	src1.Fill(color.RGBA{0xff, 0, 0, 0xff})
+	src1.Fill(color.RGBA{R: 0xff, A: 0xff})
 	op := &ebiten.DrawRectShaderOptions{}
 	op.CompositeMode = ebiten.CompositeModeCopy
 	op.Images[0] = src0
@@ -132,7 +132,7 @@ func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
 	for j := 0; j < h; j++ {
 		for i := 0; i < w; i++ {
 			got := dst.At(i, j).(color.RGBA)
-			want := color.RGBA{0xff, 0, 0, 0xff}
+			want := color.RGBA{R: 0xff, A: 0xff}
 			if got != want {
 				t.Errorf("dst.At(%d, %d): got: %v, want: %v", i, j, got, want)
 			}
@@ -149,7 +149,7 @@ func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
 	for j := 0; j < h; j++ {
 		for i := 0; i < w; i++ {
 			got := dst.At(i, j).(color.RGBA)
-			want := color.RGBA{25, 0xff, 25, 0xff}
+			want := color.RGBA{R: 25, G: 0xff, B: 25, A: 0xff}
 			if got != want {
 				t.Errorf("dst.At(%d, %d): got: %v, want: %v", i, j, got, want)
 			}
@@ -224,7 +224,7 @@ func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
 	for j := 0; j < h; j++ {
 		for i := 0; i < w; i++ {
 			got := dst.At(i, j).(color.RGBA)
-			want := color.RGBA{0xff, 0, 0, 0xff}
+			want := color.RGBA{R: 0xff, A: 0xff}
 			if got != want {
 				t.Errorf("dst.At(%d, %d): got: %v, want: %v", i, j, got, want)
 			}
@@ -255,7 +255,7 @@ func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
 	for j := 0; j < h; j++ {
 		for i := 0; i < w; i++ {
 			got := dst.At(i, j).(color.RGBA)
-			want := color.RGBA{0xff, 0, 0, 0xff}
+			want := color.RGBA{R: 0xff, A: 0xff}
 			if got != want {
 				t.Errorf("dst.At(%d, %d): got: %v, want: %v", i, j, got, want)
 			}
@@ -323,7 +323,7 @@ func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
 	for j := 0; j < h; j++ {
 		for i := 0; i < w; i++ {
 			got := dst.At(i, j).(color.RGBA)
-			want := color.RGBA{87, 82, 71, 255}
+			want := color.RGBA{R: 87, G: 82, B: 71, A: 255}
 			if got != want {
 				t.Errorf("dst.At(%d, %d): got: %v, want: %v", i, j, got, want)
 			}
@@ -382,7 +382,7 @@ func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
 				got := dst.At(i, j).(color.RGBA)
 				var want color.RGBA
 				if i < w/2 && j < h/2 {
-					want = color.RGBA{0xff, 0xff, 0, 0xff}
+					want = color.RGBA{R: 0xff, G: 0xff, A: 0xff}
 				}
 				if got != want {
 					t.Errorf("%s dst.At(%d, %d): got: %v, want: %v", testname, i, j, got, want)
@@ -493,7 +493,7 @@ func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
 	for j := 1; j < h-1; j++ {
 		for i := 1; i < w-1; i++ {
 			got := dst.At(i, j).(color.RGBA)
-			want := color.RGBA{0, 0, 0, 0xff}
+			want := color.RGBA{A: 0xff}
 			if i == w/2-1 || i == w/2 {
 				want.R = 0xff
 			}
@@ -551,7 +551,7 @@ func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
 	for j := 1; j < h-1; j++ {
 		for i := 1; i < w-1; i++ {
 			got := dst.At(i, j).(color.RGBA)
-			want := color.RGBA{0, 0, 0, 0xff}
+			want := color.RGBA{A: 0xff}
 			if i == w/2-1 || i == w/2 {
 				want.R = 0xff
 			}
@@ -630,7 +630,7 @@ func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
 			op := &ebiten.DrawRectShaderOptions{}
 			op.Uniforms = shader.Uniforms
 			dst.DrawRectShader(w, h, s, op)
-			if got, want := dst.At(0, 0), (color.RGBA{0xff, 0xff, 0xff, 0xff}); got != want {
+			if got, want := dst.At(0, 0), (color.RGBA{R: 0xff, G: 0xff, B: 0xff, A: 0xff}); got != want {
 				t.Errorf("got: %v, want: %v", got, want)
 			}
 		})
@@ -660,7 +660,7 @@ func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
 			got := dst.At(i, j).(color.RGBA)
 			var want color.RGBA
 			if i < w/2 && j < h/2 {
-				want = color.RGBA{0xc0, 0, 0, 0xff}
+				want = color.RGBA{R: 0xc0, A: 0xff}
 			}
 			if !sameColors(got, want, 2) {
 				t.Errorf("dst.At(%d, %d): got: %v, want: %v", i, j, got, want)
@@ -673,7 +673,7 @@ func TestShaderMatrixInitialize(t *testing.T) {
 	const w, h = 16, 16
 
 	src := ebiten.NewImage(w, h)
-	src.Fill(color.RGBA{0x10, 0x20, 0x30, 0xff})
+	src.Fill(color.RGBA{R: 0x10, G: 0x20, B: 0x30, A: 0xff})
 
 	dst := ebiten.NewImage(w, h)
 	s, err := ebiten.NewShader([]byte(`package main
@@ -693,7 +693,7 @@ func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
 	for j := 0; j < h; j++ {
 		for i := 0; i < w; i++ {
 			got := dst.At(i, j).(color.RGBA)
-			want := color.RGBA{0x20, 0x40, 0x60, 0xff}
+			want := color.RGBA{R: 0x20, G: 0x40, B: 0x60, A: 0xff}
 			if !sameColors(got, want, 2) {
 				t.Errorf("dst.At(%d, %d): got: %v, want: %v", i, j, got, want)
 			}
@@ -722,7 +722,7 @@ func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
 	for j := 0; j < h; j++ {
 		for i := 0; i < w; i++ {
 			got := dst.At(i, j).(color.RGBA)
-			want := color.RGBA{0x40, 0, 0x40, 0xff}
+			want := color.RGBA{R: 0x40, B: 0x40, A: 0xff}
 			if !sameColors(got, want, 2) {
 				t.Errorf("dst.At(%d, %d): got: %v, want: %v", i, j, got, want)
 			}
@@ -734,7 +734,7 @@ func TestShaderTextureAt(t *testing.T) {
 	const w, h = 16, 16
 
 	src := ebiten.NewImage(w, h)
-	src.Fill(color.RGBA{0x10, 0x20, 0x30, 0xff})
+	src.Fill(color.RGBA{R: 0x10, G: 0x20, B: 0x30, A: 0xff})
 
 	dst := ebiten.NewImage(w, h)
 	s, err := ebiten.NewShader([]byte(`package main
@@ -758,7 +758,7 @@ func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
 	for j := 0; j < h; j++ {
 		for i := 0; i < w; i++ {
 			got := dst.At(i, j).(color.RGBA)
-			want := color.RGBA{0x10, 0x20, 0x30, 0xff}
+			want := color.RGBA{R: 0x10, G: 0x20, B: 0x30, A: 0xff}
 			if !sameColors(got, want, 2) {
 				t.Errorf("dst.At(%d, %d): got: %v, want: %v", i, j, got, want)
 			}
@@ -770,7 +770,7 @@ func TestShaderAtan2(t *testing.T) {
 	const w, h = 16, 16
 
 	src := ebiten.NewImage(w, h)
-	src.Fill(color.RGBA{0x10, 0x20, 0x30, 0xff})
+	src.Fill(color.RGBA{R: 0x10, G: 0x20, B: 0x30, A: 0xff})
 
 	dst := ebiten.NewImage(w, h)
 	s, err := ebiten.NewShader([]byte(`package main
@@ -793,7 +793,7 @@ func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
 		for i := 0; i < w; i++ {
 			got := dst.At(i, j).(color.RGBA)
 			v := byte(math.Floor(0xff * math.Pi / 4))
-			want := color.RGBA{v, v, v, v}
+			want := color.RGBA{R: v, G: v, B: v, A: v}
 			if !sameColors(got, want, 2) {
 				t.Errorf("dst.At(%d, %d): got: %v, want: %v", i, j, got, want)
 			}
@@ -831,7 +831,7 @@ func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
 	for j := 0; j < h; j++ {
 		for i := 0; i < w; i++ {
 			got := dst.At(i, j).(color.RGBA)
-			want := color.RGBA{8, 12, 0xff, 0xff}
+			want := color.RGBA{R: 8, G: 12, B: 0xff, A: 0xff}
 			if !sameColors(got, want, 2) {
 				t.Errorf("dst.At(%d, %d): got: %v, want: %v", i, j, got, want)
 			}
@@ -871,7 +871,7 @@ func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
 	for j := 0; j < h; j++ {
 		for i := 0; i < w; i++ {
 			got := dst.At(i, j).(color.RGBA)
-			want := color.RGBA{54, 80, 0xff, 0xff}
+			want := color.RGBA{R: 54, G: 80, B: 0xff, A: 0xff}
 			if !sameColors(got, want, 2) {
 				t.Errorf("dst.At(%d, %d): got: %v, want: %v", i, j, got, want)
 			}
@@ -910,7 +910,7 @@ func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
 	for j := 0; j < h; j++ {
 		for i := 0; i < w; i++ {
 			got := dst.At(i, j).(color.RGBA)
-			want := color.RGBA{24, 30, 36, 0xff}
+			want := color.RGBA{R: 24, G: 30, B: 36, A: 0xff}
 			if !sameColors(got, want, 2) {
 				t.Errorf("dst.At(%d, %d): got: %v, want: %v", i, j, got, want)
 			}
@@ -952,7 +952,7 @@ func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
 	for j := 0; j < h; j++ {
 		for i := 0; i < w; i++ {
 			got := dst.At(i, j).(color.RGBA)
-			want := color.RGBA{6, 8, 9, 0xff}
+			want := color.RGBA{R: 6, G: 8, B: 9, A: 0xff}
 			if !sameColors(got, want, 2) {
 				t.Errorf("dst.At(%d, %d): got: %v, want: %v", i, j, got, want)
 			}
@@ -992,7 +992,7 @@ func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
 	for j := 0; j < h; j++ {
 		for i := 0; i < w; i++ {
 			got := dst.At(i, j).(color.RGBA)
-			want := color.RGBA{112, 128, 143, 159}
+			want := color.RGBA{R: 112, G: 128, B: 143, A: 159}
 			if !sameColors(got, want, 2) {
 				t.Errorf("dst.At(%d, %d): got: %v, want: %v", i, j, got, want)
 			}
@@ -1036,7 +1036,7 @@ func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
 	for j := 0; j < h; j++ {
 		for i := 0; i < w; i++ {
 			got := dst.At(i, j).(color.RGBA)
-			want := color.RGBA{44, 50, 56, 62}
+			want := color.RGBA{R: 44, G: 50, B: 56, A: 62}
 			if !sameColors(got, want, 2) {
 				t.Errorf("dst.At(%d, %d): got: %v, want: %v", i, j, got, want)
 			}
@@ -1098,7 +1098,7 @@ func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
 				got := dst.At(i, j).(color.RGBA)
 				var want color.RGBA
 				if 0 <= i && i < w/2 && 0 <= j && j < h/2 {
-					want = color.RGBA{0xff, 0xff, 0, 0xff}
+					want = color.RGBA{R: 0xff, G: 0xff, A: 0xff}
 				}
 				if got != want {
 					t.Errorf("%s dst.At(%d, %d): got: %v, want: %v", testname, i, j, got, want)
@@ -1196,7 +1196,7 @@ func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
 	for j := 0; j < h; j++ {
 		for i := 0; i < w; i++ {
 			got := dst.At(i, j).(color.RGBA)
-			want := color.RGBA{0xff, 0, 0x00, 0xff}
+			want := color.RGBA{R: 0xff, A: 0xff}
 			if !sameColors(got, want, 2) {
 				t.Errorf("dst.At(%d, %d): got: %v, want: %v", i, j, got, want)
 			}
@@ -1209,7 +1209,7 @@ func TestShaderDiscard(t *testing.T) {
 	const w, h = 16, 16
 
 	dst := ebiten.NewImage(w, h)
-	dst.Fill(color.RGBA{0xff, 0, 0, 0xff})
+	dst.Fill(color.RGBA{R: 0xff, A: 0xff})
 
 	src := ebiten.NewImage(w, h)
 	pix := make([]byte, 4*w*h)
@@ -1245,9 +1245,9 @@ func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
 	for j := 0; j < h; j++ {
 		for i := 0; i < w; i++ {
 			got := dst.At(i, j).(color.RGBA)
-			want := color.RGBA{0, 0xff, 0x00, 0xff}
+			want := color.RGBA{G: 0xff, A: 0xff}
 			if i >= w/2 || j >= h/2 {
-				want = color.RGBA{0xff, 0, 0x00, 0xff}
+				want = color.RGBA{R: 0xff, A: 0xff}
 			}
 			if !sameColors(got, want, 2) {
 				t.Errorf("dst.At(%d, %d): got: %v, want: %v", i, j, got, want)
@@ -1299,9 +1299,9 @@ func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
 			var want color.RGBA
 			if offsetX <= i && i < offsetX+srcW && offsetY <= j && j < offsetY+srcH {
 				if offsetX+srcW/2 <= i && offsetY+srcH/2 <= j {
-					want = color.RGBA{0xff, 0, 0, 0xff}
+					want = color.RGBA{R: 0xff, A: 0xff}
 				} else {
-					want = color.RGBA{0, 0xff, 0, 0xff}
+					want = color.RGBA{G: 0xff, A: 0xff}
 				}
 			}
 			if got != want {
@@ -1330,13 +1330,13 @@ func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
 	op.ColorScale.SetG(5.0 / 8.0)
 	op.ColorScale.SetB(6.0 / 8.0)
 	op.ColorScale.SetA(7.0 / 8.0)
-	op.ColorScale.ScaleWithColor(color.RGBA{0x40, 0x80, 0xc0, 0xff})
+	op.ColorScale.ScaleWithColor(color.RGBA{R: 0x40, G: 0x80, B: 0xc0, A: 0xff})
 	dst.DrawRectShader(w, h, s, op)
 
 	for j := 0; j < h; j++ {
 		for i := 0; i < w; i++ {
 			got := dst.At(i, j).(color.RGBA)
-			want := color.RGBA{0x20, 0x50, 0x90, 0xe0}
+			want := color.RGBA{R: 0x20, G: 0x50, B: 0x90, A: 0xe0}
 			if !sameColors(got, want, 1) {
 				t.Errorf("dst.At(%d, %d): got: %v, want: %v", i, j, got, want)
 			}
@@ -1391,7 +1391,7 @@ func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
 				"U3": 0xff,
 			},
 			Shader: ints,
-			Want:   color.RGBA{0xff, 0xff, 0xff, 0xff},
+			Want:   color.RGBA{R: 0xff, G: 0xff, B: 0xff, A: 0xff},
 		},
 		{
 			Name: "int",
@@ -1402,7 +1402,7 @@ func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
 				"U3": int64(0x88),
 			},
 			Shader: ints,
-			Want:   color.RGBA{0x24, 0x3f, 0x6a, 0x88},
+			Want:   color.RGBA{R: 0x24, G: 0x3f, B: 0x6a, A: 0x88},
 		},
 		{
 			Name: "uint",
@@ -1413,7 +1413,7 @@ func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
 				"U3": uint64(0xd3),
 			},
 			Shader: ints,
-			Want:   color.RGBA{0x85, 0xa3, 0x08, 0xd3},
+			Want:   color.RGBA{R: 0x85, G: 0xa3, B: 0x08, A: 0xd3},
 		},
 		{
 			Name: "0xff,slice",
@@ -1421,7 +1421,7 @@ func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
 				"U": []int{0xff, 0xff, 0xff, 0xff},
 			},
 			Shader: intArray,
-			Want:   color.RGBA{0xff, 0xff, 0xff, 0xff},
+			Want:   color.RGBA{R: 0xff, G: 0xff, B: 0xff, A: 0xff},
 		},
 		{
 			Name: "int,slice",
@@ -1429,7 +1429,7 @@ func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
 				"U": []int16{0x24, 0x3f, 0x6a, 0x88},
 			},
 			Shader: intArray,
-			Want:   color.RGBA{0x24, 0x3f, 0x6a, 0x88},
+			Want:   color.RGBA{R: 0x24, G: 0x3f, B: 0x6a, A: 0x88},
 		},
 		{
 			Name: "uint,slice",
@@ -1437,7 +1437,7 @@ func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
 				"U": []uint8{0x85, 0xa3, 0x08, 0xd3},
 			},
 			Shader: intArray,
-			Want:   color.RGBA{0x85, 0xa3, 0x08, 0xd3},
+			Want:   color.RGBA{R: 0x85, G: 0xa3, B: 0x08, A: 0xd3},
 		},
 		{
 			Name: "0xff,array",
@@ -1445,7 +1445,7 @@ func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
 				"U": [...]int{0xff, 0xff, 0xff, 0xff},
 			},
 			Shader: intArray,
-			Want:   color.RGBA{0xff, 0xff, 0xff, 0xff},
+			Want:   color.RGBA{R: 0xff, G: 0xff, B: 0xff, A: 0xff},
 		},
 		{
 			Name: "int,array",
@@ -1453,7 +1453,7 @@ func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
 				"U": [...]int16{0x24, 0x3f, 0x6a, 0x88},
 			},
 			Shader: intArray,
-			Want:   color.RGBA{0x24, 0x3f, 0x6a, 0x88},
+			Want:   color.RGBA{R: 0x24, G: 0x3f, B: 0x6a, A: 0x88},
 		},
 		{
 			Name: "uint,array",
@@ -1461,7 +1461,7 @@ func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
 				"U": [...]uint8{0x85, 0xa3, 0x08, 0xd3},
 			},
 			Shader: intArray,
-			Want:   color.RGBA{0x85, 0xa3, 0x08, 0xd3},
+			Want:   color.RGBA{R: 0x85, G: 0xa3, B: 0x08, A: 0xd3},
 		},
 		{
 			Name: "0xff,array",
@@ -1469,7 +1469,7 @@ func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
 				"U": [...]int{0xff, 0xff, 0xff, 0xff},
 			},
 			Shader: intArray,
-			Want:   color.RGBA{0xff, 0xff, 0xff, 0xff},
+			Want:   color.RGBA{R: 0xff, G: 0xff, B: 0xff, A: 0xff},
 		},
 		{
 			Name: "int,array",
@@ -1477,7 +1477,7 @@ func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
 				"U": [...]int16{0x24, 0x3f, 0x6a, 0x88},
 			},
 			Shader: intArray,
-			Want:   color.RGBA{0x24, 0x3f, 0x6a, 0x88},
+			Want:   color.RGBA{R: 0x24, G: 0x3f, B: 0x6a, A: 0x88},
 		},
 		{
 			Name: "uint,array",
@@ -1485,7 +1485,7 @@ func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
 				"U": [...]uint8{0x85, 0xa3, 0x08, 0xd3},
 			},
 			Shader: intArray,
-			Want:   color.RGBA{0x85, 0xa3, 0x08, 0xd3},
+			Want:   color.RGBA{R: 0x85, G: 0xa3, B: 0x08, A: 0xd3},
 		},
 		{
 			Name: "0xff,ivec",
@@ -1494,7 +1494,7 @@ func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
 				"U1": [...]int{0xff, 0xff, 0xff, 0xff, 0xff, 0xff},
 			},
 			Shader: intVec,
-			Want:   color.RGBA{0xff, 0xff, 0xff, 0xff},
+			Want:   color.RGBA{R: 0xff, G: 0xff, B: 0xff, A: 0xff},
 		},
 		{
 			Name: "int,ivec",
@@ -1503,7 +1503,7 @@ func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
 				"U1": [...]int16{0x85, 0xa3, 0x08, 0xd3, 0x13, 0x19},
 			},
 			Shader: intVec,
-			Want:   color.RGBA{0x24, 0x3f, 0x08, 0xd3},
+			Want:   color.RGBA{R: 0x24, G: 0x3f, B: 0x08, A: 0xd3},
 		},
 		{
 			Name: "uint,ivec",
@@ -1512,7 +1512,7 @@ func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
 				"U1": [...]uint8{0x85, 0xa3, 0x08, 0xd3, 0x13, 0x19},
 			},
 			Shader: intVec,
-			Want:   color.RGBA{0x24, 0x3f, 0x08, 0xd3},
+			Want:   color.RGBA{R: 0x24, G: 0x3f, B: 0x08, A: 0xd3},
 		},
 	}
 	for _, tc := range testCases {
@@ -1570,7 +1570,7 @@ func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
 		},
 	}
 	dst.DrawRectShader(w, h, s, op)
-	if got, want := dst.At(0, 0).(color.RGBA), (color.RGBA{0x24, 0x85, 0x13, 0x19}); !sameColors(got, want, 1) {
+	if got, want := dst.At(0, 0).(color.RGBA), (color.RGBA{R: 0x24, G: 0x85, B: 0x13, A: 0x19}); !sameColors(got, want, 1) {
 		t.Errorf("got: %v, want: %v", got, want)
 	}
 }
@@ -1583,31 +1583,31 @@ func TestShaderIVecMod(t *testing.T) {
 		{
 			source: `a := ivec4(0x24, 0x3f, 0x6a, 0x88)
 return vec4(a)/255`,
-			want: color.RGBA{0x24, 0x3f, 0x6a, 0x88},
+			want: color.RGBA{R: 0x24, G: 0x3f, B: 0x6a, A: 0x88},
 		},
 		{
 			source: `a := ivec4(0x24, 0x3f, 0x6a, 0x88)
 a %= 0x85
 return vec4(a)/255`,
-			want: color.RGBA{0x24, 0x3f, 0x6a, 0x03},
+			want: color.RGBA{R: 0x24, G: 0x3f, B: 0x6a, A: 0x03},
 		},
 		{
 			source: `a := ivec4(0x24, 0x3f, 0x6a, 0x88)
 a %= ivec4(0x85, 0xa3, 0x08, 0xd3)
 return vec4(a)/255`,
-			want: color.RGBA{0x24, 0x3f, 0x02, 0x88},
+			want: color.RGBA{R: 0x24, G: 0x3f, B: 0x02, A: 0x88},
 		},
 		{
 			source: `a := ivec4(0x24, 0x3f, 0x6a, 0x88)
 b := a % 0x85
 return vec4(b)/255`,
-			want: color.RGBA{0x24, 0x3f, 0x6a, 0x03},
+			want: color.RGBA{R: 0x24, G: 0x3f, B: 0x6a, A: 0x03},
 		},
 		{
 			source: `a := ivec4(0x24, 0x3f, 0x6a, 0x88)
 b := a % ivec4(0x85, 0xa3, 0x08, 0xd3)
 return vec4(b)/255`,
-			want: color.RGBA{0x24, 0x3f, 0x02, 0x88},
+			want: color.RGBA{R: 0x24, G: 0x3f, B: 0x02, A: 0x88},
 		},
 	}
 

vector/path.go

@@ -448,7 +448,7 @@ const (
 	LineJoinRound
 )
 
-// StokeOptions is options to render a stroke.
+// StrokeOptions is options to render a stroke.
 type StrokeOptions struct {
 	// Width is the stroke width in pixels.
 	//

vector/util.go

@@ -91,7 +91,7 @@ func StrokeRect(dst *ebiten.Image, x, y, width, height float32, strokeWidth floa
 	drawVerticesForUtil(dst, vs, is, clr)
 }
 
-// DrawFilledCircle filles a circle with the specified center position (cx, cy), the radius (r), width and color.
+// DrawFilledCircle fills a circle with the specified center position (cx, cy), the radius (r), width and color.
 func DrawFilledCircle(dst *ebiten.Image, cx, cy, r float32, clr color.Color) {
 	var path Path
 	path.Arc(cx, cy, r, 0, 2*math.Pi, Clockwise)

window.go

@@ -30,16 +30,16 @@ type WindowResizingModeType = ui.WindowResizingMode
 // WindowResizingModeTypes
 const (
 	// WindowResizingModeDisabled indicates the mode to disallow resizing the window by a user.
-	WindowResizingModeDisabled WindowResizingModeType = WindowResizingModeType(ui.WindowResizingModeDisabled)
+	WindowResizingModeDisabled WindowResizingModeType = ui.WindowResizingModeDisabled
 
 	// WindowResizingModeOnlyFullscreenEnabled indicates the mode to disallow resizing the window,
 	// but allow to make the window fullscreen by a user.
 	// This works only on macOS so far.
 	// On the other platforms, this is the same as WindowResizingModeDisabled.
-	WindowResizingModeOnlyFullscreenEnabled WindowResizingModeType = WindowResizingModeType(ui.WindowResizingModeOnlyFullscreenEnabled)
+	WindowResizingModeOnlyFullscreenEnabled WindowResizingModeType = ui.WindowResizingModeOnlyFullscreenEnabled
 
 	// WindowResizingModeEnabled indicates the mode to allow resizing the window by a user.
-	WindowResizingModeEnabled WindowResizingModeType = WindowResizingModeType(ui.WindowResizingModeEnabled)
+	WindowResizingModeEnabled WindowResizingModeType = ui.WindowResizingModeEnabled
 )
 
 // IsWindowDecorated reports whether the window is decorated.
@@ -67,14 +67,14 @@ func SetWindowDecorated(decorated bool) {
 //
 // WindowResizingMode is concurrent-safe.
 func WindowResizingMode() WindowResizingModeType {
-	return WindowResizingModeType(ui.Get().Window().ResizingMode())
+	return ui.Get().Window().ResizingMode()
 }
 
 // SetWindowResizingMode sets the mode in which a user resizes the window.
 //
 // SetWindowResizingMode is concurrent-safe.
 func SetWindowResizingMode(mode WindowResizingModeType) {
-	ui.Get().Window().SetResizingMode(ui.WindowResizingMode(mode))
+	ui.Get().Window().SetResizingMode(mode)
 }
 
 // IsWindowResizable reports whether the window is resizable by the user's dragging on desktops.
@@ -300,7 +300,7 @@ func IsWindowBeingClosed() bool {
 // SetWindowClosingHandled sets whether the window closing is handled or not on desktops. The default state is false.
 //
 // If the window closing is handled, the window is not closed immediately and
-// the game can know whether the window is begin closed or not by IsWindowBeingClosed.
+// the game can know whether the window is being closed or not by IsWindowBeingClosed.
 // In this case, the window is not closed automatically.
 // To end the game, you have to return an error value at the Game's Update function.
 //