roodletoof/whiteboard
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

updated ebiten version from 2.7.9 to 2.9.9

Browse Source
This commit is contained in:
Ivar Fatland
2026-06-15 19:06:55 +02:00
parent 21edbc41c4
commit db1b625069
405 changed files with 31913 additions and 12595 deletions
Download Patch File Download Diff File Expand all files Collapse all files
vendor/github.com/hajimehoshi/ebiten/v2/internal/mipmap/mipmap.go
Generated Vendored
+99 -66
View File
@@ -23,6 +23,7 @@ import (
"github.com/hajimehoshi/ebiten/v2/internal/buffered"
"github.com/hajimehoshi/ebiten/v2/internal/graphics"
"github.com/hajimehoshi/ebiten/v2/internal/graphicsdriver"
"github.com/hajimehoshi/ebiten/v2/internal/restorable"
)
func canUseMipmap(imageType atlas.ImageType) bool {
@@ -40,7 +41,12 @@ type Mipmap struct {
height int
imageType atlas.ImageType
orig *buffered.Image
imgs map[int]*buffered.Image
imgs map[int]imageWithDirtyFlag
}
type imageWithDirtyFlag struct {
img *buffered.Image
dirty bool
}
func New(width, height int, imageType atlas.ImageType) *Mipmap {
@@ -58,63 +64,81 @@ func (m *Mipmap) DumpScreenshot(graphicsDriver graphicsdriver.Graphics, name str
func (m *Mipmap) WritePixels(pix []byte, region image.Rectangle) {
m.orig.WritePixels(pix, region)
m.deallocateMipmaps()
m.markDirty()
}
func (m *Mipmap) markDirty() {
for i, img := range m.imgs {
img.dirty = true
m.imgs[i] = img
}
}
func (m *Mipmap) ReadPixels(graphicsDriver graphicsdriver.Graphics, pixels []byte, region image.Rectangle) (ok bool, err error) {
return m.orig.ReadPixels(graphicsDriver, pixels, region)
}
func (m *Mipmap) DrawTriangles(srcs [graphics.ShaderImageCount]*Mipmap, vertices []float32, indices []uint32, blend graphicsdriver.Blend, dstRegion image.Rectangle, srcRegions [graphics.ShaderImageCount]image.Rectangle, shader *atlas.Shader, uniforms []uint32, fillRule graphicsdriver.FillRule, canSkipMipmap bool) {
func (m *Mipmap) DrawTriangles(srcs [graphics.ShaderSrcImageCount]*Mipmap, vertices []float32, indices []uint32, blend graphicsdriver.Blend, dstRegion image.Rectangle, srcRegions [graphics.ShaderSrcImageCount]image.Rectangle, shader *atlas.Shader, uniforms []uint32, fillRule graphicsdriver.FillRule, canSkipMipmap bool, hint restorable.Hint) {
if len(indices) == 0 {
return
}
level := 0
// TODO: Do we need to check all the sources' states of being volatile?
if !canSkipMipmap && srcs[0] != nil && canUseMipmap(srcs[0].imageType) {
level = math.MaxInt32
for i := 0; i < len(indices)/3; i++ {
const n = graphics.VertexFloatCount
dx0 := vertices[n*indices[3*i]+0]
dy0 := vertices[n*indices[3*i]+1]
sx0 := vertices[n*indices[3*i]+2]
sy0 := vertices[n*indices[3*i]+3]
dx1 := vertices[n*indices[3*i+1]+0]
dy1 := vertices[n*indices[3*i+1]+1]
sx1 := vertices[n*indices[3*i+1]+2]
sy1 := vertices[n*indices[3*i+1]+3]
dx2 := vertices[n*indices[3*i+2]+0]
dy2 := vertices[n*indices[3*i+2]+1]
sx2 := vertices[n*indices[3*i+2]+2]
sy2 := vertices[n*indices[3*i+2]+3]
if l := mipmapLevelFromDistance(dx0, dy0, dx1, dy1, sx0, sy0, sx1, sy1); level > l {
level = l
}
if l := mipmapLevelFromDistance(dx1, dy1, dx2, dy2, sx1, sy1, sx2, sy2); level > l {
level = l
}
if l := mipmapLevelFromDistance(dx2, dy2, dx0, dy0, sx2, sy2, sx0, sy0); level > l {
level = l
// Use the fast path if mipmap is not used.
if canSkipMipmap || srcs[0] == nil || !canUseMipmap(srcs[0].imageType) {
var imgs [graphics.ShaderSrcImageCount]*buffered.Image
for i, src := range srcs {
if src == nil {
continue
}
imgs[i] = src.orig
}
if level == math.MaxInt32 {
panic("mipmap: level must be calculated at least once but not")
}
m.orig.DrawTriangles(imgs, vertices, indices, blend, dstRegion, srcRegions, shader, uniforms, fillRule, hint)
m.markDirty()
return
}
var imgs [graphics.ShaderImageCount]*buffered.Image
level := math.MaxInt32
for i := 0; i < len(indices); i += 3 {
idx0 := indices[i]
idx1 := indices[i+1]
idx2 := indices[i+2]
dx0 := vertices[graphics.VertexFloatCount*idx0]
dy0 := vertices[graphics.VertexFloatCount*idx0+1]
sx0 := vertices[graphics.VertexFloatCount*idx0+2]
sy0 := vertices[graphics.VertexFloatCount*idx0+3]
dx1 := vertices[graphics.VertexFloatCount*idx1]
dy1 := vertices[graphics.VertexFloatCount*idx1+1]
sx1 := vertices[graphics.VertexFloatCount*idx1+2]
sy1 := vertices[graphics.VertexFloatCount*idx1+3]
dx2 := vertices[graphics.VertexFloatCount*idx2]
dy2 := vertices[graphics.VertexFloatCount*idx2+1]
sx2 := vertices[graphics.VertexFloatCount*idx2+2]
sy2 := vertices[graphics.VertexFloatCount*idx2+3]
if l := mipmapLevelFromDistance(dx0, dy0, dx1, dy1, sx0, sy0, sx1, sy1); level > l {
level = l
}
if l := mipmapLevelFromDistance(dx1, dy1, dx2, dy2, sx1, sy1, sx2, sy2); level > l {
level = l
}
if l := mipmapLevelFromDistance(dx2, dy2, dx0, dy0, sx2, sy2, sx0, sy0); level > l {
level = l
}
}
if level == math.MaxInt32 {
panic("mipmap: level must be calculated at least once but not")
}
var imgs [graphics.ShaderSrcImageCount]*buffered.Image
for i, src := range srcs {
if src == nil {
continue
}
if level != 0 {
if img := src.level(level); img != nil {
const n = graphics.VertexFloatCount
s := float32(pow2(level))
for i := 0; i < len(vertices)/n; i++ {
vertices[i*n+2] /= s
vertices[i*n+3] /= s
for i := 0; i < len(vertices); i += graphics.VertexFloatCount {
vertices[i+2] /= s
vertices[i+3] /= s
}
imgs[i] = img
continue
@@ -123,15 +147,18 @@ func (m *Mipmap) DrawTriangles(srcs [graphics.ShaderImageCount]*Mipmap, vertices
imgs[i] = src.orig
}
m.orig.DrawTriangles(imgs, vertices, indices, blend, dstRegion, srcRegions, shader, uniforms, fillRule)
m.deallocateMipmaps()
m.orig.DrawTriangles(imgs, vertices, indices, blend, dstRegion, srcRegions, shader, uniforms, fillRule, hint)
m.markDirty()
}
func (m *Mipmap) setImg(level int, img *buffered.Image) {
if m.imgs == nil {
m.imgs = map[int]*buffered.Image{}
m.imgs = map[int]imageWithDirtyFlag{}
}
m.imgs[level] = imageWithDirtyFlag{
img: img,
dirty: false,
}
m.imgs[level] = img
}
func (m *Mipmap) level(level int) *buffered.Image {
@@ -140,57 +167,66 @@ func (m *Mipmap) level(level int) *buffered.Image {
}
if !canUseMipmap(m.imageType) {
panic("mipmap: mipmap images for a volatile or a screen image is not implemented yet")
panic("mipmap: mipmap images for a screen image is not implemented yet")
}
if img, ok := m.imgs[level]; ok {
return img
img, ok := m.imgs[level]
if ok && !img.dirty {
return img.img
}
var srcW, srcH int
var src *buffered.Image
vs := make([]float32, 4*graphics.VertexFloatCount)
shader := atlas.NearestFilterShader
switch {
case level == 1:
src = m.orig
graphics.QuadVertices(vs, 0, 0, float32(m.width), float32(m.height), 0.5, 0, 0, 0.5, 0, 0, 1, 1, 1, 1)
shader = atlas.LinearFilterShader
srcW = m.width
srcH = m.height
case level > 1:
src = m.level(level - 1)
if src == nil {
m.setImg(level, nil)
return nil
}
w := sizeForLevel(m.width, level-1)
h := sizeForLevel(m.height, level-1)
graphics.QuadVertices(vs, 0, 0, float32(w), float32(h), 0.5, 0, 0, 0.5, 0, 0, 1, 1, 1, 1)
shader = atlas.LinearFilterShader
srcW = sizeForLevel(m.width, level-1)
srcH = sizeForLevel(m.height, level-1)
default:
panic(fmt.Sprintf("mipmap: invalid level: %d", level))
}
graphics.QuadVerticesFromSrcAndMatrix(vs, 0, 0, float32(srcW), float32(srcH), 0.5, 0, 0, 0.5, 0, 0, 1, 1, 1, 1)
is := graphics.QuadIndices()
w2 := sizeForLevel(m.width, level)
h2 := sizeForLevel(m.height, level)
if w2 == 0 || h2 == 0 {
dstW := sizeForLevel(m.width, level)
dstH := sizeForLevel(m.height, level)
if dstW == 0 || dstH == 0 {
m.setImg(level, nil)
return nil
}
// buffered.NewImage panics with a too big size when actual allocation happens.
// 4096 should be a safe size in most environments (#1399).
// Unfortunately a precise max image size cannot be obtained here since this requires GPU access.
if w2 > 4096 || h2 > 4096 {
if dstW > 4096 || dstH > 4096 {
m.setImg(level, nil)
return nil
}
s := buffered.NewImage(w2, h2, m.imageType)
var s *buffered.Image
if img.img != nil {
// As s is overwritten, this doesn't have to be cleared.
s = img.img
} else {
s = buffered.NewImage(dstW, dstH, m.imageType)
}
dstRegion := image.Rect(0, 0, w2, h2)
s.DrawTriangles([graphics.ShaderImageCount]*buffered.Image{src}, vs, is, graphicsdriver.BlendCopy, dstRegion, [graphics.ShaderImageCount]image.Rectangle{}, shader, nil, graphicsdriver.FillAll)
dstRegion := image.Rect(0, 0, dstW, dstH)
srcRegion := image.Rect(0, 0, srcW, srcH)
s.DrawTriangles([graphics.ShaderSrcImageCount]*buffered.Image{src}, vs, is, graphicsdriver.BlendCopy, dstRegion, [graphics.ShaderSrcImageCount]image.Rectangle{srcRegion}, atlas.LinearFilterShader, nil, graphicsdriver.FillRuleFillAll, restorable.HintOverwriteDstRegion)
m.setImg(level, s)
return m.imgs[level]
return m.imgs[level].img
}
func sizeForLevel(x int, level int) int {
@@ -204,19 +240,16 @@ func sizeForLevel(x int, level int) int {
}
func (m *Mipmap) Deallocate() {
m.deallocateMipmaps()
m.orig.Deallocate()
}
func (m *Mipmap) deallocateMipmaps() {
for _, img := range m.imgs {
if img != nil {
img.Deallocate()
if img.img == nil {
continue
}
img.img.Deallocate()
}
for k := range m.imgs {
delete(m.imgs, k)
}
m.orig.Deallocate()
}
// mipmapLevel returns an appropriate mipmap level for the given distance.