ebiten, vector: bug fix: race conditions

This change fixes these race conditions in

 * (*ebiten.Image).invokeUsageCallbacks concurrent invocations
 * (*ebiten.Image).usageCallbacks usages
 * vector.theCallbackTokens usages
 * vector's global shader initializations

Closes #3333

Author: hajimehoshi

image.go

@@ -19,6 +19,7 @@ import (
 	"image"
 	"image/color"
 	"math"
+	"slices"
 	"sync"
 	"sync/atomic"
 	"unsafe"
@@ -72,15 +73,23 @@ type Image struct {
 
 	// usageCallbacks are callbacks that are invoked when the image is used.
 	// usageCallbacks is valid only when the image is not a sub-image.
-	usageCallbacks map[int64]func()
+	usageCallbacks map[int64]usageCallback
 
 	// inUsageCallbacks reports whether the image is in usageCallbacks.
-	inUsageCallbacks bool
+	inUsageCallbacks atomic.Bool
+
+	// usageCallbacksM is a mutex for usageCallbacks.
+	usageCallbacksM sync.Mutex
 
 	// Do not add a 'buffering' member that are resolved lazily.
 	// This tends to forget resolving the buffer easily (#2362).
 }
 
+type usageCallback struct {
+	image *Image
+	fn    func(image *Image)
+}
+
 func (i *Image) copyCheck() {
 	if i.addr != i {
 		panic("ebiten: illegal use of non-zero Image copied by value")
@@ -1597,19 +1606,26 @@ func (*Image) private() {
 var currentCallbackToken atomic.Int64
 
 //go:linkname addUsageCallback
-func addUsageCallback(img *Image, callback func()) int64 {
-	return img.addUsageCallback(callback)
+func addUsageCallback(img *Image, callback func(image *Image)) int64 {
+	return img.addUsageCallback(img, callback)
 }
 
-func (i *Image) addUsageCallback(callback func()) int64 {
+func (i *Image) addUsageCallback(image *Image, callback func(image *Image)) int64 {
 	if i.isSubImage() {
-		return i.original.addUsageCallback(callback)
+		return i.original.addUsageCallback(image, callback)
 	}
+	token := currentCallbackToken.Add(1)
+
+	i.usageCallbacksM.Lock()
+	defer i.usageCallbacksM.Unlock()
+
 	if i.usageCallbacks == nil {
-		i.usageCallbacks = map[int64]func(){}
+		i.usageCallbacks = map[int64]usageCallback{}
+	}
+	i.usageCallbacks[token] = usageCallback{
+		image: image,
+		fn:    callback,
 	}
-	token := currentCallbackToken.Add(1)
-	i.usageCallbacks[token] = callback
 	return token
 }
 
@@ -1623,25 +1639,45 @@ func (i *Image) removeUsageCallback(token int64) {
 		i.original.removeUsageCallback(token)
 		return
 	}
+
+	i.usageCallbacksM.Lock()
+	defer i.usageCallbacksM.Unlock()
 	delete(i.usageCallbacks, token)
 }
 
+var theTmpUsageCallbackSlicePool = sync.Pool{
+	New: func() any {
+		slice := make([]usageCallback, 0, 16)
+		return &slice
+	},
+}
+
 func (i *Image) invokeUsageCallbacks() {
 	if i.isSubImage() {
 		i.original.invokeUsageCallbacks()
 		return
 	}
 
-	if i.inUsageCallbacks {
+	// Do not allow recursive calls.
+	if !i.inUsageCallbacks.CompareAndSwap(false, true) {
 		return
 	}
+	defer i.inUsageCallbacks.Store(false)
 
-	i.inUsageCallbacks = true
-	defer func() {
-		i.inUsageCallbacks = false
+	tmpUsageCallbackSlice := theTmpUsageCallbackSlicePool.Get().(*[]usageCallback)
+
+	func() {
+		i.usageCallbacksM.Lock()
+		defer i.usageCallbacksM.Unlock()
+		for _, cb := range i.usageCallbacks {
+			*tmpUsageCallbackSlice = append(*tmpUsageCallbackSlice, cb)
+		}
 	}()
 
-	for _, cb := range i.usageCallbacks {
-		cb()
+	for _, cb := range *tmpUsageCallbackSlice {
+		cb.fn(cb.image)
 	}
+
+	*tmpUsageCallbackSlice = slices.Delete(*tmpUsageCallbackSlice, 0, len(*tmpUsageCallbackSlice))
+	theTmpUsageCallbackSlicePool.Put(tmpUsageCallbackSlice)
 }

vector/fill.go

@@ -15,6 +15,7 @@
 package vector
 
 import (
+	"fmt"
 	"slices"
 
 	"github.com/hajimehoshi/ebiten/v2"
@@ -121,6 +122,8 @@ var (
 
 // theAtlas manages the atlas for stencil buffer images.
 // theAtlas is a singleton to avoid unnecessary texture allocations.
+//
+// theAtlas methods are used only at fillPathsState.fillPaths, and should be protected by theFillPathM.
 var theAtlas atlas
 
 type fillPathsState struct {
@@ -147,6 +150,7 @@ func (f *fillPathsState) addPath(path *Path, clr ebiten.ColorScale) {
 	if path == nil {
 		return
 	}
+
 	f.paths = slices.Grow(f.paths, 1)[:len(f.paths)+1]
 	if f.paths[len(f.paths)-1] == nil {
 		f.paths[len(f.paths)-1] = &Path{}
@@ -163,62 +167,13 @@ func (f *fillPathsState) addPath(path *Path, clr ebiten.ColorScale) {
 }
 
 // fillPaths fills the specified path with the specified color.
+//
+// fillPaths callers must be protected by theFillPathM.
 func (f *fillPathsState) fillPaths(dst *ebiten.Image) {
 	if len(f.paths) != len(f.colors) {
 		panic("vector: the number of paths and colors must be the same")
 	}
 
-	if stencilBufferFillShader == nil {
-		s, err := ebiten.NewShader([]byte(stencilBufferFillShaderSrc))
-		if err != nil {
-			panic(err)
-		}
-		stencilBufferFillShader = s
-	}
-	if stencilBufferBezierShader == nil {
-		s, err := ebiten.NewShader([]byte(stencilBufferBezierShaderSrc))
-		if err != nil {
-			panic(err)
-		}
-		stencilBufferBezierShader = s
-	}
-	if !f.antialias && f.fillRule == FillRuleNonZero {
-		if stencilBufferNonZeroShader == nil {
-			s, err := ebiten.NewShader([]byte(stencilBufferNonZeroShaderSrc))
-			if err != nil {
-				panic(err)
-			}
-			stencilBufferNonZeroShader = s
-		}
-	}
-	if f.antialias && f.fillRule == FillRuleNonZero {
-		if stencilBufferNonZeroAAShader == nil {
-			s, err := ebiten.NewShader([]byte(stencilBufferNonZeroAAShaderSrc))
-			if err != nil {
-				panic(err)
-			}
-			stencilBufferNonZeroAAShader = s
-		}
-	}
-	if !f.antialias && f.fillRule == FillRuleEvenOdd {
-		if stencilBufferEvenOddShader == nil {
-			s, err := ebiten.NewShader([]byte(stencilBufferEvenOddShaderSrc))
-			if err != nil {
-				panic(err)
-			}
-			stencilBufferEvenOddShader = s
-		}
-	}
-	if f.antialias && f.fillRule == FillRuleEvenOdd {
-		if stencilBufferEvenOddAAShader == nil {
-			s, err := ebiten.NewShader([]byte(stencilBufferEvenOddAAShaderSrc))
-			if err != nil {
-				panic(err)
-			}
-			stencilBufferEvenOddAAShader = s
-		}
-	}
-
 	vs := f.vertices[:0]
 	is := f.indices[:0]
 	defer func() {
@@ -343,7 +298,11 @@ func (f *fillPathsState) fillPaths(dst *ebiten.Image) {
 			}
 			op := &ebiten.DrawTrianglesShaderOptions{}
 			op.Blend = ebiten.BlendLighter
-			stencilBufferImage.DrawTrianglesShader32(vs, is, stencilBufferFillShader, op)
+			shader, err := ensureStencilBufferShaders()
+			if err != nil {
+				panic(fmt.Sprintf("vector: failed to create stencil buffer shader: %v", err))
+			}
+			stencilBufferImage.DrawTrianglesShader32(vs, is, shader, op)
 		}
 	}
 
@@ -415,7 +374,11 @@ func (f *fillPathsState) fillPaths(dst *ebiten.Image) {
 			}
 			op := &ebiten.DrawTrianglesShaderOptions{}
 			op.Blend = ebiten.BlendLighter
-			stencilBufferImage.DrawTrianglesShader32(vs, is, stencilBufferBezierShader, op)
+			shader, err := ensureStencilBufferBezierShader()
+			if err != nil {
+				panic(fmt.Sprintf("vector: failed to create stencil buffer bezier shader: %v", err))
+			}
+			stencilBufferImage.DrawTrianglesShader32(vs, is, shader, op)
 		}
 	}
 
@@ -506,16 +469,16 @@ func (f *fillPathsState) fillPaths(dst *ebiten.Image) {
 		var shader *ebiten.Shader
 		switch f.fillRule {
 		case FillRuleNonZero:
-			if f.antialias {
-				shader = stencilBufferNonZeroAAShader
-			} else {
-				shader = stencilBufferNonZeroShader
+			var err error
+			shader, err = ensureStencilBufferNonZeroShader(f.antialias)
+			if err != nil {
+				panic(fmt.Sprintf("vector: failed to create stencil buffer non-zero shader: %v", err))
 			}
 		case FillRuleEvenOdd:
-			if f.antialias {
-				shader = stencilBufferEvenOddAAShader
-			} else {
-				shader = stencilBufferEvenOddShader
+			var err error
+			shader, err = ensureStencilBufferEvenOddShader(f.antialias)
+			if err != nil {
+				panic(fmt.Sprintf("vector: failed to create stencil buffer even-odd shader: %v", err))
 			}
 		}
 		dst.DrawTrianglesShader32(vs, is, shader, op)

vector/stencilshader.go

@@ -15,6 +15,8 @@
 package vector
 
 import (
+	"sync"
+
 	"github.com/hajimehoshi/ebiten/v2"
 )
 
@@ -30,8 +32,94 @@ var (
 	stencilBufferNonZeroAAShader *ebiten.Shader
 	stencilBufferEvenOddShader   *ebiten.Shader
 	stencilBufferEvenOddAAShader *ebiten.Shader
+
+	stencilBufferM sync.Mutex
 )
 
+func ensureStencilBufferShaders() (*ebiten.Shader, error) {
+	stencilBufferM.Lock()
+	defer stencilBufferM.Unlock()
+
+	if stencilBufferFillShader != nil {
+		return stencilBufferFillShader, nil
+	}
+	s, err := ebiten.NewShader([]byte(stencilBufferFillShaderSrc))
+	if err != nil {
+		return nil, err
+	}
+	stencilBufferFillShader = s
+	return stencilBufferFillShader, err
+}
+
+func ensureStencilBufferBezierShader() (*ebiten.Shader, error) {
+	stencilBufferM.Lock()
+	defer stencilBufferM.Unlock()
+
+	if stencilBufferBezierShader != nil {
+		return stencilBufferBezierShader, nil
+	}
+	s, err := ebiten.NewShader([]byte(stencilBufferBezierShaderSrc))
+	if err != nil {
+		return nil, err
+	}
+	stencilBufferBezierShader = s
+	return stencilBufferBezierShader, nil
+}
+
+func ensureStencilBufferNonZeroShader(antialias bool) (*ebiten.Shader, error) {
+	stencilBufferM.Lock()
+	defer stencilBufferM.Unlock()
+
+	if antialias {
+		if stencilBufferNonZeroAAShader != nil {
+			return stencilBufferNonZeroAAShader, nil
+		}
+		s, err := ebiten.NewShader([]byte(stencilBufferNonZeroAAShaderSrc))
+		if err != nil {
+			return nil, err
+		}
+		stencilBufferNonZeroAAShader = s
+		return stencilBufferNonZeroAAShader, nil
+	}
+
+	if stencilBufferNonZeroShader != nil {
+		return stencilBufferNonZeroShader, nil
+	}
+	s, err := ebiten.NewShader([]byte(stencilBufferNonZeroShaderSrc))
+	if err != nil {
+		return nil, err
+	}
+	stencilBufferNonZeroShader = s
+	return stencilBufferNonZeroShader, nil
+}
+
+func ensureStencilBufferEvenOddShader(antialias bool) (*ebiten.Shader, error) {
+	stencilBufferM.Lock()
+	defer stencilBufferM.Unlock()
+
+	if antialias {
+		if stencilBufferEvenOddAAShader != nil {
+			return stencilBufferEvenOddAAShader, nil
+		}
+		s, err := ebiten.NewShader([]byte(stencilBufferEvenOddAAShaderSrc))
+		if err != nil {
+			return nil, err
+		}
+		stencilBufferEvenOddAAShader = s
+		return stencilBufferEvenOddAAShader, nil
+	}
+
+	if stencilBufferEvenOddShader != nil {
+		return stencilBufferEvenOddShader, nil
+	}
+	s, err := ebiten.NewShader([]byte(stencilBufferEvenOddShaderSrc))
+	if err != nil {
+		return nil, err
+	}
+	stencilBufferEvenOddShader = s
+	return stencilBufferEvenOddShader, nil
+}
+
 //ebitengine:shadersource
 const stencilBufferFillShaderSrc = `//kage:unit pixels