internal/graphicscommand: bug fix: resolve unsent WritePixels commands

(*Image).WritePixels doens't send a command to the queue immediately
but caches commands internally. However, the package atlas assumed
that pixel data was sent to the cache every end of a frame. Then, byte
slices for pixels were corrupted.

This change fixes the issue by resolving all the images when flushing
commands.

Closes #2390

internal/atlas/image.go

@@ -37,6 +37,8 @@ type temporaryBytes struct {
 	pixels           []byte
 	pos              int
 	notFullyUsedTime int
+
+	m sync.Mutex
 }
 
 var theTemporaryBytes temporaryBytes
@@ -743,9 +745,12 @@ func (i *Image) DumpScreenshot(graphicsDriver graphicsdriver.Graphics, path stri
 func EndFrame(graphicsDriver graphicsdriver.Graphics) error {
 	backendsM.Lock()
 
-	theTemporaryBytes.resetAtFrameEnd()
+	if err := restorable.ResolveStaleImages(graphicsDriver); err != nil {
+		return err
+	}
 
-	return restorable.ResolveStaleImages(graphicsDriver)
+	theTemporaryBytes.resetAtFrameEnd()
+	return nil
 }
 
 func BeginFrame(graphicsDriver graphicsdriver.Graphics) error {

internal/graphicscommand/command.go

@@ -273,6 +273,8 @@ func (q *commandQueue) flush(graphicsDriver graphicsdriver.Graphics) error {
 
 // FlushCommands flushes the command queue.
 func FlushCommands(graphicsDriver graphicsdriver.Graphics) error {
+	resolveImages()
+
 	return theCommandQueue.Flush(graphicsDriver)
 }
 

internal/graphicscommand/image.go

@@ -43,7 +43,7 @@ type Image struct {
 	// have its graphicsdriver.Image.
 	id int
 
-	bufferedRP []*graphicsdriver.WritePixelsArgs
+	bufferedWP []*graphicsdriver.WritePixelsArgs
 }
 
 var nextID = 1
@@ -54,6 +54,25 @@ func genNextID() int {
 	return id
 }
 
+// unresolvedImages is the set of unresolved images.
+// An unresolved image is an image that might have an state unsent to the command queue yet.
+var unresolvedImages []*Image
+
+// addUnresolvedImage adds an image to the list of unresolved images.
+func addUnresolvedImage(img *Image) {
+	unresolvedImages = append(unresolvedImages, img)
+}
+
+// resolveImages resolves all the image states unsent to the command queue.
+// resolveImages should be called before flushing commands.
+func resolveImages() {
+	for i, img := range unresolvedImages {
+		img.resolveBufferedWritePixels()
+		unresolvedImages[i] = nil
+	}
+	unresolvedImages = unresolvedImages[:0]
+}
+
 // NewImage returns a new image.
 //
 // Note that the image is not initialized yet.
@@ -75,15 +94,15 @@ func NewImage(width, height int, screenFramebuffer bool) *Image {
 }
 
 func (i *Image) resolveBufferedWritePixels() {
-	if len(i.bufferedRP) == 0 {
+	if len(i.bufferedWP) == 0 {
 		return
 	}
 	c := &writePixelsCommand{
 		dst:  i,
-		args: i.bufferedRP,
+		args: i.bufferedWP,
 	}
 	theCommandQueue.Enqueue(c)
-	i.bufferedRP = nil
+	i.bufferedWP = nil
 }
 
 func (i *Image) Dispose() {
@@ -167,13 +186,14 @@ func (i *Image) ReadPixels(graphicsDriver graphicsdriver.Graphics, buf []byte) e
 }
 
 func (i *Image) WritePixels(pixels []byte, x, y, width, height int) {
-	i.bufferedRP = append(i.bufferedRP, &graphicsdriver.WritePixelsArgs{
+	i.bufferedWP = append(i.bufferedWP, &graphicsdriver.WritePixelsArgs{
 		Pixels: pixels,
 		X:      x,
 		Y:      y,
 		Width:  width,
 		Height: height,
 	})
+	addUnresolvedImage(i)
 }
 
 func (i *Image) IsInvalidated() bool {

internal/processtest/testdata/issue2390.go

@@ -0,0 +1,88 @@
+// Copyright 2022 The Ebitengine Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//go:build ignore
+// +build ignore
+
+package main
+
+import (
+	"errors"
+	"fmt"
+	"image"
+	"image/color"
+	"log"
+
+	"github.com/hajimehoshi/ebiten/v2"
+)
+
+var regularTermination = errors.New("regular termination")
+
+type Game struct {
+	images       []*ebiten.Image
+	imageCreated chan struct{}
+}
+
+func (g *Game) Update() error {
+	if g.imageCreated == nil {
+		g.imageCreated = make(chan struct{})
+		go func() {
+			op := &ebiten.NewImageFromImageOptions{
+				Unmanaged: true,
+			}
+			for i := 0; i < 3; i++ {
+				i := i
+				img := image.NewRGBA(image.Rect(0, 0, 512, 512))
+				for j := 0; j < len(img.Pix)/4; j++ {
+					img.Pix[4*j] = byte(0x60 * i)
+					img.Pix[4*j+1] = byte(0x60 * i)
+					img.Pix[4*j+2] = byte(0x60 * i)
+					img.Pix[4*j+3] = 0xff
+				}
+				g.images = append(g.images, ebiten.NewImageFromImageWithOptions(img, op))
+			}
+			close(g.imageCreated)
+		}()
+		return nil
+	}
+
+	select {
+	case <-g.imageCreated:
+	default:
+		return nil
+	}
+
+	for i, img := range g.images {
+		got := img.At(0, 0).(color.RGBA)
+		want := color.RGBA{byte(0x60 * i), byte(0x60 * i), byte(0x60 * i), 0xff}
+		if got != want {
+			panic(fmt.Sprintf("got: %v, want: %v", got, want))
+		}
+	}
+
+	return regularTermination
+}
+
+func (g *Game) Draw(screen *ebiten.Image) {
+}
+
+func (g *Game) Layout(outsideWidth, outsideHeight int) (int, int) {
+	return 640, 480
+}
+
+func main() {
+	if err := ebiten.RunGame(&Game{}); err != nil && !errors.Is(err, regularTermination) {
+		log.Fatal(err)
+	}
+}