vendor dependencies, make some changes to how input is done

vendor/github.com/hajimehoshi/ebiten/v2/internal/graphicscommand/command.go

@@ -0,0 +1,391 @@
+// Copyright 2016 Hajime Hoshi
+//
+// 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.
+
+package graphicscommand
+
+import (
+	"fmt"
+	"image"
+	"math"
+	"strings"
+
+	"github.com/hajimehoshi/ebiten/v2/internal/graphics"
+	"github.com/hajimehoshi/ebiten/v2/internal/graphicsdriver"
+	"github.com/hajimehoshi/ebiten/v2/internal/shaderir"
+)
+
+// command represents a drawing command.
+//
+// A command for drawing that is created when Image functions are called like DrawTriangles,
+// or Fill.
+// A command is not immediately executed after created. Instead, it is queued after created,
+// and executed only when necessary.
+type command interface {
+	fmt.Stringer
+
+	Exec(commandQueue *commandQueue, graphicsDriver graphicsdriver.Graphics, indexOffset int) error
+	NeedsSync() bool
+}
+
+type drawTrianglesCommandPool struct {
+	pool []*drawTrianglesCommand
+}
+
+func (p *drawTrianglesCommandPool) get() *drawTrianglesCommand {
+	if len(p.pool) == 0 {
+		return &drawTrianglesCommand{}
+	}
+	v := p.pool[len(p.pool)-1]
+	p.pool[len(p.pool)-1] = nil
+	p.pool = p.pool[:len(p.pool)-1]
+	return v
+}
+
+func (p *drawTrianglesCommandPool) put(v *drawTrianglesCommand) {
+	if len(p.pool) >= 1024 {
+		return
+	}
+	p.pool = append(p.pool, v)
+}
+
+// drawTrianglesCommand represents a drawing command to draw an image on another image.
+type drawTrianglesCommand struct {
+	dst        *Image
+	srcs       [graphics.ShaderImageCount]*Image
+	vertices   []float32
+	blend      graphicsdriver.Blend
+	dstRegions []graphicsdriver.DstRegion
+	shader     *Shader
+	uniforms   []uint32
+	fillRule   graphicsdriver.FillRule
+}
+
+func (c *drawTrianglesCommand) String() string {
+	// TODO: Improve readability
+	blend := fmt.Sprintf("{src-color: %d, src-alpha: %d, dst-color: %d, dst-alpha: %d, op-color: %d, op-alpha: %d}",
+		c.blend.BlendFactorSourceRGB,
+		c.blend.BlendFactorSourceAlpha,
+		c.blend.BlendFactorDestinationRGB,
+		c.blend.BlendFactorDestinationAlpha,
+		c.blend.BlendOperationRGB,
+		c.blend.BlendOperationAlpha)
+
+	dst := fmt.Sprintf("%d", c.dst.id)
+	if c.dst.screen {
+		dst += " (screen)"
+	}
+
+	var srcstrs [graphics.ShaderImageCount]string
+	for i, src := range c.srcs {
+		if src == nil {
+			srcstrs[i] = "(nil)"
+			continue
+		}
+		srcstrs[i] = fmt.Sprintf("%d", src.id)
+		if src.screen {
+			srcstrs[i] += " (screen)"
+		}
+	}
+
+	return fmt.Sprintf("draw-triangles: dst: %s <- src: [%s], num of dst regions: %d, num of indices: %d, blend: %s, fill rule: %s, shader id: %d", dst, strings.Join(srcstrs[:], ", "), len(c.dstRegions), c.numIndices(), blend, c.fillRule, c.shader.id)
+}
+
+// Exec executes the drawTrianglesCommand.
+func (c *drawTrianglesCommand) Exec(commandQueue *commandQueue, graphicsDriver graphicsdriver.Graphics, indexOffset int) error {
+	// TODO: Is it ok not to bind any framebuffer here?
+	if len(c.dstRegions) == 0 {
+		return nil
+	}
+
+	var imgs [graphics.ShaderImageCount]graphicsdriver.ImageID
+	for i, src := range c.srcs {
+		if src == nil {
+			imgs[i] = graphicsdriver.InvalidImageID
+			continue
+		}
+		imgs[i] = src.image.ID()
+	}
+
+	return graphicsDriver.DrawTriangles(c.dst.image.ID(), imgs, c.shader.shader.ID(), c.dstRegions, indexOffset, c.blend, c.uniforms, c.fillRule)
+}
+
+func (c *drawTrianglesCommand) NeedsSync() bool {
+	return false
+}
+
+func (c *drawTrianglesCommand) numVertices() int {
+	return len(c.vertices)
+}
+
+func (c *drawTrianglesCommand) numIndices() int {
+	var nindices int
+	for _, dstRegion := range c.dstRegions {
+		nindices += dstRegion.IndexCount
+	}
+	return nindices
+}
+
+func (c *drawTrianglesCommand) setVertices(vertices []float32) {
+	c.vertices = vertices
+}
+
+// CanMergeWithDrawTrianglesCommand returns a boolean value indicating whether the other drawTrianglesCommand can be merged
+// with the drawTrianglesCommand c.
+func (c *drawTrianglesCommand) CanMergeWithDrawTrianglesCommand(dst *Image, srcs [graphics.ShaderImageCount]*Image, vertices []float32, blend graphicsdriver.Blend, shader *Shader, uniforms []uint32, fillRule graphicsdriver.FillRule) bool {
+	if c.shader != shader {
+		return false
+	}
+	if len(c.uniforms) != len(uniforms) {
+		return false
+	}
+	for i := range c.uniforms {
+		if c.uniforms[i] != uniforms[i] {
+			return false
+		}
+	}
+	if c.dst != dst {
+		return false
+	}
+	if c.srcs != srcs {
+		return false
+	}
+	if c.blend != blend {
+		return false
+	}
+	if c.fillRule != fillRule {
+		return false
+	}
+	if c.fillRule != graphicsdriver.FillAll && mightOverlapDstRegions(c.vertices, vertices) {
+		return false
+	}
+	return true
+}
+
+var (
+	posInf32 = float32(math.Inf(1))
+	negInf32 = float32(math.Inf(-1))
+)
+
+func dstRegionFromVertices(vertices []float32) (minX, minY, maxX, maxY float32) {
+	minX = posInf32
+	minY = posInf32
+	maxX = negInf32
+	maxY = negInf32
+
+	for i := 0; i < len(vertices)/graphics.VertexFloatCount; i++ {
+		x := vertices[graphics.VertexFloatCount*i]
+		y := vertices[graphics.VertexFloatCount*i+1]
+		if x < minX {
+			minX = x
+		}
+		if y < minY {
+			minY = y
+		}
+		if maxX < x {
+			maxX = x
+		}
+		if maxY < y {
+			maxY = y
+		}
+	}
+	return
+}
+
+func mightOverlapDstRegions(vertices1, vertices2 []float32) bool {
+	minX1, minY1, maxX1, maxY1 := dstRegionFromVertices(vertices1)
+	minX2, minY2, maxX2, maxY2 := dstRegionFromVertices(vertices2)
+	const margin = 1
+	return minX1 < maxX2+margin && minX2 < maxX1+margin && minY1 < maxY2+margin && minY2 < maxY1+margin
+}
+
+// writePixelsCommand represents a command to replace pixels of an image.
+type writePixelsCommand struct {
+	dst  *Image
+	args []writePixelsCommandArgs
+}
+
+type writePixelsCommandArgs struct {
+	pixels *graphics.ManagedBytes
+	region image.Rectangle
+}
+
+func (c *writePixelsCommand) String() string {
+	return fmt.Sprintf("write-pixels: dst: %d, len(args): %d", c.dst.id, len(c.args))
+}
+
+// Exec executes the writePixelsCommand.
+func (c *writePixelsCommand) Exec(commandQueue *commandQueue, graphicsDriver graphicsdriver.Graphics, indexOffset int) error {
+	if len(c.args) == 0 {
+		return nil
+	}
+	args := make([]graphicsdriver.PixelsArgs, 0, len(c.args))
+	for _, a := range c.args {
+		pix, f := a.pixels.GetAndRelease()
+		// A finalizer is executed when flushing the queue at the end of the frame.
+		// At the end of the frame, the last command is rendering triangles onto the screen,
+		// so the bytes are already sent to GPU and synced.
+		// TODO: This might be fragile. When is the better time to call finalizers by a command queue?
+		commandQueue.addFinalizer(f)
+		args = append(args, graphicsdriver.PixelsArgs{
+			Pixels: pix,
+			Region: a.region,
+		})
+	}
+	if err := c.dst.image.WritePixels(args); err != nil {
+		return err
+	}
+	return nil
+}
+
+func (c *writePixelsCommand) NeedsSync() bool {
+	return false
+}
+
+type readPixelsCommand struct {
+	img  *Image
+	args []graphicsdriver.PixelsArgs
+}
+
+// Exec executes a readPixelsCommand.
+func (c *readPixelsCommand) Exec(commandQueue *commandQueue, graphicsDriver graphicsdriver.Graphics, indexOffset int) error {
+	if err := c.img.image.ReadPixels(c.args); err != nil {
+		return err
+	}
+	return nil
+}
+
+func (c *readPixelsCommand) NeedsSync() bool {
+	return true
+}
+
+func (c *readPixelsCommand) String() string {
+	return fmt.Sprintf("read-pixels: image: %d", c.img.id)
+}
+
+// disposeImageCommand represents a command to dispose an image.
+type disposeImageCommand struct {
+	target *Image
+}
+
+func (c *disposeImageCommand) String() string {
+	return fmt.Sprintf("dispose-image: target: %d", c.target.id)
+}
+
+// Exec executes the disposeImageCommand.
+func (c *disposeImageCommand) Exec(commandQueue *commandQueue, graphicsDriver graphicsdriver.Graphics, indexOffset int) error {
+	c.target.image.Dispose()
+	return nil
+}
+
+func (c *disposeImageCommand) NeedsSync() bool {
+	return false
+}
+
+// disposeShaderCommand represents a command to dispose a shader.
+type disposeShaderCommand struct {
+	target *Shader
+}
+
+func (c *disposeShaderCommand) String() string {
+	return "dispose-shader: target"
+}
+
+// Exec executes the disposeShaderCommand.
+func (c *disposeShaderCommand) Exec(commandQueue *commandQueue, graphicsDriver graphicsdriver.Graphics, indexOffset int) error {
+	c.target.shader.Dispose()
+	return nil
+}
+
+func (c *disposeShaderCommand) NeedsSync() bool {
+	return false
+}
+
+// newImageCommand represents a command to create an empty image with given width and height.
+type newImageCommand struct {
+	result *Image
+	width  int
+	height int
+	screen bool
+}
+
+func (c *newImageCommand) String() string {
+	return fmt.Sprintf("new-image: result: %d, width: %d, height: %d, screen: %t", c.result.id, c.width, c.height, c.screen)
+}
+
+// Exec executes a newImageCommand.
+func (c *newImageCommand) Exec(commandQueue *commandQueue, graphicsDriver graphicsdriver.Graphics, indexOffset int) error {
+	var err error
+	if c.screen {
+		c.result.image, err = graphicsDriver.NewScreenFramebufferImage(c.width, c.height)
+	} else {
+		c.result.image, err = graphicsDriver.NewImage(c.width, c.height)
+	}
+	return err
+}
+
+func (c *newImageCommand) NeedsSync() bool {
+	return true
+}
+
+// newShaderCommand is a command to create a shader.
+type newShaderCommand struct {
+	result *Shader
+	ir     *shaderir.Program
+}
+
+func (c *newShaderCommand) String() string {
+	return "new-shader"
+}
+
+// Exec executes a newShaderCommand.
+func (c *newShaderCommand) Exec(commandQueue *commandQueue, graphicsDriver graphicsdriver.Graphics, indexOffset int) error {
+	s, err := graphicsDriver.NewShader(c.ir)
+	if err != nil {
+		return err
+	}
+	c.result.shader = s
+	return nil
+}
+
+func (c *newShaderCommand) NeedsSync() bool {
+	return true
+}
+
+// InitializeGraphicsDriverState initialize the current graphics driver state.
+func InitializeGraphicsDriverState(graphicsDriver graphicsdriver.Graphics) (err error) {
+	runOnRenderThread(func() {
+		err = graphicsDriver.Initialize()
+	}, true)
+	return
+}
+
+// ResetGraphicsDriverState resets the current graphics driver state.
+// If the graphics driver doesn't have an API to reset, ResetGraphicsDriverState does nothing.
+func ResetGraphicsDriverState(graphicsDriver graphicsdriver.Graphics) (err error) {
+	if r, ok := graphicsDriver.(graphicsdriver.Resetter); ok {
+		runOnRenderThread(func() {
+			err = r.Reset()
+		}, true)
+	}
+	return nil
+}
+
+// MaxImageSize returns the maximum size of an image.
+func MaxImageSize(graphicsDriver graphicsdriver.Graphics) int {
+	var size int
+	runOnRenderThread(func() {
+		size = graphicsDriver.MaxImageSize()
+	}, true)
+	return size
+}

vendor/github.com/hajimehoshi/ebiten/v2/internal/graphicscommand/commandqueue.go

@@ -0,0 +1,529 @@
+// Copyright 2023 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.
+
+package graphicscommand
+
+import (
+	"fmt"
+	"image"
+	"math"
+	"sync"
+	"sync/atomic"
+
+	"github.com/hajimehoshi/ebiten/v2/internal/debug"
+	"github.com/hajimehoshi/ebiten/v2/internal/graphics"
+	"github.com/hajimehoshi/ebiten/v2/internal/graphicsdriver"
+	"github.com/hajimehoshi/ebiten/v2/internal/shaderir"
+)
+
+const (
+	is32bit = 1 >> (^uint(0) >> 63)
+	is64bit = 1 - is32bit
+
+	// MaxVertexCount is the maximum number of vertices for one draw call.
+	//
+	// On 64bit architectures, this value is 2^32-1, as the index type is uint32.
+	// This value cannot be exactly 2^32 especially with WebGL 2, as 2^32th vertex is not rendered correctly.
+	// See https://registry.khronos.org/webgl/specs/latest/2.0/#5.18 .
+	//
+	// On 32bit architectures, this value is an adjusted number so that maxVertexFloatCount doesn't overflow int.
+	MaxVertexCount = is64bit*math.MaxUint32 + is32bit*(math.MaxInt32/graphics.VertexFloatCount)
+
+	maxVertexFloatCount = MaxVertexCount * graphics.VertexFloatCount
+)
+
+var vsyncEnabled int32 = 1
+
+func SetVsyncEnabled(enabled bool, graphicsDriver graphicsdriver.Graphics) {
+	if enabled {
+		atomic.StoreInt32(&vsyncEnabled, 1)
+	} else {
+		atomic.StoreInt32(&vsyncEnabled, 0)
+	}
+
+	runOnRenderThread(func() {
+		graphicsDriver.SetVsyncEnabled(enabled)
+	}, true)
+}
+
+// FlushCommands flushes the command queue and present the screen if needed.
+// If endFrame is true, the current screen might be used to present.
+func FlushCommands(graphicsDriver graphicsdriver.Graphics, endFrame bool) error {
+	if err := theCommandQueueManager.flush(graphicsDriver, endFrame); err != nil {
+		return err
+	}
+	return nil
+}
+
+// commandQueue is a command queue for drawing commands.
+type commandQueue struct {
+	// commands is a queue of drawing commands.
+	commands []command
+
+	// vertices represents a vertices data in OpenGL's array buffer.
+	vertices []float32
+	indices  []uint32
+
+	tmpNumVertexFloats int
+
+	drawTrianglesCommandPool drawTrianglesCommandPool
+
+	uint32sBuffer uint32sBuffer
+	finalizers    []func()
+
+	err atomic.Value
+}
+
+// addFinalizer adds a finalizer function to this queue.
+// A finalizer is executed when the command queue is flushed at the end of the frame.
+func (q *commandQueue) addFinalizer(f func()) {
+	q.finalizers = append(q.finalizers, f)
+}
+
+func (q *commandQueue) appendIndices(indices []uint32, offset uint32) {
+	n := len(q.indices)
+	q.indices = append(q.indices, indices...)
+	for i := n; i < len(q.indices); i++ {
+		q.indices[i] += offset
+	}
+}
+
+// mustUseDifferentVertexBuffer reports whether a different vertex buffer must be used.
+func mustUseDifferentVertexBuffer(nextNumVertexFloats int) bool {
+	return nextNumVertexFloats > maxVertexFloatCount
+}
+
+// EnqueueDrawTrianglesCommand enqueues a drawing-image command.
+func (q *commandQueue) EnqueueDrawTrianglesCommand(dst *Image, srcs [graphics.ShaderImageCount]*Image, vertices []float32, indices []uint32, blend graphicsdriver.Blend, dstRegion image.Rectangle, srcRegions [graphics.ShaderImageCount]image.Rectangle, shader *Shader, uniforms []uint32, fillRule graphicsdriver.FillRule) {
+	if len(vertices) > maxVertexFloatCount {
+		panic(fmt.Sprintf("graphicscommand: len(vertices) must equal to or less than %d but was %d", maxVertexFloatCount, len(vertices)))
+	}
+
+	split := false
+	if mustUseDifferentVertexBuffer(q.tmpNumVertexFloats + len(vertices)) {
+		q.tmpNumVertexFloats = 0
+		split = true
+	}
+
+	// Assume that all the image sizes are same.
+	// Assume that the images are packed from the front in the slice srcs.
+	q.vertices = append(q.vertices, vertices...)
+	q.appendIndices(indices, uint32(q.tmpNumVertexFloats/graphics.VertexFloatCount))
+	q.tmpNumVertexFloats += len(vertices)
+
+	// prependPreservedUniforms not only prepends values to the given slice but also creates a new slice.
+	// Allocating a new slice is necessary to make EnqueueDrawTrianglesCommand safe so far.
+	// TODO: This might cause a performance issue (#2601).
+	uniforms = q.prependPreservedUniforms(uniforms, shader, dst, srcs, dstRegion, srcRegions)
+
+	// Remove unused uniform variables so that more commands can be merged.
+	shader.ir.FilterUniformVariables(uniforms)
+
+	// TODO: If dst is the screen, reorder the command to be the last.
+	if !split && 0 < len(q.commands) {
+		if last, ok := q.commands[len(q.commands)-1].(*drawTrianglesCommand); ok {
+			if last.CanMergeWithDrawTrianglesCommand(dst, srcs, vertices, blend, shader, uniforms, fillRule) {
+				last.setVertices(q.lastVertices(len(vertices) + last.numVertices()))
+				if last.dstRegions[len(last.dstRegions)-1].Region == dstRegion {
+					last.dstRegions[len(last.dstRegions)-1].IndexCount += len(indices)
+				} else {
+					last.dstRegions = append(last.dstRegions, graphicsdriver.DstRegion{
+						Region:     dstRegion,
+						IndexCount: len(indices),
+					})
+				}
+				return
+			}
+		}
+	}
+
+	c := q.drawTrianglesCommandPool.get()
+	c.dst = dst
+	c.srcs = srcs
+	c.vertices = q.lastVertices(len(vertices))
+	c.blend = blend
+	c.dstRegions = []graphicsdriver.DstRegion{
+		{
+			Region:     dstRegion,
+			IndexCount: len(indices),
+		},
+	}
+	c.shader = shader
+	c.uniforms = uniforms
+	c.fillRule = fillRule
+	q.commands = append(q.commands, c)
+}
+
+func (q *commandQueue) lastVertices(n int) []float32 {
+	return q.vertices[len(q.vertices)-n : len(q.vertices)]
+}
+
+// Enqueue enqueues a drawing command other than a draw-triangles command.
+//
+// For a draw-triangles command, use EnqueueDrawTrianglesCommand.
+func (q *commandQueue) Enqueue(command command) {
+	// TODO: If dst is the screen, reorder the command to be the last.
+	q.commands = append(q.commands, command)
+}
+
+// Flush flushes the command queue.
+func (q *commandQueue) Flush(graphicsDriver graphicsdriver.Graphics, endFrame bool) error {
+	if err := q.err.Load(); err != nil {
+		return err.(error)
+	}
+
+	var sync bool
+	// Disable asynchronous rendering when vsync is on, as this causes a rendering delay (#2822).
+	if endFrame && atomic.LoadInt32(&vsyncEnabled) != 0 {
+		sync = true
+	}
+	if !sync {
+		for _, c := range q.commands {
+			if c.NeedsSync() {
+				sync = true
+				break
+			}
+		}
+	}
+
+	logger := debug.SwitchLogger()
+
+	var flushErr error
+	runOnRenderThread(func() {
+		defer logger.Flush()
+
+		if err := q.flush(graphicsDriver, endFrame, logger); err != nil {
+			if sync {
+				flushErr = err
+				return
+			}
+			q.err.Store(err)
+			return
+		}
+
+		theCommandQueueManager.putCommandQueue(q)
+	}, sync)
+
+	if sync && flushErr != nil {
+		return flushErr
+	}
+
+	return nil
+}
+
+// flush must be called the render thread.
+func (q *commandQueue) flush(graphicsDriver graphicsdriver.Graphics, endFrame bool, logger debug.Logger) (err error) {
+	// If endFrame is true, Begin/End should be called to ensure the framebuffer is swapped.
+	if len(q.commands) == 0 && !endFrame {
+		return nil
+	}
+
+	es := q.indices
+	vs := q.vertices
+	logger.Logf("Graphics commands:\n")
+
+	if err := graphicsDriver.Begin(); err != nil {
+		return err
+	}
+
+	defer func() {
+		// Call End even if an error causes, or the graphics driver's state might be stale (#2388).
+		if err1 := graphicsDriver.End(endFrame); err1 != nil && err == nil {
+			err = err1
+		}
+
+		// Release the commands explicitly (#1803).
+		// Apparently, the part of a slice between len and cap-1 still holds references.
+		// Then, resetting the length by [:0] doesn't release the references.
+		for i, c := range q.commands {
+			if c, ok := c.(*drawTrianglesCommand); ok {
+				q.drawTrianglesCommandPool.put(c)
+			}
+			q.commands[i] = nil
+		}
+		q.commands = q.commands[:0]
+		q.vertices = q.vertices[:0]
+		q.indices = q.indices[:0]
+		q.tmpNumVertexFloats = 0
+
+		if endFrame {
+			q.uint32sBuffer.reset()
+			for i, f := range q.finalizers {
+				f()
+				q.finalizers[i] = nil
+			}
+			q.finalizers = q.finalizers[:0]
+		}
+	}()
+
+	cs := q.commands
+	for len(cs) > 0 {
+		nv := 0
+		ne := 0
+		nc := 0
+		for _, c := range cs {
+			if dtc, ok := c.(*drawTrianglesCommand); ok {
+				if nc > 0 && mustUseDifferentVertexBuffer(nv+dtc.numVertices()) {
+					break
+				}
+				nv += dtc.numVertices()
+				ne += dtc.numIndices()
+			}
+			nc++
+		}
+		if 0 < ne {
+			if err := graphicsDriver.SetVertices(vs[:nv], es[:ne]); err != nil {
+				return err
+			}
+			es = es[ne:]
+			vs = vs[nv:]
+		}
+		indexOffset := 0
+		for _, c := range cs[:nc] {
+			if err := c.Exec(q, graphicsDriver, indexOffset); err != nil {
+				return err
+			}
+			logger.Logf("  %s\n", c)
+			// TODO: indexOffset should be reset if the command type is different
+			// from the previous one. This fix is needed when another drawing command is
+			// introduced than drawTrianglesCommand.
+			if dtc, ok := c.(*drawTrianglesCommand); ok {
+				indexOffset += dtc.numIndices()
+			}
+		}
+		cs = cs[nc:]
+	}
+
+	return nil
+}
+
+type rectangleF32 struct {
+	x      float32
+	y      float32
+	width  float32
+	height float32
+}
+
+func imageRectangleToRectangleF32(r image.Rectangle) rectangleF32 {
+	return rectangleF32{
+		x:      float32(r.Min.X),
+		y:      float32(r.Min.Y),
+		width:  float32(r.Dx()),
+		height: float32(r.Dy()),
+	}
+}
+
+func (q *commandQueue) prependPreservedUniforms(uniforms []uint32, shader *Shader, dst *Image, srcs [graphics.ShaderImageCount]*Image, dstRegion image.Rectangle, srcRegions [graphics.ShaderImageCount]image.Rectangle) []uint32 {
+	origUniforms := uniforms
+	uniforms = q.uint32sBuffer.alloc(len(origUniforms) + graphics.PreservedUniformUint32Count)
+	copy(uniforms[graphics.PreservedUniformUint32Count:], origUniforms)
+
+	// Set the destination texture size.
+	dw, dh := dst.InternalSize()
+	uniforms[0] = math.Float32bits(float32(dw))
+	uniforms[1] = math.Float32bits(float32(dh))
+	uniformIndex := 2
+
+	for i := 0; i < graphics.ShaderImageCount; i++ {
+		var floatW, floatH uint32
+		if srcs[i] != nil {
+			w, h := srcs[i].InternalSize()
+			floatW = math.Float32bits(float32(w))
+			floatH = math.Float32bits(float32(h))
+		}
+
+		uniforms[uniformIndex+i*2] = floatW
+		uniforms[uniformIndex+1+i*2] = floatH
+	}
+	uniformIndex += graphics.ShaderImageCount * 2
+
+	dr := imageRectangleToRectangleF32(dstRegion)
+	if shader.unit() == shaderir.Texels {
+		dr.x /= float32(dw)
+		dr.y /= float32(dh)
+		dr.width /= float32(dw)
+		dr.height /= float32(dh)
+	}
+
+	// Set the destination region origin.
+	uniforms[uniformIndex] = math.Float32bits(dr.x)
+	uniforms[uniformIndex+1] = math.Float32bits(dr.y)
+	uniformIndex += 2
+
+	// Set the destination region size.
+	uniforms[uniformIndex] = math.Float32bits(dr.width)
+	uniforms[uniformIndex+1] = math.Float32bits(dr.height)
+	uniformIndex += 2
+
+	var srs [graphics.ShaderImageCount]rectangleF32
+	for i, r := range srcRegions {
+		srs[i] = imageRectangleToRectangleF32(r)
+	}
+	if shader.unit() == shaderir.Texels {
+		for i, src := range srcs {
+			if src == nil {
+				continue
+			}
+			w, h := src.InternalSize()
+			srs[i].x /= float32(w)
+			srs[i].y /= float32(h)
+			srs[i].width /= float32(w)
+			srs[i].height /= float32(h)
+		}
+	}
+
+	// Set the source region origins.
+	for i := 0; i < graphics.ShaderImageCount; i++ {
+		uniforms[uniformIndex+i*2] = math.Float32bits(srs[i].x)
+		uniforms[uniformIndex+1+i*2] = math.Float32bits(srs[i].y)
+	}
+	uniformIndex += graphics.ShaderImageCount * 2
+
+	// Set the source region sizes.
+	for i := 0; i < graphics.ShaderImageCount; i++ {
+		uniforms[uniformIndex+i*2] = math.Float32bits(srs[i].width)
+		uniforms[uniformIndex+1+i*2] = math.Float32bits(srs[i].height)
+	}
+	uniformIndex += graphics.ShaderImageCount * 2
+
+	// Set the projection matrix.
+	uniforms[uniformIndex] = math.Float32bits(2 / float32(dw))
+	uniforms[uniformIndex+1] = 0
+	uniforms[uniformIndex+2] = 0
+	uniforms[uniformIndex+3] = 0
+	uniforms[uniformIndex+4] = 0
+	uniforms[uniformIndex+5] = math.Float32bits(2 / float32(dh))
+	uniforms[uniformIndex+6] = 0
+	uniforms[uniformIndex+7] = 0
+	uniforms[uniformIndex+8] = 0
+	uniforms[uniformIndex+9] = 0
+	uniforms[uniformIndex+10] = math.Float32bits(1)
+	uniforms[uniformIndex+11] = 0
+	uniforms[uniformIndex+12] = math.Float32bits(-1)
+	uniforms[uniformIndex+13] = math.Float32bits(-1)
+	uniforms[uniformIndex+14] = 0
+	uniforms[uniformIndex+15] = math.Float32bits(1)
+
+	return uniforms
+}
+
+type commandQueuePool struct {
+	cache []*commandQueue
+	m     sync.Mutex
+}
+
+func (c *commandQueuePool) get() (*commandQueue, error) {
+	c.m.Lock()
+	defer c.m.Unlock()
+
+	if len(c.cache) == 0 {
+		return &commandQueue{}, nil
+	}
+
+	for _, q := range c.cache {
+		if err := q.err.Load(); err != nil {
+			return nil, err.(error)
+		}
+	}
+
+	q := c.cache[len(c.cache)-1]
+	c.cache[len(c.cache)-1] = nil
+	c.cache = c.cache[:len(c.cache)-1]
+	return q, nil
+}
+
+func (c *commandQueuePool) put(queue *commandQueue) {
+	c.m.Lock()
+	defer c.m.Unlock()
+
+	c.cache = append(c.cache, queue)
+}
+
+type commandQueueManager struct {
+	pool    commandQueuePool
+	current *commandQueue
+}
+
+var theCommandQueueManager commandQueueManager
+
+func (c *commandQueueManager) enqueueCommand(command command) {
+	if c.current == nil {
+		c.current, _ = c.pool.get()
+	}
+	c.current.Enqueue(command)
+}
+
+// put can be called from any goroutines.
+func (c *commandQueueManager) putCommandQueue(commandQueue *commandQueue) {
+	c.pool.put(commandQueue)
+}
+
+func (c *commandQueueManager) enqueueDrawTrianglesCommand(dst *Image, srcs [graphics.ShaderImageCount]*Image, vertices []float32, indices []uint32, blend graphicsdriver.Blend, dstRegion image.Rectangle, srcRegions [graphics.ShaderImageCount]image.Rectangle, shader *Shader, uniforms []uint32, fillRule graphicsdriver.FillRule) {
+	if c.current == nil {
+		c.current, _ = c.pool.get()
+	}
+	c.current.EnqueueDrawTrianglesCommand(dst, srcs, vertices, indices, blend, dstRegion, srcRegions, shader, uniforms, fillRule)
+}
+
+func (c *commandQueueManager) flush(graphicsDriver graphicsdriver.Graphics, endFrame bool) error {
+	// Switch the command queue.
+	prev := c.current
+	q, err := c.pool.get()
+	if err != nil {
+		return err
+	}
+	c.current = q
+
+	if prev == nil {
+		return nil
+	}
+	if err := prev.Flush(graphicsDriver, endFrame); err != nil {
+		return err
+	}
+	return nil
+}
+
+// uint32sBuffer is a reusable buffer to allocate []uint32.
+type uint32sBuffer struct {
+	buf []uint32
+}
+
+func roundUpPower2(x int) int {
+	p2 := 1
+	for p2 < x {
+		p2 *= 2
+	}
+	return p2
+}
+
+func max(a, b int) int {
+	if a < b {
+		return b
+	}
+	return a
+}
+
+func (b *uint32sBuffer) alloc(n int) []uint32 {
+	buf := b.buf
+	if len(buf)+n > cap(buf) {
+		buf = make([]uint32, 0, max(roundUpPower2(len(buf)+n), 16))
+	}
+	s := buf[len(buf) : len(buf)+n]
+	b.buf = buf[:len(buf)+n]
+	return s
+}
+
+func (b *uint32sBuffer) reset() {
+	b.buf = b.buf[:0]
+}

vendor/github.com/hajimehoshi/ebiten/v2/internal/graphicscommand/doc.go

@@ -0,0 +1,16 @@
+// Copyright 2017 The Ebiten 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.
+
+// Package graphicscommand represents a low layer for graphics using OpenGL.
+package graphicscommand

vendor/github.com/hajimehoshi/ebiten/v2/internal/graphicscommand/image.go

@@ -0,0 +1,235 @@
+// Copyright 2016 Hajime Hoshi
+//
+// 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.
+
+package graphicscommand
+
+import (
+	"fmt"
+	"image"
+	"io"
+	"sort"
+	"strconv"
+	"strings"
+
+	"github.com/hajimehoshi/ebiten/v2/internal/debug"
+	"github.com/hajimehoshi/ebiten/v2/internal/graphics"
+	"github.com/hajimehoshi/ebiten/v2/internal/graphicsdriver"
+	"github.com/hajimehoshi/ebiten/v2/internal/png"
+)
+
+// Image represents an image that is implemented with OpenGL.
+type Image struct {
+	image          graphicsdriver.Image
+	width          int
+	height         int
+	internalWidth  int
+	internalHeight int
+	screen         bool
+
+	// 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.
+	id int
+
+	bufferedWritePixelsArgs []writePixelsCommandArgs
+}
+
+var nextImageID = 1
+
+func genNextImageID() int {
+	id := nextImageID
+	nextImageID++
+	return id
+}
+
+// NewImage returns a new image.
+//
+// Note that the image is not initialized yet.
+func NewImage(width, height int, screenFramebuffer bool) *Image {
+	i := &Image{
+		width:  width,
+		height: height,
+		screen: screenFramebuffer,
+		id:     genNextImageID(),
+	}
+	c := &newImageCommand{
+		result: i,
+		width:  width,
+		height: height,
+		screen: screenFramebuffer,
+	}
+	theCommandQueueManager.enqueueCommand(c)
+	return i
+}
+
+func (i *Image) flushBufferedWritePixels() {
+	if len(i.bufferedWritePixelsArgs) == 0 {
+		return
+	}
+
+	c := &writePixelsCommand{
+		dst:  i,
+		args: i.bufferedWritePixelsArgs,
+	}
+	theCommandQueueManager.enqueueCommand(c)
+
+	i.bufferedWritePixelsArgs = nil
+}
+
+func (i *Image) Dispose() {
+	i.bufferedWritePixelsArgs = nil
+	c := &disposeImageCommand{
+		target: i,
+	}
+	theCommandQueueManager.enqueueCommand(c)
+}
+
+func (i *Image) InternalSize() (int, int) {
+	if i.screen {
+		return i.width, i.height
+	}
+	if i.internalWidth == 0 {
+		i.internalWidth = graphics.InternalImageSize(i.width)
+	}
+	if i.internalHeight == 0 {
+		i.internalHeight = graphics.InternalImageSize(i.height)
+	}
+	return i.internalWidth, i.internalHeight
+}
+
+// DrawTriangles draws triangles with the given image.
+//
+// The vertex floats are:
+//
+//	0: Destination X in pixels
+//	1: Destination Y in pixels
+//	2: Source X in texels
+//	3: Source Y in texels
+//	4: Color R [0.0-1.0]
+//	5: Color G
+//	6: Color B
+//	7: Color Y
+//
+// src and shader are exclusive and only either is non-nil.
+//
+// The elements that index is in between 2 and 7 are used for the source images.
+// The source image is 1) src argument if non-nil, or 2) an image value in the uniform variables if it exists.
+// If there are multiple images in the uniform variables, the smallest ID's value is adopted.
+//
+// If the source image is not specified, i.e., src is nil and there is no image in the uniform variables, the
+// elements for the source image are not used.
+func (i *Image) DrawTriangles(srcs [graphics.ShaderImageCount]*Image, vertices []float32, indices []uint32, blend graphicsdriver.Blend, dstRegion image.Rectangle, srcRegions [graphics.ShaderImageCount]image.Rectangle, shader *Shader, uniforms []uint32, fillRule graphicsdriver.FillRule) {
+	for _, src := range srcs {
+		if src == nil {
+			continue
+		}
+		if src.screen {
+			panic("graphicscommand: the screen image cannot be the rendering source")
+		}
+		src.flushBufferedWritePixels()
+	}
+	i.flushBufferedWritePixels()
+
+	theCommandQueueManager.enqueueDrawTrianglesCommand(i, srcs, vertices, indices, blend, dstRegion, srcRegions, shader, uniforms, fillRule)
+}
+
+// ReadPixels reads the image's pixels.
+// ReadPixels returns an error when an error happens in the graphics driver.
+func (i *Image) ReadPixels(graphicsDriver graphicsdriver.Graphics, args []graphicsdriver.PixelsArgs) error {
+	i.flushBufferedWritePixels()
+	c := &readPixelsCommand{
+		img:  i,
+		args: args,
+	}
+	theCommandQueueManager.enqueueCommand(c)
+	if err := theCommandQueueManager.flush(graphicsDriver, false); err != nil {
+		return err
+	}
+	return nil
+}
+
+func (i *Image) WritePixels(pixels *graphics.ManagedBytes, region image.Rectangle) {
+	// Release the previous pixels if the region is included by the new region.
+	// Successive WritePixels calls might accumulate the pixels and never release,
+	// especially when the image is unmanaged (#3036).
+	var cur int
+	for idx := 0; idx < len(i.bufferedWritePixelsArgs); idx++ {
+		arg := i.bufferedWritePixelsArgs[idx]
+		if arg.region.In(region) {
+			arg.pixels.Release()
+			continue
+		}
+		i.bufferedWritePixelsArgs[cur] = arg
+		cur++
+	}
+	for idx := cur; idx < len(i.bufferedWritePixelsArgs); idx++ {
+		i.bufferedWritePixelsArgs[idx] = writePixelsCommandArgs{}
+	}
+	i.bufferedWritePixelsArgs = append(i.bufferedWritePixelsArgs[:cur], writePixelsCommandArgs{
+		pixels: pixels,
+		region: region,
+	})
+}
+
+func (i *Image) dumpName(path string) string {
+	return strings.ReplaceAll(path, "*", strconv.Itoa(i.id))
+}
+
+// dumpTo dumps the image to the specified writer.
+//
+// If blackbg is true, any alpha values in the dumped image will be 255.
+//
+// This is for testing usage.
+func (i *Image) dumpTo(w io.Writer, graphicsDriver graphicsdriver.Graphics, blackbg bool, rect image.Rectangle) error {
+	if i.screen {
+		return fmt.Errorf("graphicscommand: a screen image cannot be dumped")
+	}
+
+	pix := make([]byte, 4*i.width*i.height)
+	if err := i.ReadPixels(graphicsDriver, []graphicsdriver.PixelsArgs{
+		{
+			Pixels: pix,
+			Region: image.Rect(0, 0, i.width, i.height),
+		},
+	}); err != nil {
+		return err
+	}
+
+	if blackbg {
+		for i := 0; i < len(pix)/4; i++ {
+			pix[4*i+3] = 0xff
+		}
+	}
+
+	if err := png.Encode(w, (&image.RGBA{
+		Pix:    pix,
+		Stride: 4 * i.width,
+		Rect:   image.Rect(0, 0, i.width, i.height),
+	}).SubImage(rect)); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func LogImagesInfo(images []*Image) {
+	sort.Slice(images, func(a, b int) bool {
+		return images[a].id < images[b].id
+	})
+	for _, i := range images {
+		w, h := i.InternalSize()
+		debug.Logf("  %d: (%d, %d)\n", i.id, w, h)
+	}
+}

vendor/github.com/hajimehoshi/ebiten/v2/internal/graphicscommand/image_js.go

@@ -0,0 +1,87 @@
+// 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.
+
+package graphicscommand
+
+import (
+	"archive/zip"
+	"bytes"
+	"image"
+	"syscall/js"
+
+	"github.com/hajimehoshi/ebiten/v2/internal/graphicsdriver"
+)
+
+func download(buf *bytes.Buffer, mime string, path string) {
+	global := js.Global()
+
+	jsData := global.Get("Uint8Array").New(buf.Len())
+	js.CopyBytesToJS(jsData, buf.Bytes())
+
+	a := global.Get("document").Call("createElement", "a")
+	blob := global.Get("Blob").New(
+		[]any{jsData},
+		map[string]any{"type": mime},
+	)
+	a.Set("href", global.Get("URL").Call("createObjectURL", blob))
+	a.Set("download", path)
+	a.Call("click")
+}
+
+func (i *Image) Dump(graphicsDriver graphicsdriver.Graphics, path string, blackbg bool, rect image.Rectangle) (string, error) {
+	// Screen image cannot be dumped.
+	if i.screen {
+		return "", nil
+	}
+
+	buf := &bytes.Buffer{}
+	if err := i.dumpTo(buf, graphicsDriver, blackbg, rect); err != nil {
+		return "", err
+	}
+
+	download(buf, "image/png", i.dumpName(path))
+
+	return path, nil
+}
+
+// DumpImages dumps all the specified images to the specified directory.
+//
+// This is for testing usage.
+func DumpImages(images []*Image, graphicsDriver graphicsdriver.Graphics, dir string) (string, error) {
+	buf := &bytes.Buffer{}
+	zw := zip.NewWriter(buf)
+
+	for _, img := range images {
+		// Screen image cannot be dumped.
+		if img.screen {
+			continue
+		}
+
+		f, err := zw.Create(img.dumpName("*.png"))
+		if err != nil {
+			return "", err
+		}
+
+		if err := img.dumpTo(f, graphicsDriver, false, image.Rect(0, 0, img.width, img.height)); err != nil {
+			return "", err
+		}
+	}
+
+	_ = zw.Close()
+
+	zip := dir + ".zip"
+	download(buf, "archive/zip", zip)
+
+	return zip, nil
+}

vendor/github.com/hajimehoshi/ebiten/v2/internal/graphicscommand/image_notjs.go

@@ -0,0 +1,112 @@
+// 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 !js
+
+package graphicscommand
+
+import (
+	"bufio"
+	"errors"
+	"fmt"
+	"image"
+	"os"
+	"path/filepath"
+
+	"github.com/hajimehoshi/ebiten/v2/internal/graphicsdriver"
+)
+
+func (i *Image) Dump(graphicsDriver graphicsdriver.Graphics, path string, blackbg bool, rect image.Rectangle) (string, error) {
+	p, err := availableFilename(path)
+	if err != nil {
+		return "", err
+	}
+	path = p
+
+	path = i.dumpName(path)
+	f, err := os.Create(path)
+	if err != nil {
+		return "", err
+	}
+	defer func() {
+		_ = f.Close()
+	}()
+
+	w := bufio.NewWriter(f)
+	if err := i.dumpTo(w, graphicsDriver, blackbg, rect); err != nil {
+		return "", err
+	}
+	if err := w.Flush(); err != nil {
+		return "", err
+	}
+
+	return path, nil
+}
+
+// DumpImages dumps all the current images to the specified directory.
+//
+// This is for testing usage.
+func DumpImages(images []*Image, graphicsDriver graphicsdriver.Graphics, dir string) (string, error) {
+	d, err := availableFilename(dir)
+	if err != nil {
+		return "", err
+	}
+	dir = d
+
+	if err := os.Mkdir(dir, 0755); err != nil {
+		return "", err
+	}
+
+	for _, img := range images {
+		// Screen image cannot be dumped.
+		if img.screen {
+			continue
+		}
+
+		f, err := os.Create(filepath.Join(dir, img.dumpName("*.png")))
+		if err != nil {
+			return "", err
+		}
+		defer func() {
+			_ = f.Close()
+		}()
+
+		w := bufio.NewWriter(f)
+		if err := img.dumpTo(w, graphicsDriver, false, image.Rect(0, 0, img.width, img.height)); err != nil {
+			return "", err
+		}
+		if err := w.Flush(); err != nil {
+			return "", err
+		}
+	}
+
+	return dir, nil
+}
+
+// availableFilename returns a filename that is valid as a new file or directory.
+func availableFilename(name string) (string, error) {
+	ext := filepath.Ext(name)
+	base := name[:len(name)-len(ext)]
+
+	for i := 1; ; i++ {
+		if _, err := os.Stat(name); err != nil {
+			if errors.Is(err, os.ErrNotExist) {
+				break
+			}
+			return "", err
+		}
+		name = fmt.Sprintf("%s_%d%s", base, i, ext)
+	}
+	return name, nil
+}

vendor/github.com/hajimehoshi/ebiten/v2/internal/graphicscommand/shader.go

@@ -0,0 +1,58 @@
+// Copyright 2020 The Ebiten 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.
+
+package graphicscommand
+
+import (
+	"github.com/hajimehoshi/ebiten/v2/internal/graphicsdriver"
+	"github.com/hajimehoshi/ebiten/v2/internal/shaderir"
+)
+
+var nextShaderID = 1
+
+func genNextShaderID() int {
+	id := nextShaderID
+	nextShaderID++
+	return id
+}
+
+type Shader struct {
+	shader graphicsdriver.Shader
+	ir     *shaderir.Program
+	id     int
+}
+
+func NewShader(ir *shaderir.Program) *Shader {
+	s := &Shader{
+		ir: ir,
+		id: genNextShaderID(),
+	}
+	c := &newShaderCommand{
+		result: s,
+		ir:     ir,
+	}
+	theCommandQueueManager.enqueueCommand(c)
+	return s
+}
+
+func (s *Shader) Dispose() {
+	c := &disposeShaderCommand{
+		target: s,
+	}
+	theCommandQueueManager.enqueueCommand(c)
+}
+
+func (s *Shader) unit() shaderir.Unit {
+	return s.ir.Unit
+}

vendor/github.com/hajimehoshi/ebiten/v2/internal/graphicscommand/thread.go

@@ -0,0 +1,51 @@
+// Copyright 2020 The Ebiten 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.
+
+package graphicscommand
+
+import (
+	"context"
+
+	"github.com/hajimehoshi/ebiten/v2/internal/thread"
+)
+
+var theRenderThread thread.Thread = thread.NewNoopThread()
+
+// SetOSThreadAsRenderThread sets an OS thread as rendering thread e.g. for OpenGL.
+func SetOSThreadAsRenderThread() {
+	theRenderThread = thread.NewOSThread()
+}
+
+func LoopRenderThread(ctx context.Context) {
+	_ = theRenderThread.Loop(ctx)
+}
+
+// runOnRenderThread calls f on the rendering thread.
+func runOnRenderThread(f func(), sync bool) {
+	if sync {
+		theRenderThread.Call(f)
+		return
+	}
+
+	// As the current thread doesn't have a capacity in a channel,
+	// CallAsync should block when the previously-queued task is not executed yet.
+	// This blocking is expected as double-buffering is used.
+	theRenderThread.CallAsync(f)
+}
+
+func Terminate() {
+	// Post a task to the render thread to ensure all the queued functions are executed.
+	// This is necessary especially for GLFW. glfw.Terminate will remove the context and any graphics calls after that will be invalidated.
+	theRenderThread.Call(func() {})
+}