internal/driver: rename to internal/graphicsdriver

This commit is contained in:
Hajime Hoshi 2022-02-06 20:41:32 +09:00
parent 52f4c409ac
commit df60c4c92d
35 changed files with 390 additions and 390 deletions

View File

@ -348,17 +348,17 @@ package {{.Package}}
import ( import (
"fmt" "fmt"
"github.com/hajimehoshi/ebiten/v2/internal/driver" "github.com/hajimehoshi/ebiten/v2/internal/graphicsdriver"
) )
func convertCh(driverCh chan driver.Event) (chan Event) { func convertCh(driverCh chan graphicsdriver.Event) (chan Event) {
ch := make(chan Event) ch := make(chan Event)
go func() { go func() {
defer close(ch) defer close(ch)
for v := range driverCh { for v := range driverCh {
switch v := v.(type) { switch v := v.(type) {
{{range .Events}}case driver.{{.Name}}: {{range .Events}}case graphicsdriver.{{.Name}}:
ch <- {{.Name}}(v) ch <- {{.Name}}(v)
{{end}}default: {{end}}default:
panic(fmt.Sprintf("event: unknown event: %v", v)) panic(fmt.Sprintf("event: unknown event: %v", v))

View File

@ -15,7 +15,7 @@
package ebiten package ebiten
import ( import (
"github.com/hajimehoshi/ebiten/v2/internal/driver" "github.com/hajimehoshi/ebiten/v2/internal/graphicsdriver"
) )
// 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 maginified or minified.
@ -23,15 +23,15 @@ type Filter int
const ( const (
// FilterNearest represents nearest (crisp-edged) filter // FilterNearest represents nearest (crisp-edged) filter
FilterNearest Filter = Filter(driver.FilterNearest) FilterNearest Filter = Filter(graphicsdriver.FilterNearest)
// FilterLinear represents linear filter // FilterLinear represents linear filter
FilterLinear Filter = Filter(driver.FilterLinear) FilterLinear Filter = Filter(graphicsdriver.FilterLinear)
// filterScreen represents a special filter for screen. Inner usage only. // filterScreen represents a special filter for screen. Inner usage only.
// //
// Some parameters like a color matrix or color vertex values can be ignored when filterScreen is used. // Some parameters like a color matrix or color vertex values can be ignored when filterScreen is used.
filterScreen Filter = Filter(driver.FilterScreen) filterScreen Filter = Filter(graphicsdriver.FilterScreen)
) )
// CompositeMode represents Porter-Duff composition mode. // CompositeMode represents Porter-Duff composition mode.
@ -44,46 +44,46 @@ type CompositeMode int
const ( const (
// Regular alpha blending // Regular alpha blending
// c_out = c_src + c_dst × (1 - α_src) // c_out = c_src + c_dst × (1 - α_src)
CompositeModeSourceOver CompositeMode = CompositeMode(driver.CompositeModeSourceOver) CompositeModeSourceOver CompositeMode = CompositeMode(graphicsdriver.CompositeModeSourceOver)
// c_out = 0 // c_out = 0
CompositeModeClear CompositeMode = CompositeMode(driver.CompositeModeClear) CompositeModeClear CompositeMode = CompositeMode(graphicsdriver.CompositeModeClear)
// c_out = c_src // c_out = c_src
CompositeModeCopy CompositeMode = CompositeMode(driver.CompositeModeCopy) CompositeModeCopy CompositeMode = CompositeMode(graphicsdriver.CompositeModeCopy)
// c_out = c_dst // c_out = c_dst
CompositeModeDestination CompositeMode = CompositeMode(driver.CompositeModeDestination) CompositeModeDestination CompositeMode = CompositeMode(graphicsdriver.CompositeModeDestination)
// c_out = c_src × (1 - α_dst) + c_dst // c_out = c_src × (1 - α_dst) + c_dst
CompositeModeDestinationOver CompositeMode = CompositeMode(driver.CompositeModeDestinationOver) CompositeModeDestinationOver CompositeMode = CompositeMode(graphicsdriver.CompositeModeDestinationOver)
// c_out = c_src × α_dst // c_out = c_src × α_dst
CompositeModeSourceIn CompositeMode = CompositeMode(driver.CompositeModeSourceIn) CompositeModeSourceIn CompositeMode = CompositeMode(graphicsdriver.CompositeModeSourceIn)
// c_out = c_dst × α_src // c_out = c_dst × α_src
CompositeModeDestinationIn CompositeMode = CompositeMode(driver.CompositeModeDestinationIn) CompositeModeDestinationIn CompositeMode = CompositeMode(graphicsdriver.CompositeModeDestinationIn)
// c_out = c_src × (1 - α_dst) // c_out = c_src × (1 - α_dst)
CompositeModeSourceOut CompositeMode = CompositeMode(driver.CompositeModeSourceOut) CompositeModeSourceOut CompositeMode = CompositeMode(graphicsdriver.CompositeModeSourceOut)
// c_out = c_dst × (1 - α_src) // c_out = c_dst × (1 - α_src)
CompositeModeDestinationOut CompositeMode = CompositeMode(driver.CompositeModeDestinationOut) CompositeModeDestinationOut CompositeMode = CompositeMode(graphicsdriver.CompositeModeDestinationOut)
// c_out = c_src × α_dst + c_dst × (1 - α_src) // c_out = c_src × α_dst + c_dst × (1 - α_src)
CompositeModeSourceAtop CompositeMode = CompositeMode(driver.CompositeModeSourceAtop) CompositeModeSourceAtop CompositeMode = CompositeMode(graphicsdriver.CompositeModeSourceAtop)
// c_out = c_src × (1 - α_dst) + c_dst × α_src // c_out = c_src × (1 - α_dst) + c_dst × α_src
CompositeModeDestinationAtop CompositeMode = CompositeMode(driver.CompositeModeDestinationAtop) CompositeModeDestinationAtop CompositeMode = CompositeMode(graphicsdriver.CompositeModeDestinationAtop)
// c_out = c_src × (1 - α_dst) + c_dst × (1 - α_src) // c_out = c_src × (1 - α_dst) + c_dst × (1 - α_src)
CompositeModeXor CompositeMode = CompositeMode(driver.CompositeModeXor) CompositeModeXor CompositeMode = CompositeMode(graphicsdriver.CompositeModeXor)
// Sum of source and destination (a.k.a. 'plus' or 'additive') // Sum of source and destination (a.k.a. 'plus' or 'additive')
// c_out = c_src + c_dst // c_out = c_src + c_dst
CompositeModeLighter CompositeMode = CompositeMode(driver.CompositeModeLighter) CompositeModeLighter CompositeMode = CompositeMode(graphicsdriver.CompositeModeLighter)
// The product of source and destination (a.k.a 'multiply blend mode') // The product of source and destination (a.k.a 'multiply blend mode')
// c_out = c_src * c_dst // c_out = c_src * c_dst
CompositeModeMultiply CompositeMode = CompositeMode(driver.CompositeModeMultiply) CompositeModeMultiply CompositeMode = CompositeMode(graphicsdriver.CompositeModeMultiply)
) )

View File

@ -20,8 +20,8 @@ import (
"image/color" "image/color"
"github.com/hajimehoshi/ebiten/v2/internal/affine" "github.com/hajimehoshi/ebiten/v2/internal/affine"
"github.com/hajimehoshi/ebiten/v2/internal/driver"
"github.com/hajimehoshi/ebiten/v2/internal/graphics" "github.com/hajimehoshi/ebiten/v2/internal/graphics"
"github.com/hajimehoshi/ebiten/v2/internal/graphicsdriver"
"github.com/hajimehoshi/ebiten/v2/internal/mipmap" "github.com/hajimehoshi/ebiten/v2/internal/mipmap"
) )
@ -106,8 +106,8 @@ func (i *Image) Fill(clr color.Color) {
i.DrawImage(emptySubImage, op) i.DrawImage(emptySubImage, op)
} }
func canSkipMipmap(geom GeoM, filter driver.Filter) bool { func canSkipMipmap(geom GeoM, filter graphicsdriver.Filter) bool {
if filter != driver.FilterLinear { if filter != graphicsdriver.FilterLinear {
return true return true
} }
return geom.det2x2() >= 0.999 return geom.det2x2() >= 0.999
@ -178,7 +178,7 @@ func (i *Image) DrawImage(img *Image, options *DrawImageOptions) {
} }
dstBounds := i.Bounds() dstBounds := i.Bounds()
dstRegion := driver.Region{ dstRegion := graphicsdriver.Region{
X: float32(dstBounds.Min.X), X: float32(dstBounds.Min.X),
Y: float32(dstBounds.Min.Y), Y: float32(dstBounds.Min.Y),
Width: float32(dstBounds.Dx()), Width: float32(dstBounds.Dx()),
@ -192,8 +192,8 @@ func (i *Image) DrawImage(img *Image, options *DrawImageOptions) {
} }
bounds := img.Bounds() bounds := img.Bounds()
mode := driver.CompositeMode(options.CompositeMode) mode := graphicsdriver.CompositeMode(options.CompositeMode)
filter := driver.Filter(options.Filter) filter := graphicsdriver.Filter(options.Filter)
a, b, c, d, tx, ty := options.GeoM.elements32() a, b, c, d, tx, ty := options.GeoM.elements32()
@ -206,7 +206,7 @@ func (i *Image) DrawImage(img *Image, options *DrawImageOptions) {
srcs := [graphics.ShaderImageNum]*mipmap.Mipmap{img.mipmap} srcs := [graphics.ShaderImageNum]*mipmap.Mipmap{img.mipmap}
i.mipmap.DrawTriangles(srcs, vs, is, options.ColorM.affineColorM(), mode, filter, driver.AddressUnsafe, dstRegion, driver.Region{}, [graphics.ShaderImageNum - 1][2]float32{}, nil, nil, false, canSkipMipmap(options.GeoM, filter)) i.mipmap.DrawTriangles(srcs, vs, is, options.ColorM.affineColorM(), mode, filter, graphicsdriver.AddressUnsafe, dstRegion, graphicsdriver.Region{}, [graphics.ShaderImageNum - 1][2]float32{}, nil, nil, false, canSkipMipmap(options.GeoM, filter))
} }
// Vertex represents a vertex passed to DrawTriangles. // Vertex represents a vertex passed to DrawTriangles.
@ -235,13 +235,13 @@ type Address int
const ( const (
// AddressUnsafe means there is no guarantee when the texture coodinates are out of range. // AddressUnsafe means there is no guarantee when the texture coodinates are out of range.
AddressUnsafe Address = Address(driver.AddressUnsafe) AddressUnsafe Address = Address(graphicsdriver.AddressUnsafe)
// AddressClampToZero means that out-of-range texture coordinates return 0 (transparent). // AddressClampToZero means that out-of-range texture coordinates return 0 (transparent).
AddressClampToZero Address = Address(driver.AddressClampToZero) AddressClampToZero Address = Address(graphicsdriver.AddressClampToZero)
// AddressRepeat means that texture coordinates wrap to the other side of the texture. // AddressRepeat means that texture coordinates wrap to the other side of the texture.
AddressRepeat Address = Address(driver.AddressRepeat) AddressRepeat Address = Address(graphicsdriver.AddressRepeat)
) )
// FillRule is the rule whether an overlapped region is rendered with DrawTriangles(Shader). // FillRule is the rule whether an overlapped region is rendered with DrawTriangles(Shader).
@ -320,7 +320,7 @@ func (i *Image) DrawTriangles(vertices []Vertex, indices []uint16, img *Image, o
// TODO: Check the maximum value of indices and len(vertices)? // TODO: Check the maximum value of indices and len(vertices)?
dstBounds := i.Bounds() dstBounds := i.Bounds()
dstRegion := driver.Region{ dstRegion := graphicsdriver.Region{
X: float32(dstBounds.Min.X), X: float32(dstBounds.Min.X),
Y: float32(dstBounds.Min.Y), Y: float32(dstBounds.Min.Y),
Width: float32(dstBounds.Dx()), Width: float32(dstBounds.Dx()),
@ -331,13 +331,13 @@ func (i *Image) DrawTriangles(vertices []Vertex, indices []uint16, img *Image, o
options = &DrawTrianglesOptions{} options = &DrawTrianglesOptions{}
} }
mode := driver.CompositeMode(options.CompositeMode) mode := graphicsdriver.CompositeMode(options.CompositeMode)
address := driver.Address(options.Address) address := graphicsdriver.Address(options.Address)
var sr driver.Region var sr graphicsdriver.Region
if address != driver.AddressUnsafe { if address != graphicsdriver.AddressUnsafe {
b := img.Bounds() b := img.Bounds()
sr = driver.Region{ sr = graphicsdriver.Region{
X: float32(b.Min.X), X: float32(b.Min.X),
Y: float32(b.Min.Y), Y: float32(b.Min.Y),
Width: float32(b.Dx()), Width: float32(b.Dx()),
@ -345,7 +345,7 @@ func (i *Image) DrawTriangles(vertices []Vertex, indices []uint16, img *Image, o
} }
} }
filter := driver.Filter(options.Filter) filter := graphicsdriver.Filter(options.Filter)
vs := graphics.Vertices(len(vertices)) vs := graphics.Vertices(len(vertices))
for i, v := range vertices { for i, v := range vertices {
@ -432,7 +432,7 @@ func (i *Image) DrawTrianglesShader(vertices []Vertex, indices []uint16, shader
// TODO: Check the maximum value of indices and len(vertices)? // TODO: Check the maximum value of indices and len(vertices)?
dstBounds := i.Bounds() dstBounds := i.Bounds()
dstRegion := driver.Region{ dstRegion := graphicsdriver.Region{
X: float32(dstBounds.Min.X), X: float32(dstBounds.Min.X),
Y: float32(dstBounds.Min.Y), Y: float32(dstBounds.Min.Y),
Width: float32(dstBounds.Dx()), Width: float32(dstBounds.Dx()),
@ -443,7 +443,7 @@ func (i *Image) DrawTrianglesShader(vertices []Vertex, indices []uint16, shader
options = &DrawTrianglesShaderOptions{} options = &DrawTrianglesShaderOptions{}
} }
mode := driver.CompositeMode(options.CompositeMode) mode := graphicsdriver.CompositeMode(options.CompositeMode)
vs := graphics.Vertices(len(vertices)) vs := graphics.Vertices(len(vertices))
for i, v := range vertices { for i, v := range vertices {
@ -486,10 +486,10 @@ func (i *Image) DrawTrianglesShader(vertices []Vertex, indices []uint16, shader
sy = float32(b.Min.Y) sy = float32(b.Min.Y)
} }
var sr driver.Region var sr graphicsdriver.Region
if img := options.Images[0]; img != nil { if img := options.Images[0]; img != nil {
b := img.Bounds() b := img.Bounds()
sr = driver.Region{ sr = graphicsdriver.Region{
X: float32(b.Min.X), X: float32(b.Min.X),
Y: float32(b.Min.Y), Y: float32(b.Min.Y),
Width: float32(b.Dx()), Width: float32(b.Dx()),
@ -509,7 +509,7 @@ func (i *Image) DrawTrianglesShader(vertices []Vertex, indices []uint16, shader
us := shader.convertUniforms(options.Uniforms) us := shader.convertUniforms(options.Uniforms)
i.mipmap.DrawTriangles(imgs, vs, is, affine.ColorMIdentity{}, mode, driver.FilterNearest, driver.AddressUnsafe, dstRegion, sr, offsets, shader.shader, us, options.FillRule == EvenOdd, false) i.mipmap.DrawTriangles(imgs, vs, is, affine.ColorMIdentity{}, mode, graphicsdriver.FilterNearest, graphicsdriver.AddressUnsafe, dstRegion, sr, offsets, shader.shader, us, options.FillRule == EvenOdd, false)
} }
// DrawRectShaderOptions represents options for DrawRectShader. // DrawRectShaderOptions represents options for DrawRectShader.
@ -561,7 +561,7 @@ func (i *Image) DrawRectShader(width, height int, shader *Shader, options *DrawR
} }
dstBounds := i.Bounds() dstBounds := i.Bounds()
dstRegion := driver.Region{ dstRegion := graphicsdriver.Region{
X: float32(dstBounds.Min.X), X: float32(dstBounds.Min.X),
Y: float32(dstBounds.Min.Y), Y: float32(dstBounds.Min.Y),
Width: float32(dstBounds.Dx()), Width: float32(dstBounds.Dx()),
@ -572,7 +572,7 @@ func (i *Image) DrawRectShader(width, height int, shader *Shader, options *DrawR
options = &DrawRectShaderOptions{} options = &DrawRectShaderOptions{}
} }
mode := driver.CompositeMode(options.CompositeMode) mode := graphicsdriver.CompositeMode(options.CompositeMode)
var imgs [graphics.ShaderImageNum]*mipmap.Mipmap var imgs [graphics.ShaderImageNum]*mipmap.Mipmap
for i, img := range options.Images { for i, img := range options.Images {
@ -599,10 +599,10 @@ func (i *Image) DrawRectShader(width, height int, shader *Shader, options *DrawR
vs := graphics.QuadVertices(sx, sy, sx+float32(width), sy+float32(height), a, b, c, d, tx, ty, 1, 1, 1, 1) vs := graphics.QuadVertices(sx, sy, sx+float32(width), sy+float32(height), a, b, c, d, tx, ty, 1, 1, 1, 1)
is := graphics.QuadIndices() is := graphics.QuadIndices()
var sr driver.Region var sr graphicsdriver.Region
if img := options.Images[0]; img != nil { if img := options.Images[0]; img != nil {
b := img.Bounds() b := img.Bounds()
sr = driver.Region{ sr = graphicsdriver.Region{
X: float32(b.Min.X), X: float32(b.Min.X),
Y: float32(b.Min.Y), Y: float32(b.Min.Y),
Width: float32(b.Dx()), Width: float32(b.Dx()),
@ -621,7 +621,7 @@ func (i *Image) DrawRectShader(width, height int, shader *Shader, options *DrawR
} }
us := shader.convertUniforms(options.Uniforms) us := shader.convertUniforms(options.Uniforms)
i.mipmap.DrawTriangles(imgs, vs, is, affine.ColorMIdentity{}, mode, driver.FilterNearest, driver.AddressUnsafe, dstRegion, sr, offsets, shader.shader, us, false, canSkipMipmap(options.GeoM, driver.FilterNearest)) i.mipmap.DrawTriangles(imgs, vs, is, affine.ColorMIdentity{}, mode, graphicsdriver.FilterNearest, graphicsdriver.AddressUnsafe, dstRegion, sr, offsets, shader.shader, us, false, canSkipMipmap(options.GeoM, graphicsdriver.FilterNearest))
} }
// SubImage returns an image representing the portion of the image p visible through r. // SubImage returns an image representing the portion of the image p visible through r.

View File

@ -21,8 +21,8 @@ import (
"sync" "sync"
"github.com/hajimehoshi/ebiten/v2/internal/affine" "github.com/hajimehoshi/ebiten/v2/internal/affine"
"github.com/hajimehoshi/ebiten/v2/internal/driver"
"github.com/hajimehoshi/ebiten/v2/internal/graphics" "github.com/hajimehoshi/ebiten/v2/internal/graphics"
"github.com/hajimehoshi/ebiten/v2/internal/graphicsdriver"
"github.com/hajimehoshi/ebiten/v2/internal/hooks" "github.com/hajimehoshi/ebiten/v2/internal/hooks"
"github.com/hajimehoshi/ebiten/v2/internal/packing" "github.com/hajimehoshi/ebiten/v2/internal/packing"
"github.com/hajimehoshi/ebiten/v2/internal/restorable" "github.com/hajimehoshi/ebiten/v2/internal/restorable"
@ -299,13 +299,13 @@ func (i *Image) ensureIsolated() {
is := graphics.QuadIndices() is := graphics.QuadIndices()
srcs := [graphics.ShaderImageNum]*restorable.Image{i.backend.restorable} srcs := [graphics.ShaderImageNum]*restorable.Image{i.backend.restorable}
var offsets [graphics.ShaderImageNum - 1][2]float32 var offsets [graphics.ShaderImageNum - 1][2]float32
dstRegion := driver.Region{ dstRegion := graphicsdriver.Region{
X: paddingSize, X: paddingSize,
Y: paddingSize, Y: paddingSize,
Width: float32(w - 2*paddingSize), Width: float32(w - 2*paddingSize),
Height: float32(h - 2*paddingSize), Height: float32(h - 2*paddingSize),
} }
newImg.DrawTriangles(srcs, offsets, vs, is, affine.ColorMIdentity{}, driver.CompositeModeCopy, driver.FilterNearest, driver.AddressUnsafe, dstRegion, driver.Region{}, nil, nil, false) newImg.DrawTriangles(srcs, offsets, vs, is, affine.ColorMIdentity{}, graphicsdriver.CompositeModeCopy, graphicsdriver.FilterNearest, graphicsdriver.AddressUnsafe, dstRegion, graphicsdriver.Region{}, nil, nil, false)
i.dispose(false) i.dispose(false)
i.backend = &backend{ i.backend = &backend{
@ -355,13 +355,13 @@ func (i *Image) putOnAtlas() error {
w, h := float32(i.width), float32(i.height) w, h := float32(i.width), float32(i.height)
vs := graphics.QuadVertices(0, 0, w, h, 1, 0, 0, 1, 0, 0, 1, 1, 1, 1) vs := graphics.QuadVertices(0, 0, w, h, 1, 0, 0, 1, 0, 0, 1, 1, 1, 1)
is := graphics.QuadIndices() is := graphics.QuadIndices()
dr := driver.Region{ dr := graphicsdriver.Region{
X: 0, X: 0,
Y: 0, Y: 0,
Width: w, Width: w,
Height: h, Height: h,
} }
newI.drawTriangles([graphics.ShaderImageNum]*Image{i}, vs, is, affine.ColorMIdentity{}, driver.CompositeModeCopy, driver.FilterNearest, driver.AddressUnsafe, dr, driver.Region{}, [graphics.ShaderImageNum - 1][2]float32{}, nil, nil, false, true) newI.drawTriangles([graphics.ShaderImageNum]*Image{i}, vs, is, affine.ColorMIdentity{}, graphicsdriver.CompositeModeCopy, graphicsdriver.FilterNearest, graphicsdriver.AddressUnsafe, dr, graphicsdriver.Region{}, [graphics.ShaderImageNum - 1][2]float32{}, nil, nil, false, true)
} }
newI.moveTo(i) newI.moveTo(i)
@ -409,13 +409,13 @@ func (i *Image) processSrc(src *Image) {
// 5: Color G // 5: Color G
// 6: Color B // 6: Color B
// 7: Color Y // 7: Color Y
func (i *Image) DrawTriangles(srcs [graphics.ShaderImageNum]*Image, vertices []float32, indices []uint16, colorm affine.ColorM, mode driver.CompositeMode, filter driver.Filter, address driver.Address, dstRegion, srcRegion driver.Region, subimageOffsets [graphics.ShaderImageNum - 1][2]float32, shader *Shader, uniforms []driver.Uniform, evenOdd bool) { func (i *Image) DrawTriangles(srcs [graphics.ShaderImageNum]*Image, vertices []float32, indices []uint16, colorm affine.ColorM, mode graphicsdriver.CompositeMode, filter graphicsdriver.Filter, address graphicsdriver.Address, dstRegion, srcRegion graphicsdriver.Region, subimageOffsets [graphics.ShaderImageNum - 1][2]float32, shader *Shader, uniforms []graphicsdriver.Uniform, evenOdd bool) {
backendsM.Lock() backendsM.Lock()
defer backendsM.Unlock() defer backendsM.Unlock()
i.drawTriangles(srcs, vertices, indices, colorm, mode, filter, address, dstRegion, srcRegion, subimageOffsets, shader, uniforms, evenOdd, false) i.drawTriangles(srcs, vertices, indices, colorm, mode, filter, address, dstRegion, srcRegion, subimageOffsets, shader, uniforms, evenOdd, false)
} }
func (i *Image) drawTriangles(srcs [graphics.ShaderImageNum]*Image, vertices []float32, indices []uint16, colorm affine.ColorM, mode driver.CompositeMode, filter driver.Filter, address driver.Address, dstRegion, srcRegion driver.Region, subimageOffsets [graphics.ShaderImageNum - 1][2]float32, shader *Shader, uniforms []driver.Uniform, evenOdd bool, keepOnAtlas bool) { func (i *Image) drawTriangles(srcs [graphics.ShaderImageNum]*Image, vertices []float32, indices []uint16, colorm affine.ColorM, mode graphicsdriver.CompositeMode, filter graphicsdriver.Filter, address graphicsdriver.Address, dstRegion, srcRegion graphicsdriver.Region, subimageOffsets [graphics.ShaderImageNum - 1][2]float32, shader *Shader, uniforms []graphicsdriver.Uniform, evenOdd bool, keepOnAtlas bool) {
if i.disposed { if i.disposed {
panic("atlas: the drawing target image must not be disposed (DrawTriangles)") panic("atlas: the drawing target image must not be disposed (DrawTriangles)")
} }

View File

@ -21,8 +21,8 @@ import (
"github.com/hajimehoshi/ebiten/v2/internal/affine" "github.com/hajimehoshi/ebiten/v2/internal/affine"
"github.com/hajimehoshi/ebiten/v2/internal/atlas" "github.com/hajimehoshi/ebiten/v2/internal/atlas"
"github.com/hajimehoshi/ebiten/v2/internal/driver"
"github.com/hajimehoshi/ebiten/v2/internal/graphics" "github.com/hajimehoshi/ebiten/v2/internal/graphics"
"github.com/hajimehoshi/ebiten/v2/internal/graphicsdriver"
t "github.com/hajimehoshi/ebiten/v2/internal/testing" t "github.com/hajimehoshi/ebiten/v2/internal/testing"
) )
@ -97,13 +97,13 @@ func TestEnsureIsolated(t *testing.T) {
// img4.EnsureIsolated() should be called. // img4.EnsureIsolated() should be called.
vs := quadVertices(size/2, size/2, size/4, size/4, 1) vs := quadVertices(size/2, size/2, size/4, size/4, 1)
is := graphics.QuadIndices() is := graphics.QuadIndices()
dr := driver.Region{ dr := graphicsdriver.Region{
X: 0, X: 0,
Y: 0, Y: 0,
Width: size, Width: size,
Height: size, Height: size,
} }
img4.DrawTriangles([graphics.ShaderImageNum]*atlas.Image{img3}, vs, is, affine.ColorMIdentity{}, driver.CompositeModeCopy, driver.FilterNearest, driver.AddressUnsafe, dr, driver.Region{}, [graphics.ShaderImageNum - 1][2]float32{}, nil, nil, false) img4.DrawTriangles([graphics.ShaderImageNum]*atlas.Image{img3}, vs, is, affine.ColorMIdentity{}, graphicsdriver.CompositeModeCopy, graphicsdriver.FilterNearest, graphicsdriver.AddressUnsafe, dr, graphicsdriver.Region{}, [graphics.ShaderImageNum - 1][2]float32{}, nil, nil, false)
want := false want := false
if got := img4.IsOnAtlasForTesting(); got != want { if got := img4.IsOnAtlasForTesting(); got != want {
t.Errorf("got: %v, want: %v", got, want) t.Errorf("got: %v, want: %v", got, want)
@ -133,7 +133,7 @@ func TestEnsureIsolated(t *testing.T) {
// Check further drawing doesn't cause panic. // Check further drawing doesn't cause panic.
// This bug was fixed by 03dcd948. // This bug was fixed by 03dcd948.
img4.DrawTriangles([graphics.ShaderImageNum]*atlas.Image{img3}, vs, is, affine.ColorMIdentity{}, driver.CompositeModeCopy, driver.FilterNearest, driver.AddressUnsafe, dr, driver.Region{}, [graphics.ShaderImageNum - 1][2]float32{}, nil, nil, false) img4.DrawTriangles([graphics.ShaderImageNum]*atlas.Image{img3}, vs, is, affine.ColorMIdentity{}, graphicsdriver.CompositeModeCopy, graphicsdriver.FilterNearest, graphicsdriver.AddressUnsafe, dr, graphicsdriver.Region{}, [graphics.ShaderImageNum - 1][2]float32{}, nil, nil, false)
} }
func TestReputOnAtlas(t *testing.T) { func TestReputOnAtlas(t *testing.T) {
@ -174,13 +174,13 @@ func TestReputOnAtlas(t *testing.T) {
// Use img1 as a render target. // Use img1 as a render target.
vs := quadVertices(size, size, 0, 0, 1) vs := quadVertices(size, size, 0, 0, 1)
is := graphics.QuadIndices() is := graphics.QuadIndices()
dr := driver.Region{ dr := graphicsdriver.Region{
X: 0, X: 0,
Y: 0, Y: 0,
Width: size, Width: size,
Height: size, Height: size,
} }
img1.DrawTriangles([graphics.ShaderImageNum]*atlas.Image{img2}, vs, is, affine.ColorMIdentity{}, driver.CompositeModeCopy, driver.FilterNearest, driver.AddressUnsafe, dr, driver.Region{}, [graphics.ShaderImageNum - 1][2]float32{}, nil, nil, false) img1.DrawTriangles([graphics.ShaderImageNum]*atlas.Image{img2}, vs, is, affine.ColorMIdentity{}, graphicsdriver.CompositeModeCopy, graphicsdriver.FilterNearest, graphicsdriver.AddressUnsafe, dr, graphicsdriver.Region{}, [graphics.ShaderImageNum - 1][2]float32{}, nil, nil, false)
if got, want := img1.IsOnAtlasForTesting(), false; got != want { if got, want := img1.IsOnAtlasForTesting(), false; got != want {
t.Errorf("got: %v, want: %v", got, want) t.Errorf("got: %v, want: %v", got, want)
} }
@ -192,7 +192,7 @@ func TestReputOnAtlas(t *testing.T) {
if err := atlas.PutImagesOnAtlasForTesting(); err != nil { if err := atlas.PutImagesOnAtlasForTesting(); err != nil {
t.Fatal(err) t.Fatal(err)
} }
img0.DrawTriangles([graphics.ShaderImageNum]*atlas.Image{img1}, vs, is, affine.ColorMIdentity{}, driver.CompositeModeCopy, driver.FilterNearest, driver.AddressUnsafe, dr, driver.Region{}, [graphics.ShaderImageNum - 1][2]float32{}, nil, nil, false) img0.DrawTriangles([graphics.ShaderImageNum]*atlas.Image{img1}, vs, is, affine.ColorMIdentity{}, graphicsdriver.CompositeModeCopy, graphicsdriver.FilterNearest, graphicsdriver.AddressUnsafe, dr, graphicsdriver.Region{}, [graphics.ShaderImageNum - 1][2]float32{}, nil, nil, false)
if got, want := img1.IsOnAtlasForTesting(), false; got != want { if got, want := img1.IsOnAtlasForTesting(), false; got != want {
t.Errorf("got: %v, want: %v", got, want) t.Errorf("got: %v, want: %v", got, want)
} }
@ -220,7 +220,7 @@ func TestReputOnAtlas(t *testing.T) {
} }
// img1 is on an atlas again. // img1 is on an atlas again.
img0.DrawTriangles([graphics.ShaderImageNum]*atlas.Image{img1}, vs, is, affine.ColorMIdentity{}, driver.CompositeModeCopy, driver.FilterNearest, driver.AddressUnsafe, dr, driver.Region{}, [graphics.ShaderImageNum - 1][2]float32{}, nil, nil, false) img0.DrawTriangles([graphics.ShaderImageNum]*atlas.Image{img1}, vs, is, affine.ColorMIdentity{}, graphicsdriver.CompositeModeCopy, graphicsdriver.FilterNearest, graphicsdriver.AddressUnsafe, dr, graphicsdriver.Region{}, [graphics.ShaderImageNum - 1][2]float32{}, nil, nil, false)
if got, want := img1.IsOnAtlasForTesting(), true; got != want { if got, want := img1.IsOnAtlasForTesting(), true; got != want {
t.Errorf("got: %v, want: %v", got, want) t.Errorf("got: %v, want: %v", got, want)
} }
@ -244,7 +244,7 @@ func TestReputOnAtlas(t *testing.T) {
} }
// Use img1 as a render target again. // Use img1 as a render target again.
img1.DrawTriangles([graphics.ShaderImageNum]*atlas.Image{img2}, vs, is, affine.ColorMIdentity{}, driver.CompositeModeCopy, driver.FilterNearest, driver.AddressUnsafe, dr, driver.Region{}, [graphics.ShaderImageNum - 1][2]float32{}, nil, nil, false) img1.DrawTriangles([graphics.ShaderImageNum]*atlas.Image{img2}, vs, is, affine.ColorMIdentity{}, graphicsdriver.CompositeModeCopy, graphicsdriver.FilterNearest, graphicsdriver.AddressUnsafe, dr, graphicsdriver.Region{}, [graphics.ShaderImageNum - 1][2]float32{}, nil, nil, false)
if got, want := img1.IsOnAtlasForTesting(), false; got != want { if got, want := img1.IsOnAtlasForTesting(), false; got != want {
t.Errorf("got: %v, want: %v", got, want) t.Errorf("got: %v, want: %v", got, want)
} }
@ -256,7 +256,7 @@ func TestReputOnAtlas(t *testing.T) {
t.Fatal(err) t.Fatal(err)
} }
img1.ReplacePixels(make([]byte, 4*size*size)) img1.ReplacePixels(make([]byte, 4*size*size))
img0.DrawTriangles([graphics.ShaderImageNum]*atlas.Image{img1}, vs, is, affine.ColorMIdentity{}, driver.CompositeModeCopy, driver.FilterNearest, driver.AddressUnsafe, dr, driver.Region{}, [graphics.ShaderImageNum - 1][2]float32{}, nil, nil, false) img0.DrawTriangles([graphics.ShaderImageNum]*atlas.Image{img1}, vs, is, affine.ColorMIdentity{}, graphicsdriver.CompositeModeCopy, graphicsdriver.FilterNearest, graphicsdriver.AddressUnsafe, dr, graphicsdriver.Region{}, [graphics.ShaderImageNum - 1][2]float32{}, nil, nil, false)
if got, want := img1.IsOnAtlasForTesting(), false; got != want { if got, want := img1.IsOnAtlasForTesting(), false; got != want {
t.Errorf("got: %v, want: %v", got, want) t.Errorf("got: %v, want: %v", got, want)
} }
@ -266,7 +266,7 @@ func TestReputOnAtlas(t *testing.T) {
} }
// img1 is not on an atlas due to ReplacePixels. // img1 is not on an atlas due to ReplacePixels.
img0.DrawTriangles([graphics.ShaderImageNum]*atlas.Image{img1}, vs, is, affine.ColorMIdentity{}, driver.CompositeModeCopy, driver.FilterNearest, driver.AddressUnsafe, dr, driver.Region{}, [graphics.ShaderImageNum - 1][2]float32{}, nil, nil, false) img0.DrawTriangles([graphics.ShaderImageNum]*atlas.Image{img1}, vs, is, affine.ColorMIdentity{}, graphicsdriver.CompositeModeCopy, graphicsdriver.FilterNearest, graphicsdriver.AddressUnsafe, dr, graphicsdriver.Region{}, [graphics.ShaderImageNum - 1][2]float32{}, nil, nil, false)
if got, want := img1.IsOnAtlasForTesting(), false; got != want { if got, want := img1.IsOnAtlasForTesting(), false; got != want {
t.Errorf("got: %v, want: %v", got, want) t.Errorf("got: %v, want: %v", got, want)
} }
@ -276,7 +276,7 @@ func TestReputOnAtlas(t *testing.T) {
if err := atlas.PutImagesOnAtlasForTesting(); err != nil { if err := atlas.PutImagesOnAtlasForTesting(); err != nil {
t.Fatal(err) t.Fatal(err)
} }
img0.DrawTriangles([graphics.ShaderImageNum]*atlas.Image{img3}, vs, is, affine.ColorMIdentity{}, driver.CompositeModeCopy, driver.FilterNearest, driver.AddressUnsafe, dr, driver.Region{}, [graphics.ShaderImageNum - 1][2]float32{}, nil, nil, false) img0.DrawTriangles([graphics.ShaderImageNum]*atlas.Image{img3}, vs, is, affine.ColorMIdentity{}, graphicsdriver.CompositeModeCopy, graphicsdriver.FilterNearest, graphicsdriver.AddressUnsafe, dr, graphicsdriver.Region{}, [graphics.ShaderImageNum - 1][2]float32{}, nil, nil, false)
if got, want := img3.IsOnAtlasForTesting(), false; got != want { if got, want := img3.IsOnAtlasForTesting(), false; got != want {
t.Errorf("got: %v, want: %v", got, want) t.Errorf("got: %v, want: %v", got, want)
} }
@ -370,13 +370,13 @@ func TestReplacePixelsAfterDrawTriangles(t *testing.T) {
vs := quadVertices(w, h, 0, 0, 1) vs := quadVertices(w, h, 0, 0, 1)
is := graphics.QuadIndices() is := graphics.QuadIndices()
dr := driver.Region{ dr := graphicsdriver.Region{
X: 0, X: 0,
Y: 0, Y: 0,
Width: w, Width: w,
Height: h, Height: h,
} }
dst.DrawTriangles([graphics.ShaderImageNum]*atlas.Image{src}, vs, is, affine.ColorMIdentity{}, driver.CompositeModeCopy, driver.FilterNearest, driver.AddressUnsafe, dr, driver.Region{}, [graphics.ShaderImageNum - 1][2]float32{}, nil, nil, false) dst.DrawTriangles([graphics.ShaderImageNum]*atlas.Image{src}, vs, is, affine.ColorMIdentity{}, graphicsdriver.CompositeModeCopy, graphicsdriver.FilterNearest, graphicsdriver.AddressUnsafe, dr, graphicsdriver.Region{}, [graphics.ShaderImageNum - 1][2]float32{}, nil, nil, false)
dst.ReplacePixels(pix) dst.ReplacePixels(pix)
pix, err := dst.Pixels(0, 0, w, h) pix, err := dst.Pixels(0, 0, w, h)
@ -418,13 +418,13 @@ func TestSmallImages(t *testing.T) {
vs := quadVertices(w, h, 0, 0, 1) vs := quadVertices(w, h, 0, 0, 1)
is := graphics.QuadIndices() is := graphics.QuadIndices()
dr := driver.Region{ dr := graphicsdriver.Region{
X: 0, X: 0,
Y: 0, Y: 0,
Width: w, Width: w,
Height: h, Height: h,
} }
dst.DrawTriangles([graphics.ShaderImageNum]*atlas.Image{src}, vs, is, affine.ColorMIdentity{}, driver.CompositeModeSourceOver, driver.FilterNearest, driver.AddressUnsafe, dr, driver.Region{}, [graphics.ShaderImageNum - 1][2]float32{}, nil, nil, false) dst.DrawTriangles([graphics.ShaderImageNum]*atlas.Image{src}, vs, is, affine.ColorMIdentity{}, graphicsdriver.CompositeModeSourceOver, graphicsdriver.FilterNearest, graphicsdriver.AddressUnsafe, dr, graphicsdriver.Region{}, [graphics.ShaderImageNum - 1][2]float32{}, nil, nil, false)
pix, err := dst.Pixels(0, 0, w, h) pix, err := dst.Pixels(0, 0, w, h)
if err != nil { if err != nil {
@ -466,13 +466,13 @@ func TestLongImages(t *testing.T) {
const scale = 120 const scale = 120
vs := quadVertices(w, h, 0, 0, scale) vs := quadVertices(w, h, 0, 0, scale)
is := graphics.QuadIndices() is := graphics.QuadIndices()
dr := driver.Region{ dr := graphicsdriver.Region{
X: 0, X: 0,
Y: 0, Y: 0,
Width: dstW, Width: dstW,
Height: dstH, Height: dstH,
} }
dst.DrawTriangles([graphics.ShaderImageNum]*atlas.Image{src}, vs, is, affine.ColorMIdentity{}, driver.CompositeModeSourceOver, driver.FilterNearest, driver.AddressUnsafe, dr, driver.Region{}, [graphics.ShaderImageNum - 1][2]float32{}, nil, nil, false) dst.DrawTriangles([graphics.ShaderImageNum]*atlas.Image{src}, vs, is, affine.ColorMIdentity{}, graphicsdriver.CompositeModeSourceOver, graphicsdriver.FilterNearest, graphicsdriver.AddressUnsafe, dr, graphicsdriver.Region{}, [graphics.ShaderImageNum - 1][2]float32{}, nil, nil, false)
pix, err := dst.Pixels(0, 0, dstW, dstH) pix, err := dst.Pixels(0, 0, dstW, dstH)
if err != nil { if err != nil {
@ -555,13 +555,13 @@ func TestDisposedAndReputOnAtlas(t *testing.T) {
// Use src as a render target so that src is not on an atlas. // Use src as a render target so that src is not on an atlas.
vs := quadVertices(size, size, 0, 0, 1) vs := quadVertices(size, size, 0, 0, 1)
is := graphics.QuadIndices() is := graphics.QuadIndices()
dr := driver.Region{ dr := graphicsdriver.Region{
X: 0, X: 0,
Y: 0, Y: 0,
Width: size, Width: size,
Height: size, Height: size,
} }
src.DrawTriangles([graphics.ShaderImageNum]*atlas.Image{src2}, vs, is, affine.ColorMIdentity{}, driver.CompositeModeCopy, driver.FilterNearest, driver.AddressUnsafe, dr, driver.Region{}, [graphics.ShaderImageNum - 1][2]float32{}, nil, nil, false) src.DrawTriangles([graphics.ShaderImageNum]*atlas.Image{src2}, vs, is, affine.ColorMIdentity{}, graphicsdriver.CompositeModeCopy, graphicsdriver.FilterNearest, graphicsdriver.AddressUnsafe, dr, graphicsdriver.Region{}, [graphics.ShaderImageNum - 1][2]float32{}, nil, nil, false)
if got, want := src.IsOnAtlasForTesting(), false; got != want { if got, want := src.IsOnAtlasForTesting(), false; got != want {
t.Errorf("got: %v, want: %v", got, want) t.Errorf("got: %v, want: %v", got, want)
} }
@ -571,7 +571,7 @@ func TestDisposedAndReputOnAtlas(t *testing.T) {
if err := atlas.PutImagesOnAtlasForTesting(); err != nil { if err := atlas.PutImagesOnAtlasForTesting(); err != nil {
t.Fatal(err) t.Fatal(err)
} }
dst.DrawTriangles([graphics.ShaderImageNum]*atlas.Image{src}, vs, is, affine.ColorMIdentity{}, driver.CompositeModeCopy, driver.FilterNearest, driver.AddressUnsafe, dr, driver.Region{}, [graphics.ShaderImageNum - 1][2]float32{}, nil, nil, false) dst.DrawTriangles([graphics.ShaderImageNum]*atlas.Image{src}, vs, is, affine.ColorMIdentity{}, graphicsdriver.CompositeModeCopy, graphicsdriver.FilterNearest, graphicsdriver.AddressUnsafe, dr, graphicsdriver.Region{}, [graphics.ShaderImageNum - 1][2]float32{}, nil, nil, false)
if got, want := src.IsOnAtlasForTesting(), false; got != want { if got, want := src.IsOnAtlasForTesting(), false; got != want {
t.Errorf("got: %v, want: %v", got, want) t.Errorf("got: %v, want: %v", got, want)
} }
@ -603,7 +603,7 @@ func TestImageIsNotReputOnAtlasWithoutUsingAsSource(t *testing.T) {
// Use src as a render target so that src is not on an atlas. // Use src as a render target so that src is not on an atlas.
vs := quadVertices(size, size, 0, 0, 1) vs := quadVertices(size, size, 0, 0, 1)
is := graphics.QuadIndices() is := graphics.QuadIndices()
dr := driver.Region{ dr := graphicsdriver.Region{
X: 0, X: 0,
Y: 0, Y: 0,
Width: size, Width: size,
@ -611,7 +611,7 @@ func TestImageIsNotReputOnAtlasWithoutUsingAsSource(t *testing.T) {
} }
// Use src2 as a rendering target, and make src2 an independent image. // Use src2 as a rendering target, and make src2 an independent image.
src2.DrawTriangles([graphics.ShaderImageNum]*atlas.Image{src}, vs, is, affine.ColorMIdentity{}, driver.CompositeModeCopy, driver.FilterNearest, driver.AddressUnsafe, dr, driver.Region{}, [graphics.ShaderImageNum - 1][2]float32{}, nil, nil, false) src2.DrawTriangles([graphics.ShaderImageNum]*atlas.Image{src}, vs, is, affine.ColorMIdentity{}, graphicsdriver.CompositeModeCopy, graphicsdriver.FilterNearest, graphicsdriver.AddressUnsafe, dr, graphicsdriver.Region{}, [graphics.ShaderImageNum - 1][2]float32{}, nil, nil, false)
if got, want := src2.IsOnAtlasForTesting(), false; got != want { if got, want := src2.IsOnAtlasForTesting(), false; got != want {
t.Errorf("got: %v, want: %v", got, want) t.Errorf("got: %v, want: %v", got, want)
} }
@ -632,7 +632,7 @@ func TestImageIsNotReputOnAtlasWithoutUsingAsSource(t *testing.T) {
if err := atlas.PutImagesOnAtlasForTesting(); err != nil { if err := atlas.PutImagesOnAtlasForTesting(); err != nil {
t.Fatal(err) t.Fatal(err)
} }
dst.DrawTriangles([graphics.ShaderImageNum]*atlas.Image{src2}, vs, is, affine.ColorMIdentity{}, driver.CompositeModeCopy, driver.FilterNearest, driver.AddressUnsafe, dr, driver.Region{}, [graphics.ShaderImageNum - 1][2]float32{}, nil, nil, false) dst.DrawTriangles([graphics.ShaderImageNum]*atlas.Image{src2}, vs, is, affine.ColorMIdentity{}, graphicsdriver.CompositeModeCopy, graphicsdriver.FilterNearest, graphicsdriver.AddressUnsafe, dr, graphicsdriver.Region{}, [graphics.ShaderImageNum - 1][2]float32{}, nil, nil, false)
if got, want := src2.IsOnAtlasForTesting(), false; got != want { if got, want := src2.IsOnAtlasForTesting(), false; got != want {
t.Errorf("got: %v, want: %v", got, want) t.Errorf("got: %v, want: %v", got, want)
} }

View File

@ -20,8 +20,8 @@ import (
"github.com/hajimehoshi/ebiten/v2/internal/affine" "github.com/hajimehoshi/ebiten/v2/internal/affine"
"github.com/hajimehoshi/ebiten/v2/internal/atlas" "github.com/hajimehoshi/ebiten/v2/internal/atlas"
"github.com/hajimehoshi/ebiten/v2/internal/driver"
"github.com/hajimehoshi/ebiten/v2/internal/graphics" "github.com/hajimehoshi/ebiten/v2/internal/graphics"
"github.com/hajimehoshi/ebiten/v2/internal/graphicsdriver"
etesting "github.com/hajimehoshi/ebiten/v2/internal/testing" etesting "github.com/hajimehoshi/ebiten/v2/internal/testing"
) )
@ -32,7 +32,7 @@ func TestShaderFillTwice(t *testing.T) {
vs := quadVertices(w, h, 0, 0, 1) vs := quadVertices(w, h, 0, 0, 1)
is := graphics.QuadIndices() is := graphics.QuadIndices()
dr := driver.Region{ dr := graphicsdriver.Region{
X: 0, X: 0,
Y: 0, Y: 0,
Width: w, Width: w,
@ -40,13 +40,13 @@ func TestShaderFillTwice(t *testing.T) {
} }
p0 := etesting.ShaderProgramFill(0xff, 0xff, 0xff, 0xff) p0 := etesting.ShaderProgramFill(0xff, 0xff, 0xff, 0xff)
s0 := atlas.NewShader(&p0) s0 := atlas.NewShader(&p0)
dst.DrawTriangles([graphics.ShaderImageNum]*atlas.Image{}, vs, is, affine.ColorMIdentity{}, driver.CompositeModeCopy, driver.FilterNearest, driver.AddressUnsafe, dr, driver.Region{}, [graphics.ShaderImageNum - 1][2]float32{}, s0, nil, false) dst.DrawTriangles([graphics.ShaderImageNum]*atlas.Image{}, vs, is, affine.ColorMIdentity{}, graphicsdriver.CompositeModeCopy, graphicsdriver.FilterNearest, graphicsdriver.AddressUnsafe, dr, graphicsdriver.Region{}, [graphics.ShaderImageNum - 1][2]float32{}, s0, nil, false)
// Vertices must be recreated (#1755) // Vertices must be recreated (#1755)
vs = quadVertices(w, h, 0, 0, 1) vs = quadVertices(w, h, 0, 0, 1)
p1 := etesting.ShaderProgramFill(0x80, 0x80, 0x80, 0xff) p1 := etesting.ShaderProgramFill(0x80, 0x80, 0x80, 0xff)
s1 := atlas.NewShader(&p1) s1 := atlas.NewShader(&p1)
dst.DrawTriangles([graphics.ShaderImageNum]*atlas.Image{}, vs, is, affine.ColorMIdentity{}, driver.CompositeModeCopy, driver.FilterNearest, driver.AddressUnsafe, dr, driver.Region{}, [graphics.ShaderImageNum - 1][2]float32{}, s1, nil, false) dst.DrawTriangles([graphics.ShaderImageNum]*atlas.Image{}, vs, is, affine.ColorMIdentity{}, graphicsdriver.CompositeModeCopy, graphicsdriver.FilterNearest, graphicsdriver.AddressUnsafe, dr, graphicsdriver.Region{}, [graphics.ShaderImageNum - 1][2]float32{}, s1, nil, false)
pix, err := dst.Pixels(0, 0, w, h) pix, err := dst.Pixels(0, 0, w, h)
if err != nil { if err != nil {
@ -68,17 +68,17 @@ func TestImageDrawTwice(t *testing.T) {
vs := quadVertices(w, h, 0, 0, 1) vs := quadVertices(w, h, 0, 0, 1)
is := graphics.QuadIndices() is := graphics.QuadIndices()
dr := driver.Region{ dr := graphicsdriver.Region{
X: 0, X: 0,
Y: 0, Y: 0,
Width: w, Width: w,
Height: h, Height: h,
} }
dst.DrawTriangles([graphics.ShaderImageNum]*atlas.Image{src0}, vs, is, affine.ColorMIdentity{}, driver.CompositeModeCopy, driver.FilterNearest, driver.AddressUnsafe, dr, driver.Region{}, [graphics.ShaderImageNum - 1][2]float32{}, nil, nil, false) dst.DrawTriangles([graphics.ShaderImageNum]*atlas.Image{src0}, vs, is, affine.ColorMIdentity{}, graphicsdriver.CompositeModeCopy, graphicsdriver.FilterNearest, graphicsdriver.AddressUnsafe, dr, graphicsdriver.Region{}, [graphics.ShaderImageNum - 1][2]float32{}, nil, nil, false)
// Vertices must be recreated (#1755) // Vertices must be recreated (#1755)
vs = quadVertices(w, h, 0, 0, 1) vs = quadVertices(w, h, 0, 0, 1)
dst.DrawTriangles([graphics.ShaderImageNum]*atlas.Image{src1}, vs, is, affine.ColorMIdentity{}, driver.CompositeModeCopy, driver.FilterNearest, driver.AddressUnsafe, dr, driver.Region{}, [graphics.ShaderImageNum - 1][2]float32{}, nil, nil, false) dst.DrawTriangles([graphics.ShaderImageNum]*atlas.Image{src1}, vs, is, affine.ColorMIdentity{}, graphicsdriver.CompositeModeCopy, graphicsdriver.FilterNearest, graphicsdriver.AddressUnsafe, dr, graphicsdriver.Region{}, [graphics.ShaderImageNum - 1][2]float32{}, nil, nil, false)
pix, err := dst.Pixels(0, 0, w, h) pix, err := dst.Pixels(0, 0, w, h)
if err != nil { if err != nil {

View File

@ -20,8 +20,8 @@ import (
"github.com/hajimehoshi/ebiten/v2/internal/affine" "github.com/hajimehoshi/ebiten/v2/internal/affine"
"github.com/hajimehoshi/ebiten/v2/internal/atlas" "github.com/hajimehoshi/ebiten/v2/internal/atlas"
"github.com/hajimehoshi/ebiten/v2/internal/driver"
"github.com/hajimehoshi/ebiten/v2/internal/graphics" "github.com/hajimehoshi/ebiten/v2/internal/graphics"
"github.com/hajimehoshi/ebiten/v2/internal/graphicsdriver"
"github.com/hajimehoshi/ebiten/v2/internal/shaderir" "github.com/hajimehoshi/ebiten/v2/internal/shaderir"
) )
@ -214,7 +214,7 @@ func (i *Image) replacePendingPixels(pix []byte, x, y, width, height int) {
// DrawTriangles draws the src image with the given vertices. // DrawTriangles draws the src image with the given vertices.
// //
// Copying vertices and indices is the caller's responsibility. // Copying vertices and indices is the caller's responsibility.
func (i *Image) DrawTriangles(srcs [graphics.ShaderImageNum]*Image, vertices []float32, indices []uint16, colorm affine.ColorM, mode driver.CompositeMode, filter driver.Filter, address driver.Address, dstRegion, srcRegion driver.Region, subimageOffsets [graphics.ShaderImageNum - 1][2]float32, shader *Shader, uniforms []driver.Uniform, evenOdd bool) { func (i *Image) DrawTriangles(srcs [graphics.ShaderImageNum]*Image, vertices []float32, indices []uint16, colorm affine.ColorM, mode graphicsdriver.CompositeMode, filter graphicsdriver.Filter, address graphicsdriver.Address, dstRegion, srcRegion graphicsdriver.Region, subimageOffsets [graphics.ShaderImageNum - 1][2]float32, shader *Shader, uniforms []graphicsdriver.Uniform, evenOdd bool) {
for _, src := range srcs { for _, src := range srcs {
if i == src { if i == src {
panic("buffered: Image.DrawTriangles: source images must be different from the receiver") panic("buffered: Image.DrawTriangles: source images must be different from the receiver")

View File

@ -21,14 +21,14 @@ import (
"github.com/hajimehoshi/ebiten/v2/internal/affine" "github.com/hajimehoshi/ebiten/v2/internal/affine"
"github.com/hajimehoshi/ebiten/v2/internal/debug" "github.com/hajimehoshi/ebiten/v2/internal/debug"
"github.com/hajimehoshi/ebiten/v2/internal/driver"
"github.com/hajimehoshi/ebiten/v2/internal/graphics" "github.com/hajimehoshi/ebiten/v2/internal/graphics"
"github.com/hajimehoshi/ebiten/v2/internal/graphicsdriver"
"github.com/hajimehoshi/ebiten/v2/internal/shaderir" "github.com/hajimehoshi/ebiten/v2/internal/shaderir"
) )
var theGraphicsDriver driver.Graphics var theGraphicsDriver graphicsdriver.Graphics
func SetGraphicsDriver(driver driver.Graphics) { func SetGraphicsDriver(driver graphicsdriver.Graphics) {
theGraphicsDriver = driver theGraphicsDriver = driver
} }
@ -150,7 +150,7 @@ func mustUseDifferentVertexBuffer(nextNumVertexFloats, nextNumIndices int) bool
} }
// EnqueueDrawTrianglesCommand enqueues a drawing-image command. // EnqueueDrawTrianglesCommand enqueues a drawing-image command.
func (q *commandQueue) EnqueueDrawTrianglesCommand(dst *Image, srcs [graphics.ShaderImageNum]*Image, offsets [graphics.ShaderImageNum - 1][2]float32, vertices []float32, indices []uint16, color affine.ColorM, mode driver.CompositeMode, filter driver.Filter, address driver.Address, dstRegion, srcRegion driver.Region, shader *Shader, uniforms []driver.Uniform, evenOdd bool) { func (q *commandQueue) EnqueueDrawTrianglesCommand(dst *Image, srcs [graphics.ShaderImageNum]*Image, offsets [graphics.ShaderImageNum - 1][2]float32, vertices []float32, indices []uint16, color affine.ColorM, mode graphicsdriver.CompositeMode, filter graphicsdriver.Filter, address graphicsdriver.Address, dstRegion, srcRegion graphicsdriver.Region, shader *Shader, uniforms []graphicsdriver.Uniform, evenOdd bool) {
if len(indices) > graphics.IndicesNum { if len(indices) > graphics.IndicesNum {
panic(fmt.Sprintf("graphicscommand: len(indices) must be <= graphics.IndicesNum but not at EnqueueDrawTrianglesCommand: len(indices): %d, graphics.IndicesNum: %d", len(indices), graphics.IndicesNum)) panic(fmt.Sprintf("graphicscommand: len(indices) must be <= graphics.IndicesNum but not at EnqueueDrawTrianglesCommand: len(indices): %d, graphics.IndicesNum: %d", len(indices), graphics.IndicesNum))
} }
@ -363,46 +363,46 @@ type drawTrianglesCommand struct {
vertices []float32 vertices []float32
nindices int nindices int
color affine.ColorM color affine.ColorM
mode driver.CompositeMode mode graphicsdriver.CompositeMode
filter driver.Filter filter graphicsdriver.Filter
address driver.Address address graphicsdriver.Address
dstRegion driver.Region dstRegion graphicsdriver.Region
srcRegion driver.Region srcRegion graphicsdriver.Region
shader *Shader shader *Shader
uniforms []driver.Uniform uniforms []graphicsdriver.Uniform
evenOdd bool evenOdd bool
} }
func (c *drawTrianglesCommand) String() string { func (c *drawTrianglesCommand) String() string {
mode := "" mode := ""
switch c.mode { switch c.mode {
case driver.CompositeModeSourceOver: case graphicsdriver.CompositeModeSourceOver:
mode = "source-over" mode = "source-over"
case driver.CompositeModeClear: case graphicsdriver.CompositeModeClear:
mode = "clear" mode = "clear"
case driver.CompositeModeCopy: case graphicsdriver.CompositeModeCopy:
mode = "copy" mode = "copy"
case driver.CompositeModeDestination: case graphicsdriver.CompositeModeDestination:
mode = "destination" mode = "destination"
case driver.CompositeModeDestinationOver: case graphicsdriver.CompositeModeDestinationOver:
mode = "destination-over" mode = "destination-over"
case driver.CompositeModeSourceIn: case graphicsdriver.CompositeModeSourceIn:
mode = "source-in" mode = "source-in"
case driver.CompositeModeDestinationIn: case graphicsdriver.CompositeModeDestinationIn:
mode = "destination-in" mode = "destination-in"
case driver.CompositeModeSourceOut: case graphicsdriver.CompositeModeSourceOut:
mode = "source-out" mode = "source-out"
case driver.CompositeModeDestinationOut: case graphicsdriver.CompositeModeDestinationOut:
mode = "destination-out" mode = "destination-out"
case driver.CompositeModeSourceAtop: case graphicsdriver.CompositeModeSourceAtop:
mode = "source-atop" mode = "source-atop"
case driver.CompositeModeDestinationAtop: case graphicsdriver.CompositeModeDestinationAtop:
mode = "destination-atop" mode = "destination-atop"
case driver.CompositeModeXor: case graphicsdriver.CompositeModeXor:
mode = "xor" mode = "xor"
case driver.CompositeModeLighter: case graphicsdriver.CompositeModeLighter:
mode = "lighter" mode = "lighter"
case driver.CompositeModeMultiply: case graphicsdriver.CompositeModeMultiply:
mode = "multiply" mode = "multiply"
default: default:
panic(fmt.Sprintf("graphicscommand: invalid composite mode: %d", c.mode)) panic(fmt.Sprintf("graphicscommand: invalid composite mode: %d", c.mode))
@ -419,11 +419,11 @@ func (c *drawTrianglesCommand) String() string {
filter := "" filter := ""
switch c.filter { switch c.filter {
case driver.FilterNearest: case graphicsdriver.FilterNearest:
filter = "nearest" filter = "nearest"
case driver.FilterLinear: case graphicsdriver.FilterLinear:
filter = "linear" filter = "linear"
case driver.FilterScreen: case graphicsdriver.FilterScreen:
filter = "screen" filter = "screen"
default: default:
panic(fmt.Sprintf("graphicscommand: invalid filter: %d", c.filter)) panic(fmt.Sprintf("graphicscommand: invalid filter: %d", c.filter))
@ -431,11 +431,11 @@ func (c *drawTrianglesCommand) String() string {
address := "" address := ""
switch c.address { switch c.address {
case driver.AddressClampToZero: case graphicsdriver.AddressClampToZero:
address = "clamp_to_zero" address = "clamp_to_zero"
case driver.AddressRepeat: case graphicsdriver.AddressRepeat:
address = "repeat" address = "repeat"
case driver.AddressUnsafe: case graphicsdriver.AddressUnsafe:
address = "unsafe" address = "unsafe"
default: default:
panic(fmt.Sprintf("graphicscommand: invalid address: %d", c.address)) panic(fmt.Sprintf("graphicscommand: invalid address: %d", c.address))
@ -465,13 +465,13 @@ func (c *drawTrianglesCommand) Exec(indexOffset int) error {
return nil return nil
} }
var shaderID driver.ShaderID = driver.InvalidShaderID var shaderID graphicsdriver.ShaderID = graphicsdriver.InvalidShaderID
var imgs [graphics.ShaderImageNum]driver.ImageID var imgs [graphics.ShaderImageNum]graphicsdriver.ImageID
if c.shader != nil { if c.shader != nil {
shaderID = c.shader.shader.ID() shaderID = c.shader.shader.ID()
for i, src := range c.srcs { for i, src := range c.srcs {
if src == nil { if src == nil {
imgs[i] = driver.InvalidImageID imgs[i] = graphicsdriver.InvalidImageID
continue continue
} }
imgs[i] = src.image.ID() imgs[i] = src.image.ID()
@ -501,7 +501,7 @@ func (c *drawTrianglesCommand) addNumIndices(n int) {
// CanMergeWithDrawTrianglesCommand returns a boolean value indicating whether the other drawTrianglesCommand can be merged // CanMergeWithDrawTrianglesCommand returns a boolean value indicating whether the other drawTrianglesCommand can be merged
// with the drawTrianglesCommand c. // with the drawTrianglesCommand c.
func (c *drawTrianglesCommand) CanMergeWithDrawTrianglesCommand(dst *Image, srcs [graphics.ShaderImageNum]*Image, vertices []float32, color affine.ColorM, mode driver.CompositeMode, filter driver.Filter, address driver.Address, dstRegion, srcRegion driver.Region, shader *Shader, evenOdd bool) bool { func (c *drawTrianglesCommand) CanMergeWithDrawTrianglesCommand(dst *Image, srcs [graphics.ShaderImageNum]*Image, vertices []float32, color affine.ColorM, mode graphicsdriver.CompositeMode, filter graphicsdriver.Filter, address graphicsdriver.Address, dstRegion, srcRegion graphicsdriver.Region, shader *Shader, evenOdd bool) bool {
// If a shader is used, commands are not merged. // If a shader is used, commands are not merged.
// //
// TODO: Merge shader commands considering uniform variables. // TODO: Merge shader commands considering uniform variables.
@ -581,7 +581,7 @@ func mightOverlapDstRegions(vertices1, vertices2 []float32) bool {
// replacePixelsCommand represents a command to replace pixels of an image. // replacePixelsCommand represents a command to replace pixels of an image.
type replacePixelsCommand struct { type replacePixelsCommand struct {
dst *Image dst *Image
args []*driver.ReplacePixelsArgs args []*graphicsdriver.ReplacePixelsArgs
} }
func (c *replacePixelsCommand) String() string { func (c *replacePixelsCommand) String() string {

View File

@ -23,14 +23,14 @@ import (
"github.com/hajimehoshi/ebiten/v2/internal/affine" "github.com/hajimehoshi/ebiten/v2/internal/affine"
"github.com/hajimehoshi/ebiten/v2/internal/debug" "github.com/hajimehoshi/ebiten/v2/internal/debug"
"github.com/hajimehoshi/ebiten/v2/internal/driver"
"github.com/hajimehoshi/ebiten/v2/internal/graphics" "github.com/hajimehoshi/ebiten/v2/internal/graphics"
"github.com/hajimehoshi/ebiten/v2/internal/graphicsdriver"
"github.com/hajimehoshi/ebiten/v2/internal/png" "github.com/hajimehoshi/ebiten/v2/internal/png"
) )
// Image represents an image that is implemented with OpenGL. // Image represents an image that is implemented with OpenGL.
type Image struct { type Image struct {
image driver.Image image graphicsdriver.Image
width int width int
height int height int
internalWidth int internalWidth int
@ -39,11 +39,11 @@ type Image struct {
// id is an indentifier for the image. This is used only when dummping the information. // id is an indentifier for the image. This is used only when dummping the information.
// //
// This is duplicated with driver.Image's ID, but this id is still necessary because this image might not // This is duplicated with graphicsdriver.Image's ID, but this id is still necessary because this image might not
// have its driver.Image. // have its graphicsdriver.Image.
id int id int
bufferedRP []*driver.ReplacePixelsArgs bufferedRP []*graphicsdriver.ReplacePixelsArgs
} }
var nextID = 1 var nextID = 1
@ -141,7 +141,7 @@ func (i *Image) InternalSize() (int, int) {
// //
// If the source image is not specified, i.e., src is nil and there is no image in the uniform variables, the // 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. // elements for the source image are not used.
func (i *Image) DrawTriangles(srcs [graphics.ShaderImageNum]*Image, offsets [graphics.ShaderImageNum - 1][2]float32, vertices []float32, indices []uint16, clr affine.ColorM, mode driver.CompositeMode, filter driver.Filter, address driver.Address, dstRegion, srcRegion driver.Region, shader *Shader, uniforms []driver.Uniform, evenOdd bool) { func (i *Image) DrawTriangles(srcs [graphics.ShaderImageNum]*Image, offsets [graphics.ShaderImageNum - 1][2]float32, vertices []float32, indices []uint16, clr affine.ColorM, mode graphicsdriver.CompositeMode, filter graphicsdriver.Filter, address graphicsdriver.Address, dstRegion, srcRegion graphicsdriver.Region, shader *Shader, uniforms []graphicsdriver.Uniform, evenOdd bool) {
if shader == nil { if shader == nil {
// Fast path for rendering without a shader (#1355). // Fast path for rendering without a shader (#1355).
img := srcs[0] img := srcs[0]
@ -180,7 +180,7 @@ func (i *Image) Pixels() ([]byte, error) {
} }
func (i *Image) ReplacePixels(pixels []byte, x, y, width, height int) { func (i *Image) ReplacePixels(pixels []byte, x, y, width, height int) {
i.bufferedRP = append(i.bufferedRP, &driver.ReplacePixelsArgs{ i.bufferedRP = append(i.bufferedRP, &graphicsdriver.ReplacePixelsArgs{
Pixels: pixels, Pixels: pixels,
X: x, X: x,
Y: y, Y: y,

View File

@ -19,9 +19,9 @@ import (
"testing" "testing"
"github.com/hajimehoshi/ebiten/v2/internal/affine" "github.com/hajimehoshi/ebiten/v2/internal/affine"
"github.com/hajimehoshi/ebiten/v2/internal/driver"
"github.com/hajimehoshi/ebiten/v2/internal/graphics" "github.com/hajimehoshi/ebiten/v2/internal/graphics"
"github.com/hajimehoshi/ebiten/v2/internal/graphicscommand" "github.com/hajimehoshi/ebiten/v2/internal/graphicscommand"
"github.com/hajimehoshi/ebiten/v2/internal/graphicsdriver"
etesting "github.com/hajimehoshi/ebiten/v2/internal/testing" etesting "github.com/hajimehoshi/ebiten/v2/internal/testing"
) )
@ -45,13 +45,13 @@ func TestClear(t *testing.T) {
vs := quadVertices(w/2, h/2) vs := quadVertices(w/2, h/2)
is := graphics.QuadIndices() is := graphics.QuadIndices()
dr := driver.Region{ dr := graphicsdriver.Region{
X: 0, X: 0,
Y: 0, Y: 0,
Width: w, Width: w,
Height: h, Height: h,
} }
dst.DrawTriangles([graphics.ShaderImageNum]*graphicscommand.Image{src}, [graphics.ShaderImageNum - 1][2]float32{}, vs, is, affine.ColorMIdentity{}, driver.CompositeModeClear, driver.FilterNearest, driver.AddressUnsafe, dr, driver.Region{}, nil, nil, false) dst.DrawTriangles([graphics.ShaderImageNum]*graphicscommand.Image{src}, [graphics.ShaderImageNum - 1][2]float32{}, vs, is, affine.ColorMIdentity{}, graphicsdriver.CompositeModeClear, graphicsdriver.FilterNearest, graphicsdriver.AddressUnsafe, dr, graphicsdriver.Region{}, nil, nil, false)
pix, err := dst.Pixels() pix, err := dst.Pixels()
if err != nil { if err != nil {
@ -76,14 +76,14 @@ func TestReplacePixelsPartAfterDrawTriangles(t *testing.T) {
dst := graphicscommand.NewImage(w, h) dst := graphicscommand.NewImage(w, h)
vs := quadVertices(w/2, h/2) vs := quadVertices(w/2, h/2)
is := graphics.QuadIndices() is := graphics.QuadIndices()
dr := driver.Region{ dr := graphicsdriver.Region{
X: 0, X: 0,
Y: 0, Y: 0,
Width: w, Width: w,
Height: h, Height: h,
} }
dst.DrawTriangles([graphics.ShaderImageNum]*graphicscommand.Image{clr}, [graphics.ShaderImageNum - 1][2]float32{}, vs, is, affine.ColorMIdentity{}, driver.CompositeModeClear, driver.FilterNearest, driver.AddressUnsafe, dr, driver.Region{}, nil, nil, false) dst.DrawTriangles([graphics.ShaderImageNum]*graphicscommand.Image{clr}, [graphics.ShaderImageNum - 1][2]float32{}, vs, is, affine.ColorMIdentity{}, graphicsdriver.CompositeModeClear, graphicsdriver.FilterNearest, graphicsdriver.AddressUnsafe, dr, graphicsdriver.Region{}, nil, nil, false)
dst.DrawTriangles([graphics.ShaderImageNum]*graphicscommand.Image{src}, [graphics.ShaderImageNum - 1][2]float32{}, vs, is, affine.ColorMIdentity{}, driver.CompositeModeSourceOver, driver.FilterNearest, driver.AddressUnsafe, dr, driver.Region{}, nil, nil, false) dst.DrawTriangles([graphics.ShaderImageNum]*graphicscommand.Image{src}, [graphics.ShaderImageNum - 1][2]float32{}, vs, is, affine.ColorMIdentity{}, graphicsdriver.CompositeModeSourceOver, graphicsdriver.FilterNearest, graphicsdriver.AddressUnsafe, dr, graphicsdriver.Region{}, nil, nil, false)
dst.ReplacePixels(make([]byte, 4), 0, 0, 1, 1) dst.ReplacePixels(make([]byte, 4), 0, 0, 1, 1)
// TODO: Check the result. // TODO: Check the result.
@ -95,17 +95,17 @@ func TestShader(t *testing.T) {
dst := graphicscommand.NewImage(w, h) dst := graphicscommand.NewImage(w, h)
vs := quadVertices(w, h) vs := quadVertices(w, h)
is := graphics.QuadIndices() is := graphics.QuadIndices()
dr := driver.Region{ dr := graphicsdriver.Region{
X: 0, X: 0,
Y: 0, Y: 0,
Width: w, Width: w,
Height: h, Height: h,
} }
dst.DrawTriangles([graphics.ShaderImageNum]*graphicscommand.Image{clr}, [graphics.ShaderImageNum - 1][2]float32{}, vs, is, affine.ColorMIdentity{}, driver.CompositeModeClear, driver.FilterNearest, driver.AddressUnsafe, dr, driver.Region{}, nil, nil, false) dst.DrawTriangles([graphics.ShaderImageNum]*graphicscommand.Image{clr}, [graphics.ShaderImageNum - 1][2]float32{}, vs, is, affine.ColorMIdentity{}, graphicsdriver.CompositeModeClear, graphicsdriver.FilterNearest, graphicsdriver.AddressUnsafe, dr, graphicsdriver.Region{}, nil, nil, false)
ir := etesting.ShaderProgramFill(0xff, 0, 0, 0xff) ir := etesting.ShaderProgramFill(0xff, 0, 0, 0xff)
s := graphicscommand.NewShader(&ir) s := graphicscommand.NewShader(&ir)
dst.DrawTriangles([graphics.ShaderImageNum]*graphicscommand.Image{}, [graphics.ShaderImageNum - 1][2]float32{}, vs, is, affine.ColorMIdentity{}, driver.CompositeModeSourceOver, driver.FilterNearest, driver.AddressUnsafe, dr, driver.Region{}, s, nil, false) dst.DrawTriangles([graphics.ShaderImageNum]*graphicscommand.Image{}, [graphics.ShaderImageNum - 1][2]float32{}, vs, is, affine.ColorMIdentity{}, graphicsdriver.CompositeModeSourceOver, graphicsdriver.FilterNearest, graphicsdriver.AddressUnsafe, dr, graphicsdriver.Region{}, s, nil, false)
pix, err := dst.Pixels() pix, err := dst.Pixels()
if err != nil { if err != nil {

View File

@ -15,12 +15,12 @@
package graphicscommand package graphicscommand
import ( import (
"github.com/hajimehoshi/ebiten/v2/internal/driver" "github.com/hajimehoshi/ebiten/v2/internal/graphicsdriver"
"github.com/hajimehoshi/ebiten/v2/internal/shaderir" "github.com/hajimehoshi/ebiten/v2/internal/shaderir"
) )
type Shader struct { type Shader struct {
shader driver.Shader shader graphicsdriver.Shader
} }
func NewShader(ir *shaderir.Program) *Shader { func NewShader(ir *shaderir.Program) *Shader {

View File

@ -12,7 +12,7 @@
// See the License for the specific language governing permissions and // See the License for the specific language governing permissions and
// limitations under the License. // limitations under the License.
package driver package graphicsdriver
import ( import (
"fmt" "fmt"

View File

@ -12,7 +12,7 @@
// See the License for the specific language governing permissions and // See the License for the specific language governing permissions and
// limitations under the License. // limitations under the License.
package driver package graphicsdriver
type Filter int type Filter int

View File

@ -12,7 +12,7 @@
// See the License for the specific language governing permissions and // See the License for the specific language governing permissions and
// limitations under the License. // limitations under the License.
package driver package graphicsdriver
import ( import (
"errors" "errors"

View File

@ -24,8 +24,8 @@ import (
"strings" "strings"
"unsafe" "unsafe"
"github.com/hajimehoshi/ebiten/v2/internal/driver"
"github.com/hajimehoshi/ebiten/v2/internal/graphics" "github.com/hajimehoshi/ebiten/v2/internal/graphics"
"github.com/hajimehoshi/ebiten/v2/internal/graphicsdriver"
"github.com/hajimehoshi/ebiten/v2/internal/graphicsdriver/metal/ca" "github.com/hajimehoshi/ebiten/v2/internal/graphicsdriver/metal/ca"
"github.com/hajimehoshi/ebiten/v2/internal/graphicsdriver/metal/mtl" "github.com/hajimehoshi/ebiten/v2/internal/graphicsdriver/metal/mtl"
"github.com/hajimehoshi/ebiten/v2/internal/shaderir" "github.com/hajimehoshi/ebiten/v2/internal/shaderir"
@ -297,9 +297,9 @@ FragmentShaderFunc(0, FILTER_SCREEN, ADDRESS_UNSAFE)
type rpsKey struct { type rpsKey struct {
useColorM bool useColorM bool
filter driver.Filter filter graphicsdriver.Filter
address driver.Address address graphicsdriver.Address
compositeMode driver.CompositeMode compositeMode graphicsdriver.CompositeMode
stencilMode stencilMode stencilMode stencilMode
screen bool screen bool
} }
@ -325,11 +325,11 @@ type Graphics struct {
vb mtl.Buffer vb mtl.Buffer
ib mtl.Buffer ib mtl.Buffer
images map[driver.ImageID]*Image images map[graphicsdriver.ImageID]*Image
nextImageID driver.ImageID nextImageID graphicsdriver.ImageID
shaders map[driver.ShaderID]*Shader shaders map[graphicsdriver.ShaderID]*Shader
nextShaderID driver.ShaderID nextShaderID graphicsdriver.ShaderID
src *Image src *Image
dst *Image dst *Image
@ -499,17 +499,17 @@ func (g *Graphics) checkSize(width, height int) {
} }
} }
func (g *Graphics) genNextImageID() driver.ImageID { func (g *Graphics) genNextImageID() graphicsdriver.ImageID {
g.nextImageID++ g.nextImageID++
return g.nextImageID return g.nextImageID
} }
func (g *Graphics) genNextShaderID() driver.ShaderID { func (g *Graphics) genNextShaderID() graphicsdriver.ShaderID {
g.nextShaderID++ g.nextShaderID++
return g.nextShaderID return g.nextShaderID
} }
func (g *Graphics) NewImage(width, height int) (driver.Image, error) { func (g *Graphics) NewImage(width, height int) (graphicsdriver.Image, error) {
g.checkSize(width, height) g.checkSize(width, height)
td := mtl.TextureDescriptor{ td := mtl.TextureDescriptor{
TextureType: mtl.TextureType2D, TextureType: mtl.TextureType2D,
@ -531,7 +531,7 @@ func (g *Graphics) NewImage(width, height int) (driver.Image, error) {
return i, nil return i, nil
} }
func (g *Graphics) NewScreenFramebufferImage(width, height int) (driver.Image, error) { func (g *Graphics) NewScreenFramebufferImage(width, height int) (graphicsdriver.Image, error) {
g.view.setDrawableSize(width, height) g.view.setDrawableSize(width, height)
i := &Image{ i := &Image{
id: g.genNextImageID(), id: g.genNextImageID(),
@ -546,7 +546,7 @@ func (g *Graphics) NewScreenFramebufferImage(width, height int) (driver.Image, e
func (g *Graphics) addImage(img *Image) { func (g *Graphics) addImage(img *Image) {
if g.images == nil { if g.images == nil {
g.images = map[driver.ImageID]*Image{} g.images = map[graphicsdriver.ImageID]*Image{}
} }
if _, ok := g.images[img.id]; ok { if _, ok := g.images[img.id]; ok {
panic(fmt.Sprintf("opengl: image ID %d was already registered", img.id)) panic(fmt.Sprintf("opengl: image ID %d was already registered", img.id))
@ -562,21 +562,21 @@ func (g *Graphics) SetTransparent(transparent bool) {
g.transparent = transparent g.transparent = transparent
} }
func operationToBlendFactor(c driver.Operation) mtl.BlendFactor { func operationToBlendFactor(c graphicsdriver.Operation) mtl.BlendFactor {
switch c { switch c {
case driver.Zero: case graphicsdriver.Zero:
return mtl.BlendFactorZero return mtl.BlendFactorZero
case driver.One: case graphicsdriver.One:
return mtl.BlendFactorOne return mtl.BlendFactorOne
case driver.SrcAlpha: case graphicsdriver.SrcAlpha:
return mtl.BlendFactorSourceAlpha return mtl.BlendFactorSourceAlpha
case driver.DstAlpha: case graphicsdriver.DstAlpha:
return mtl.BlendFactorDestinationAlpha return mtl.BlendFactorDestinationAlpha
case driver.OneMinusSrcAlpha: case graphicsdriver.OneMinusSrcAlpha:
return mtl.BlendFactorOneMinusSourceAlpha return mtl.BlendFactorOneMinusSourceAlpha
case driver.OneMinusDstAlpha: case graphicsdriver.OneMinusDstAlpha:
return mtl.BlendFactorOneMinusDestinationAlpha return mtl.BlendFactorOneMinusDestinationAlpha
case driver.DstColor: case graphicsdriver.DstColor:
return mtl.BlendFactorDestinationColor return mtl.BlendFactorDestinationColor
default: default:
panic(fmt.Sprintf("metal: invalid operation: %d", c)) panic(fmt.Sprintf("metal: invalid operation: %d", c))
@ -607,12 +607,12 @@ func (g *Graphics) Initialize() error {
} }
replaces := map[string]string{ replaces := map[string]string{
"{{.FilterNearest}}": fmt.Sprintf("%d", driver.FilterNearest), "{{.FilterNearest}}": fmt.Sprintf("%d", graphicsdriver.FilterNearest),
"{{.FilterLinear}}": fmt.Sprintf("%d", driver.FilterLinear), "{{.FilterLinear}}": fmt.Sprintf("%d", graphicsdriver.FilterLinear),
"{{.FilterScreen}}": fmt.Sprintf("%d", driver.FilterScreen), "{{.FilterScreen}}": fmt.Sprintf("%d", graphicsdriver.FilterScreen),
"{{.AddressClampToZero}}": fmt.Sprintf("%d", driver.AddressClampToZero), "{{.AddressClampToZero}}": fmt.Sprintf("%d", graphicsdriver.AddressClampToZero),
"{{.AddressRepeat}}": fmt.Sprintf("%d", driver.AddressRepeat), "{{.AddressRepeat}}": fmt.Sprintf("%d", graphicsdriver.AddressRepeat),
"{{.AddressUnsafe}}": fmt.Sprintf("%d", driver.AddressUnsafe), "{{.AddressUnsafe}}": fmt.Sprintf("%d", graphicsdriver.AddressUnsafe),
} }
src := source src := source
for k, v := range replaces { for k, v := range replaces {
@ -628,7 +628,7 @@ func (g *Graphics) Initialize() error {
return err return err
} }
fs, err := lib.MakeFunction( fs, err := lib.MakeFunction(
fmt.Sprintf("FragmentShader_%d_%d_%d", 0, driver.FilterScreen, driver.AddressUnsafe)) fmt.Sprintf("FragmentShader_%d_%d_%d", 0, graphicsdriver.FilterScreen, graphicsdriver.AddressUnsafe))
if err != nil { if err != nil {
return err return err
} }
@ -651,16 +651,16 @@ func (g *Graphics) Initialize() error {
for _, screen := range []bool{false, true} { for _, screen := range []bool{false, true} {
for _, cm := range []bool{false, true} { for _, cm := range []bool{false, true} {
for _, a := range []driver.Address{ for _, a := range []graphicsdriver.Address{
driver.AddressClampToZero, graphicsdriver.AddressClampToZero,
driver.AddressRepeat, graphicsdriver.AddressRepeat,
driver.AddressUnsafe, graphicsdriver.AddressUnsafe,
} { } {
for _, f := range []driver.Filter{ for _, f := range []graphicsdriver.Filter{
driver.FilterNearest, graphicsdriver.FilterNearest,
driver.FilterLinear, graphicsdriver.FilterLinear,
} { } {
for c := driver.CompositeModeSourceOver; c <= driver.CompositeModeMax; c++ { for c := graphicsdriver.CompositeModeSourceOver; c <= graphicsdriver.CompositeModeMax; c++ {
for _, stencil := range []stencilMode{ for _, stencil := range []stencilMode{
prepareStencil, prepareStencil,
drawWithStencil, drawWithStencil,
@ -775,7 +775,7 @@ func (g *Graphics) flushRenderCommandEncoderIfNeeded() {
g.lastDst = nil g.lastDst = nil
} }
func (g *Graphics) draw(rps mtl.RenderPipelineState, dst *Image, dstRegion driver.Region, srcs [graphics.ShaderImageNum]*Image, indexLen int, indexOffset int, uniforms []driver.Uniform, stencilMode stencilMode) error { func (g *Graphics) draw(rps mtl.RenderPipelineState, dst *Image, dstRegion graphicsdriver.Region, srcs [graphics.ShaderImageNum]*Image, indexLen int, indexOffset int, uniforms []graphicsdriver.Uniform, stencilMode stencilMode) error {
// When prepareing a stencil buffer, flush the current render command encoder // When prepareing a stencil buffer, flush the current render command encoder
// to make sure the stencil buffer is cleared when loading. // to make sure the stencil buffer is cleared when loading.
// TODO: What about clearing the stencil buffer by vertices? // TODO: What about clearing the stencil buffer by vertices?
@ -866,7 +866,7 @@ func (g *Graphics) draw(rps mtl.RenderPipelineState, dst *Image, dstRegion drive
return nil return nil
} }
func (g *Graphics) DrawTriangles(dstID driver.ImageID, srcIDs [graphics.ShaderImageNum]driver.ImageID, offsets [graphics.ShaderImageNum - 1][2]float32, shaderID driver.ShaderID, indexLen int, indexOffset int, mode driver.CompositeMode, colorM driver.ColorM, filter driver.Filter, address driver.Address, dstRegion, srcRegion driver.Region, uniforms []driver.Uniform, evenOdd bool) error { func (g *Graphics) DrawTriangles(dstID graphicsdriver.ImageID, srcIDs [graphics.ShaderImageNum]graphicsdriver.ImageID, offsets [graphics.ShaderImageNum - 1][2]float32, shaderID graphicsdriver.ShaderID, indexLen int, indexOffset int, mode graphicsdriver.CompositeMode, colorM graphicsdriver.ColorM, filter graphicsdriver.Filter, address graphicsdriver.Address, dstRegion, srcRegion graphicsdriver.Region, uniforms []graphicsdriver.Uniform, evenOdd bool) error {
dst := g.images[dstID] dst := g.images[dstID]
if dst.screen { if dst.screen {
@ -879,9 +879,9 @@ func (g *Graphics) DrawTriangles(dstID driver.ImageID, srcIDs [graphics.ShaderIm
} }
rpss := map[stencilMode]mtl.RenderPipelineState{} rpss := map[stencilMode]mtl.RenderPipelineState{}
var uniformVars []driver.Uniform var uniformVars []graphicsdriver.Uniform
if shaderID == driver.InvalidShaderID { if shaderID == graphicsdriver.InvalidShaderID {
if dst.screen && filter == driver.FilterScreen { if dst.screen && filter == graphicsdriver.FilterScreen {
rpss[noStencil] = g.screenRPS rpss[noStencil] = g.screenRPS
} else { } else {
for _, stencil := range []stencilMode{ for _, stencil := range []stencilMode{
@ -902,7 +902,7 @@ func (g *Graphics) DrawTriangles(dstID driver.ImageID, srcIDs [graphics.ShaderIm
w, h := dst.internalSize() w, h := dst.internalSize()
sourceSize := []float32{0, 0} sourceSize := []float32{0, 0}
if filter != driver.FilterNearest { if filter != graphicsdriver.FilterNearest {
w, h := srcs[0].internalSize() w, h := srcs[0].internalSize()
sourceSize[0] = float32(w) sourceSize[0] = float32(w)
sourceSize[1] = float32(h) sourceSize[1] = float32(h)
@ -911,10 +911,10 @@ func (g *Graphics) DrawTriangles(dstID driver.ImageID, srcIDs [graphics.ShaderIm
var esTranslate [4]float32 var esTranslate [4]float32
colorM.Elements(&esBody, &esTranslate) colorM.Elements(&esBody, &esTranslate)
scale := float32(0) scale := float32(0)
if filter == driver.FilterScreen { if filter == graphicsdriver.FilterScreen {
scale = float32(dst.width) / float32(srcs[0].width) scale = float32(dst.width) / float32(srcs[0].width)
} }
uniformVars = []driver.Uniform{ uniformVars = []graphicsdriver.Uniform{
{ {
Float32s: []float32{float32(w), float32(h)}, Float32s: []float32{float32(w), float32(h)},
}, },
@ -952,11 +952,11 @@ func (g *Graphics) DrawTriangles(dstID driver.ImageID, srcIDs [graphics.ShaderIm
} }
} }
uniformVars = make([]driver.Uniform, graphics.PreservedUniformVariablesNum+len(uniforms)) uniformVars = make([]graphicsdriver.Uniform, graphics.PreservedUniformVariablesNum+len(uniforms))
// Set the destination texture size. // Set the destination texture size.
dw, dh := dst.internalSize() dw, dh := dst.internalSize()
uniformVars[graphics.DestinationTextureSizeUniformVariableIndex] = driver.Uniform{ uniformVars[graphics.DestinationTextureSizeUniformVariableIndex] = graphicsdriver.Uniform{
Float32s: []float32{float32(dw), float32(dh)}, Float32s: []float32{float32(dw), float32(dh)},
} }
@ -969,19 +969,19 @@ func (g *Graphics) DrawTriangles(dstID driver.ImageID, srcIDs [graphics.ShaderIm
usizes[2*i+1] = float32(h) usizes[2*i+1] = float32(h)
} }
} }
uniformVars[graphics.TextureSizesUniformVariableIndex] = driver.Uniform{ uniformVars[graphics.TextureSizesUniformVariableIndex] = graphicsdriver.Uniform{
Float32s: usizes, Float32s: usizes,
} }
// Set the destination region's origin. // Set the destination region's origin.
udorigin := []float32{float32(dstRegion.X) / float32(dw), float32(dstRegion.Y) / float32(dh)} udorigin := []float32{float32(dstRegion.X) / float32(dw), float32(dstRegion.Y) / float32(dh)}
uniformVars[graphics.TextureDestinationRegionOriginUniformVariableIndex] = driver.Uniform{ uniformVars[graphics.TextureDestinationRegionOriginUniformVariableIndex] = graphicsdriver.Uniform{
Float32s: udorigin, Float32s: udorigin,
} }
// Set the destination region's size. // Set the destination region's size.
udsize := []float32{float32(dstRegion.Width) / float32(dw), float32(dstRegion.Height) / float32(dh)} udsize := []float32{float32(dstRegion.Width) / float32(dw), float32(dstRegion.Height) / float32(dh)}
uniformVars[graphics.TextureDestinationRegionSizeUniformVariableIndex] = driver.Uniform{ uniformVars[graphics.TextureDestinationRegionSizeUniformVariableIndex] = graphicsdriver.Uniform{
Float32s: udsize, Float32s: udsize,
} }
@ -991,19 +991,19 @@ func (g *Graphics) DrawTriangles(dstID driver.ImageID, srcIDs [graphics.ShaderIm
uoffsets[2*i] = offset[0] uoffsets[2*i] = offset[0]
uoffsets[2*i+1] = offset[1] uoffsets[2*i+1] = offset[1]
} }
uniformVars[graphics.TextureSourceOffsetsUniformVariableIndex] = driver.Uniform{ uniformVars[graphics.TextureSourceOffsetsUniformVariableIndex] = graphicsdriver.Uniform{
Float32s: uoffsets, Float32s: uoffsets,
} }
// Set the source region's origin of texture0. // Set the source region's origin of texture0.
usorigin := []float32{float32(srcRegion.X), float32(srcRegion.Y)} usorigin := []float32{float32(srcRegion.X), float32(srcRegion.Y)}
uniformVars[graphics.TextureSourceRegionOriginUniformVariableIndex] = driver.Uniform{ uniformVars[graphics.TextureSourceRegionOriginUniformVariableIndex] = graphicsdriver.Uniform{
Float32s: usorigin, Float32s: usorigin,
} }
// Set the source region's size of texture0. // Set the source region's size of texture0.
ussize := []float32{float32(srcRegion.Width), float32(srcRegion.Height)} ussize := []float32{float32(srcRegion.Width), float32(srcRegion.Height)}
uniformVars[graphics.TextureSourceRegionSizeUniformVariableIndex] = driver.Uniform{ uniformVars[graphics.TextureSourceRegionSizeUniformVariableIndex] = graphicsdriver.Uniform{
Float32s: ussize, Float32s: ussize,
} }
@ -1038,8 +1038,8 @@ func (g *Graphics) SetFullscreen(fullscreen bool) {
g.view.setFullscreen(fullscreen) g.view.setFullscreen(fullscreen)
} }
func (g *Graphics) FramebufferYDirection() driver.YDirection { func (g *Graphics) FramebufferYDirection() graphicsdriver.YDirection {
return driver.Downward return graphicsdriver.Downward
} }
func (g *Graphics) NeedsRestoring() bool { func (g *Graphics) NeedsRestoring() bool {
@ -1092,7 +1092,7 @@ func (g *Graphics) MaxImageSize() int {
return g.maxImageSize return g.maxImageSize
} }
func (g *Graphics) NewShader(program *shaderir.Program) (driver.Shader, error) { func (g *Graphics) NewShader(program *shaderir.Program) (graphicsdriver.Shader, error) {
s, err := newShader(g.view.getMTLDevice(), g.genNextShaderID(), program) s, err := newShader(g.view.getMTLDevice(), g.genNextShaderID(), program)
if err != nil { if err != nil {
return nil, err return nil, err
@ -1103,7 +1103,7 @@ func (g *Graphics) NewShader(program *shaderir.Program) (driver.Shader, error) {
func (g *Graphics) addShader(shader *Shader) { func (g *Graphics) addShader(shader *Shader) {
if g.shaders == nil { if g.shaders == nil {
g.shaders = map[driver.ShaderID]*Shader{} g.shaders = map[graphicsdriver.ShaderID]*Shader{}
} }
if _, ok := g.shaders[shader.id]; ok { if _, ok := g.shaders[shader.id]; ok {
panic(fmt.Sprintf("metal: shader ID %d was already registered", shader.id)) panic(fmt.Sprintf("metal: shader ID %d was already registered", shader.id))
@ -1116,7 +1116,7 @@ func (g *Graphics) removeShader(shader *Shader) {
} }
type Image struct { type Image struct {
id driver.ImageID id graphicsdriver.ImageID
graphics *Graphics graphics *Graphics
width int width int
height int height int
@ -1125,7 +1125,7 @@ type Image struct {
stencil mtl.Texture stencil mtl.Texture
} }
func (i *Image) ID() driver.ImageID { func (i *Image) ID() graphicsdriver.ImageID {
return i.id return i.id
} }
@ -1184,7 +1184,7 @@ func (i *Image) Pixels() ([]byte, error) {
return b, nil return b, nil
} }
func (i *Image) ReplacePixels(args []*driver.ReplacePixelsArgs) { func (i *Image) ReplacePixels(args []*graphicsdriver.ReplacePixelsArgs) {
g := i.graphics g := i.graphics
g.flushRenderCommandEncoderIfNeeded() g.flushRenderCommandEncoderIfNeeded()

View File

@ -20,19 +20,19 @@ package metal
import ( import (
"fmt" "fmt"
"github.com/hajimehoshi/ebiten/v2/internal/driver" "github.com/hajimehoshi/ebiten/v2/internal/graphicsdriver"
"github.com/hajimehoshi/ebiten/v2/internal/graphicsdriver/metal/mtl" "github.com/hajimehoshi/ebiten/v2/internal/graphicsdriver/metal/mtl"
"github.com/hajimehoshi/ebiten/v2/internal/shaderir" "github.com/hajimehoshi/ebiten/v2/internal/shaderir"
"github.com/hajimehoshi/ebiten/v2/internal/shaderir/metal" "github.com/hajimehoshi/ebiten/v2/internal/shaderir/metal"
) )
type shaderRpsKey struct { type shaderRpsKey struct {
compositeMode driver.CompositeMode compositeMode graphicsdriver.CompositeMode
stencilMode stencilMode stencilMode stencilMode
} }
type Shader struct { type Shader struct {
id driver.ShaderID id graphicsdriver.ShaderID
ir *shaderir.Program ir *shaderir.Program
fs mtl.Function fs mtl.Function
@ -40,7 +40,7 @@ type Shader struct {
rpss map[shaderRpsKey]mtl.RenderPipelineState rpss map[shaderRpsKey]mtl.RenderPipelineState
} }
func newShader(device mtl.Device, id driver.ShaderID, program *shaderir.Program) (*Shader, error) { func newShader(device mtl.Device, id graphicsdriver.ShaderID, program *shaderir.Program) (*Shader, error) {
s := &Shader{ s := &Shader{
id: id, id: id,
ir: program, ir: program,
@ -52,7 +52,7 @@ func newShader(device mtl.Device, id driver.ShaderID, program *shaderir.Program)
return s, nil return s, nil
} }
func (s *Shader) ID() driver.ShaderID { func (s *Shader) ID() graphicsdriver.ShaderID {
return s.id return s.id
} }
@ -88,7 +88,7 @@ func (s *Shader) init(device mtl.Device) error {
return nil return nil
} }
func (s *Shader) RenderPipelineState(device mtl.Device, compositeMode driver.CompositeMode, stencilMode stencilMode) (mtl.RenderPipelineState, error) { func (s *Shader) RenderPipelineState(device mtl.Device, compositeMode graphicsdriver.CompositeMode, stencilMode stencilMode) (mtl.RenderPipelineState, error) {
if rps, ok := s.rpss[shaderRpsKey{ if rps, ok := s.rpss[shaderRpsKey{
compositeMode: compositeMode, compositeMode: compositeMode,
stencilMode: stencilMode, stencilMode: stencilMode,

View File

@ -18,26 +18,26 @@ import (
"fmt" "fmt"
"sync" "sync"
"github.com/hajimehoshi/ebiten/v2/internal/driver" "github.com/hajimehoshi/ebiten/v2/internal/graphicsdriver"
) )
type operation int type operation int
func convertOperation(op driver.Operation) operation { func convertOperation(op graphicsdriver.Operation) operation {
switch op { switch op {
case driver.Zero: case graphicsdriver.Zero:
return zero return zero
case driver.One: case graphicsdriver.One:
return one return one
case driver.SrcAlpha: case graphicsdriver.SrcAlpha:
return srcAlpha return srcAlpha
case driver.DstAlpha: case graphicsdriver.DstAlpha:
return dstAlpha return dstAlpha
case driver.OneMinusSrcAlpha: case graphicsdriver.OneMinusSrcAlpha:
return oneMinusSrcAlpha return oneMinusSrcAlpha
case driver.OneMinusDstAlpha: case graphicsdriver.OneMinusDstAlpha:
return oneMinusDstAlpha return oneMinusDstAlpha
case driver.DstColor: case graphicsdriver.DstColor:
return dstColor return dstColor
default: default:
panic(fmt.Sprintf("opengl: invalid operation %d at convertOperation", op)) panic(fmt.Sprintf("opengl: invalid operation %d at convertOperation", op))
@ -52,7 +52,7 @@ type context struct {
lastRenderbuffer renderbufferNative lastRenderbuffer renderbufferNative
lastViewportWidth int lastViewportWidth int
lastViewportHeight int lastViewportHeight int
lastCompositeMode driver.CompositeMode lastCompositeMode graphicsdriver.CompositeMode
maxTextureSize int maxTextureSize int
maxTextureSizeOnce sync.Once maxTextureSizeOnce sync.Once
highp bool highp bool

View File

@ -21,7 +21,7 @@ import (
"errors" "errors"
"fmt" "fmt"
"github.com/hajimehoshi/ebiten/v2/internal/driver" "github.com/hajimehoshi/ebiten/v2/internal/graphicsdriver"
"github.com/hajimehoshi/ebiten/v2/internal/graphicsdriver/opengl/gl" "github.com/hajimehoshi/ebiten/v2/internal/graphicsdriver/opengl/gl"
"github.com/hajimehoshi/ebiten/v2/internal/shaderir" "github.com/hajimehoshi/ebiten/v2/internal/shaderir"
) )
@ -110,11 +110,11 @@ func (c *context) reset() error {
c.lastFramebuffer = invalidFramebuffer c.lastFramebuffer = invalidFramebuffer
c.lastViewportWidth = 0 c.lastViewportWidth = 0
c.lastViewportHeight = 0 c.lastViewportHeight = 0
c.lastCompositeMode = driver.CompositeModeUnknown c.lastCompositeMode = graphicsdriver.CompositeModeUnknown
gl.Enable(gl.BLEND) gl.Enable(gl.BLEND)
gl.Enable(gl.SCISSOR_TEST) gl.Enable(gl.SCISSOR_TEST)
c.blendFunc(driver.CompositeModeSourceOver) c.blendFunc(graphicsdriver.CompositeModeSourceOver)
f := int32(0) f := int32(0)
gl.GetIntegerv(gl.FRAMEBUFFER_BINDING, &f) gl.GetIntegerv(gl.FRAMEBUFFER_BINDING, &f)
@ -122,7 +122,7 @@ func (c *context) reset() error {
return nil return nil
} }
func (c *context) blendFunc(mode driver.CompositeMode) { func (c *context) blendFunc(mode graphicsdriver.CompositeMode) {
if c.lastCompositeMode == mode { if c.lastCompositeMode == mode {
return return
} }
@ -496,7 +496,7 @@ func (c *context) needsRestoring() bool {
return false return false
} }
func (c *context) texSubImage2D(t textureNative, args []*driver.ReplacePixelsArgs) { func (c *context) texSubImage2D(t textureNative, args []*graphicsdriver.ReplacePixelsArgs) {
c.bindTexture(t) c.bindTexture(t)
for _, a := range args { for _, a := range args {
gl.TexSubImage2D(gl.TEXTURE_2D, 0, int32(a.X), int32(a.Y), int32(a.Width), int32(a.Height), gl.RGBA, gl.UNSIGNED_BYTE, gl.Ptr(a.Pixels)) gl.TexSubImage2D(gl.TEXTURE_2D, 0, int32(a.X), int32(a.Y), int32(a.Width), int32(a.Height), gl.RGBA, gl.UNSIGNED_BYTE, gl.Ptr(a.Pixels))

View File

@ -19,7 +19,7 @@ import (
"fmt" "fmt"
"syscall/js" "syscall/js"
"github.com/hajimehoshi/ebiten/v2/internal/driver" "github.com/hajimehoshi/ebiten/v2/internal/graphicsdriver"
"github.com/hajimehoshi/ebiten/v2/internal/graphicsdriver/opengl/gles" "github.com/hajimehoshi/ebiten/v2/internal/graphicsdriver/opengl/gles"
"github.com/hajimehoshi/ebiten/v2/internal/jsutil" "github.com/hajimehoshi/ebiten/v2/internal/jsutil"
"github.com/hajimehoshi/ebiten/v2/internal/shaderir" "github.com/hajimehoshi/ebiten/v2/internal/shaderir"
@ -167,19 +167,19 @@ func (c *context) reset() error {
c.lastFramebuffer = framebufferNative(js.Null()) c.lastFramebuffer = framebufferNative(js.Null())
c.lastViewportWidth = 0 c.lastViewportWidth = 0
c.lastViewportHeight = 0 c.lastViewportHeight = 0
c.lastCompositeMode = driver.CompositeModeUnknown c.lastCompositeMode = graphicsdriver.CompositeModeUnknown
if err := c.initGL(); err != nil { if err := c.initGL(); err != nil {
return err return err
} }
if c.gl.isContextLost.Invoke().Bool() { if c.gl.isContextLost.Invoke().Bool() {
return driver.GraphicsNotReady return graphicsdriver.GraphicsNotReady
} }
gl := c.gl gl := c.gl
gl.enable.Invoke(gles.BLEND) gl.enable.Invoke(gles.BLEND)
gl.enable.Invoke(gles.SCISSOR_TEST) gl.enable.Invoke(gles.SCISSOR_TEST)
c.blendFunc(driver.CompositeModeSourceOver) c.blendFunc(graphicsdriver.CompositeModeSourceOver)
f := gl.getParameter.Invoke(gles.FRAMEBUFFER_BINDING) f := gl.getParameter.Invoke(gles.FRAMEBUFFER_BINDING)
c.screenFramebuffer = framebufferNative(f) c.screenFramebuffer = framebufferNative(f)
@ -189,7 +189,7 @@ func (c *context) reset() error {
return nil return nil
} }
func (c *context) blendFunc(mode driver.CompositeMode) { func (c *context) blendFunc(mode graphicsdriver.CompositeMode) {
if c.lastCompositeMode == mode { if c.lastCompositeMode == mode {
return return
} }
@ -620,7 +620,7 @@ func (c *context) canUsePBO() bool {
return false return false
} }
func (c *context) texSubImage2D(t textureNative, args []*driver.ReplacePixelsArgs) { func (c *context) texSubImage2D(t textureNative, args []*graphicsdriver.ReplacePixelsArgs) {
c.bindTexture(t) c.bindTexture(t)
gl := c.gl gl := c.gl
for _, a := range args { for _, a := range args {

View File

@ -21,7 +21,7 @@ import (
"errors" "errors"
"fmt" "fmt"
"github.com/hajimehoshi/ebiten/v2/internal/driver" "github.com/hajimehoshi/ebiten/v2/internal/graphicsdriver"
"github.com/hajimehoshi/ebiten/v2/internal/graphicsdriver/opengl/gles" "github.com/hajimehoshi/ebiten/v2/internal/graphicsdriver/opengl/gles"
"github.com/hajimehoshi/ebiten/v2/internal/shaderir" "github.com/hajimehoshi/ebiten/v2/internal/shaderir"
) )
@ -102,10 +102,10 @@ func (c *context) reset() error {
c.lastFramebuffer = invalidFramebuffer c.lastFramebuffer = invalidFramebuffer
c.lastViewportWidth = 0 c.lastViewportWidth = 0
c.lastViewportHeight = 0 c.lastViewportHeight = 0
c.lastCompositeMode = driver.CompositeModeUnknown c.lastCompositeMode = graphicsdriver.CompositeModeUnknown
c.ctx.Enable(gles.BLEND) c.ctx.Enable(gles.BLEND)
c.ctx.Enable(gles.SCISSOR_TEST) c.ctx.Enable(gles.SCISSOR_TEST)
c.blendFunc(driver.CompositeModeSourceOver) c.blendFunc(graphicsdriver.CompositeModeSourceOver)
f := make([]int32, 1) f := make([]int32, 1)
c.ctx.GetIntegerv(f, gles.FRAMEBUFFER_BINDING) c.ctx.GetIntegerv(f, gles.FRAMEBUFFER_BINDING)
c.screenFramebuffer = framebufferNative(f[0]) c.screenFramebuffer = framebufferNative(f[0])
@ -113,7 +113,7 @@ func (c *context) reset() error {
return nil return nil
} }
func (c *context) blendFunc(mode driver.CompositeMode) { func (c *context) blendFunc(mode graphicsdriver.CompositeMode) {
if c.lastCompositeMode == mode { if c.lastCompositeMode == mode {
return return
} }
@ -464,7 +464,7 @@ func (c *context) canUsePBO() bool {
return false return false
} }
func (c *context) texSubImage2D(t textureNative, args []*driver.ReplacePixelsArgs) { func (c *context) texSubImage2D(t textureNative, args []*graphicsdriver.ReplacePixelsArgs) {
c.bindTexture(t) c.bindTexture(t)
for _, a := range args { for _, a := range args {
c.ctx.TexSubImage2D(gles.TEXTURE_2D, 0, int32(a.X), int32(a.Y), int32(a.Width), int32(a.Height), gles.RGBA, gles.UNSIGNED_BYTE, a.Pixels) c.ctx.TexSubImage2D(gles.TEXTURE_2D, 0, int32(a.X), int32(a.Y), int32(a.Width), int32(a.Height), gles.RGBA, gles.UNSIGNED_BYTE, a.Pixels)

View File

@ -19,7 +19,7 @@ import (
"regexp" "regexp"
"strings" "strings"
"github.com/hajimehoshi/ebiten/v2/internal/driver" "github.com/hajimehoshi/ebiten/v2/internal/graphicsdriver"
) )
// glslReservedKeywords is a set of reserved keywords that cannot be used as an indentifier on some environments. // glslReservedKeywords is a set of reserved keywords that cannot be used as an indentifier on some environments.
@ -61,11 +61,11 @@ func vertexShaderStr() string {
return src return src
} }
func fragmentShaderStr(useColorM bool, filter driver.Filter, address driver.Address) string { func fragmentShaderStr(useColorM bool, filter graphicsdriver.Filter, address graphicsdriver.Address) string {
replaces := map[string]string{ replaces := map[string]string{
"{{.AddressClampToZero}}": fmt.Sprintf("%d", driver.AddressClampToZero), "{{.AddressClampToZero}}": fmt.Sprintf("%d", graphicsdriver.AddressClampToZero),
"{{.AddressRepeat}}": fmt.Sprintf("%d", driver.AddressRepeat), "{{.AddressRepeat}}": fmt.Sprintf("%d", graphicsdriver.AddressRepeat),
"{{.AddressUnsafe}}": fmt.Sprintf("%d", driver.AddressUnsafe), "{{.AddressUnsafe}}": fmt.Sprintf("%d", graphicsdriver.AddressUnsafe),
} }
src := shaderStrFragment src := shaderStrFragment
for k, v := range replaces { for k, v := range replaces {
@ -79,22 +79,22 @@ func fragmentShaderStr(useColorM bool, filter driver.Filter, address driver.Addr
} }
switch filter { switch filter {
case driver.FilterNearest: case graphicsdriver.FilterNearest:
defs = append(defs, "#define FILTER_NEAREST") defs = append(defs, "#define FILTER_NEAREST")
case driver.FilterLinear: case graphicsdriver.FilterLinear:
defs = append(defs, "#define FILTER_LINEAR") defs = append(defs, "#define FILTER_LINEAR")
case driver.FilterScreen: case graphicsdriver.FilterScreen:
defs = append(defs, "#define FILTER_SCREEN") defs = append(defs, "#define FILTER_SCREEN")
default: default:
panic(fmt.Sprintf("opengl: invalid filter: %d", filter)) panic(fmt.Sprintf("opengl: invalid filter: %d", filter))
} }
switch address { switch address {
case driver.AddressClampToZero: case graphicsdriver.AddressClampToZero:
defs = append(defs, "#define ADDRESS_CLAMP_TO_ZERO") defs = append(defs, "#define ADDRESS_CLAMP_TO_ZERO")
case driver.AddressRepeat: case graphicsdriver.AddressRepeat:
defs = append(defs, "#define ADDRESS_REPEAT") defs = append(defs, "#define ADDRESS_REPEAT")
case driver.AddressUnsafe: case graphicsdriver.AddressUnsafe:
defs = append(defs, "#define ADDRESS_UNSAFE") defs = append(defs, "#define ADDRESS_UNSAFE")
default: default:
panic(fmt.Sprintf("opengl: invalid address: %d", address)) panic(fmt.Sprintf("opengl: invalid address: %d", address))

View File

@ -17,8 +17,8 @@ package opengl
import ( import (
"fmt" "fmt"
"github.com/hajimehoshi/ebiten/v2/internal/driver"
"github.com/hajimehoshi/ebiten/v2/internal/graphics" "github.com/hajimehoshi/ebiten/v2/internal/graphics"
"github.com/hajimehoshi/ebiten/v2/internal/graphicsdriver"
"github.com/hajimehoshi/ebiten/v2/internal/shaderir" "github.com/hajimehoshi/ebiten/v2/internal/shaderir"
) )
@ -37,11 +37,11 @@ type Graphics struct {
state openGLState state openGLState
context context context context
nextImageID driver.ImageID nextImageID graphicsdriver.ImageID
images map[driver.ImageID]*Image images map[graphicsdriver.ImageID]*Image
nextShaderID driver.ShaderID nextShaderID graphicsdriver.ShaderID
shaders map[driver.ShaderID]*Shader shaders map[graphicsdriver.ShaderID]*Shader
// drawCalled is true just after Draw is called. This holds true until ReplacePixels is called. // drawCalled is true just after Draw is called. This holds true until ReplacePixels is called.
drawCalled bool drawCalled bool
@ -86,17 +86,17 @@ func (g *Graphics) checkSize(width, height int) {
} }
} }
func (g *Graphics) genNextImageID() driver.ImageID { func (g *Graphics) genNextImageID() graphicsdriver.ImageID {
g.nextImageID++ g.nextImageID++
return g.nextImageID return g.nextImageID
} }
func (g *Graphics) genNextShaderID() driver.ShaderID { func (g *Graphics) genNextShaderID() graphicsdriver.ShaderID {
g.nextShaderID++ g.nextShaderID++
return g.nextShaderID return g.nextShaderID
} }
func (g *Graphics) NewImage(width, height int) (driver.Image, error) { func (g *Graphics) NewImage(width, height int) (graphicsdriver.Image, error) {
i := &Image{ i := &Image{
id: g.genNextImageID(), id: g.genNextImageID(),
graphics: g, graphics: g,
@ -115,7 +115,7 @@ func (g *Graphics) NewImage(width, height int) (driver.Image, error) {
return i, nil return i, nil
} }
func (g *Graphics) NewScreenFramebufferImage(width, height int) (driver.Image, error) { func (g *Graphics) NewScreenFramebufferImage(width, height int) (graphicsdriver.Image, error) {
g.checkSize(width, height) g.checkSize(width, height)
i := &Image{ i := &Image{
id: g.genNextImageID(), id: g.genNextImageID(),
@ -130,7 +130,7 @@ func (g *Graphics) NewScreenFramebufferImage(width, height int) (driver.Image, e
func (g *Graphics) addImage(img *Image) { func (g *Graphics) addImage(img *Image) {
if g.images == nil { if g.images == nil {
g.images = map[driver.ImageID]*Image{} g.images = map[graphicsdriver.ImageID]*Image{}
} }
if _, ok := g.images[img.id]; ok { if _, ok := g.images[img.id]; ok {
panic(fmt.Sprintf("opengl: image ID %d was already registered", img.id)) panic(fmt.Sprintf("opengl: image ID %d was already registered", img.id))
@ -171,7 +171,7 @@ func (g *Graphics) uniformVariableName(idx int) string {
return name return name
} }
func (g *Graphics) DrawTriangles(dstID driver.ImageID, srcIDs [graphics.ShaderImageNum]driver.ImageID, offsets [graphics.ShaderImageNum - 1][2]float32, shaderID driver.ShaderID, indexLen int, indexOffset int, mode driver.CompositeMode, colorM driver.ColorM, filter driver.Filter, address driver.Address, dstRegion, srcRegion driver.Region, uniforms []driver.Uniform, evenOdd bool) error { func (g *Graphics) DrawTriangles(dstID graphicsdriver.ImageID, srcIDs [graphics.ShaderImageNum]graphicsdriver.ImageID, offsets [graphics.ShaderImageNum - 1][2]float32, shaderID graphicsdriver.ShaderID, indexLen int, indexOffset int, mode graphicsdriver.CompositeMode, colorM graphicsdriver.ColorM, filter graphicsdriver.Filter, address graphicsdriver.Address, dstRegion, srcRegion graphicsdriver.Region, uniforms []graphicsdriver.Uniform, evenOdd bool) error {
destination := g.images[dstID] destination := g.images[dstID]
g.drawCalled = true g.drawCalled = true
@ -188,7 +188,7 @@ func (g *Graphics) DrawTriangles(dstID driver.ImageID, srcIDs [graphics.ShaderIm
g.context.blendFunc(mode) g.context.blendFunc(mode)
var program program var program program
if shaderID == driver.InvalidShaderID { if shaderID == graphicsdriver.InvalidShaderID {
program = g.state.programs[programKey{ program = g.state.programs[programKey{
useColorM: !colorM.IsIdentity(), useColorM: !colorM.IsIdentity(),
filter: filter, filter: filter,
@ -198,13 +198,13 @@ func (g *Graphics) DrawTriangles(dstID driver.ImageID, srcIDs [graphics.ShaderIm
dw, dh := destination.framebufferSize() dw, dh := destination.framebufferSize()
g.uniformVars = append(g.uniformVars, uniformVariable{ g.uniformVars = append(g.uniformVars, uniformVariable{
name: "viewport_size", name: "viewport_size",
value: driver.Uniform{ value: graphicsdriver.Uniform{
Float32s: []float32{float32(dw), float32(dh)}, Float32s: []float32{float32(dw), float32(dh)},
}, },
typ: shaderir.Type{Main: shaderir.Vec2}, typ: shaderir.Type{Main: shaderir.Vec2},
}, uniformVariable{ }, uniformVariable{
name: "source_region", name: "source_region",
value: driver.Uniform{ value: graphicsdriver.Uniform{
Float32s: []float32{ Float32s: []float32{
srcRegion.X, srcRegion.X,
srcRegion.Y, srcRegion.Y,
@ -222,35 +222,35 @@ func (g *Graphics) DrawTriangles(dstID driver.ImageID, srcIDs [graphics.ShaderIm
colorM.Elements(&esBody, &esTranslate) colorM.Elements(&esBody, &esTranslate)
g.uniformVars = append(g.uniformVars, uniformVariable{ g.uniformVars = append(g.uniformVars, uniformVariable{
name: "color_matrix_body", name: "color_matrix_body",
value: driver.Uniform{ value: graphicsdriver.Uniform{
Float32s: esBody[:], Float32s: esBody[:],
}, },
typ: shaderir.Type{Main: shaderir.Mat4}, typ: shaderir.Type{Main: shaderir.Mat4},
}, uniformVariable{ }, uniformVariable{
name: "color_matrix_translation", name: "color_matrix_translation",
value: driver.Uniform{ value: graphicsdriver.Uniform{
Float32s: esTranslate[:], Float32s: esTranslate[:],
}, },
typ: shaderir.Type{Main: shaderir.Vec4}, typ: shaderir.Type{Main: shaderir.Vec4},
}) })
} }
if filter != driver.FilterNearest { if filter != graphicsdriver.FilterNearest {
sw, sh := g.images[srcIDs[0]].framebufferSize() sw, sh := g.images[srcIDs[0]].framebufferSize()
g.uniformVars = append(g.uniformVars, uniformVariable{ g.uniformVars = append(g.uniformVars, uniformVariable{
name: "source_size", name: "source_size",
value: driver.Uniform{ value: graphicsdriver.Uniform{
Float32s: []float32{float32(sw), float32(sh)}, Float32s: []float32{float32(sw), float32(sh)},
}, },
typ: shaderir.Type{Main: shaderir.Vec2}, typ: shaderir.Type{Main: shaderir.Vec2},
}) })
} }
if filter == driver.FilterScreen { if filter == graphicsdriver.FilterScreen {
scale := float32(destination.width) / float32(g.images[srcIDs[0]].width) scale := float32(destination.width) / float32(g.images[srcIDs[0]].width)
g.uniformVars = append(g.uniformVars, uniformVariable{ g.uniformVars = append(g.uniformVars, uniformVariable{
name: "scale", name: "scale",
value: driver.Uniform{ value: graphicsdriver.Uniform{
Float32: scale, Float32: scale,
}, },
typ: shaderir.Type{Main: shaderir.Float}, typ: shaderir.Type{Main: shaderir.Float},
@ -340,7 +340,7 @@ func (g *Graphics) DrawTriangles(dstID driver.ImageID, srcIDs [graphics.ShaderIm
var imgs [graphics.ShaderImageNum]textureVariable var imgs [graphics.ShaderImageNum]textureVariable
for i, srcID := range srcIDs { for i, srcID := range srcIDs {
if srcID == driver.InvalidImageID { if srcID == graphicsdriver.InvalidImageID {
continue continue
} }
imgs[i].valid = true imgs[i].valid = true
@ -381,8 +381,8 @@ func (g *Graphics) SetFullscreen(fullscreen bool) {
// Do nothing // Do nothing
} }
func (g *Graphics) FramebufferYDirection() driver.YDirection { func (g *Graphics) FramebufferYDirection() graphicsdriver.YDirection {
return driver.Upward return graphicsdriver.Upward
} }
func (g *Graphics) NeedsRestoring() bool { func (g *Graphics) NeedsRestoring() bool {
@ -405,7 +405,7 @@ func (g *Graphics) MaxImageSize() int {
return g.context.getMaxTextureSize() return g.context.getMaxTextureSize()
} }
func (g *Graphics) NewShader(program *shaderir.Program) (driver.Shader, error) { func (g *Graphics) NewShader(program *shaderir.Program) (graphicsdriver.Shader, error) {
s, err := newShader(g.genNextShaderID(), g, program) s, err := newShader(g.genNextShaderID(), g, program)
if err != nil { if err != nil {
return nil, err return nil, err
@ -416,7 +416,7 @@ func (g *Graphics) NewShader(program *shaderir.Program) (driver.Shader, error) {
func (g *Graphics) addShader(shader *Shader) { func (g *Graphics) addShader(shader *Shader) {
if g.shaders == nil { if g.shaders == nil {
g.shaders = map[driver.ShaderID]*Shader{} g.shaders = map[graphicsdriver.ShaderID]*Shader{}
} }
if _, ok := g.shaders[shader.id]; ok { if _, ok := g.shaders[shader.id]; ok {
panic(fmt.Sprintf("opengl: shader ID %d was already registered", shader.id)) panic(fmt.Sprintf("opengl: shader ID %d was already registered", shader.id))

View File

@ -15,12 +15,12 @@
package opengl package opengl
import ( import (
"github.com/hajimehoshi/ebiten/v2/internal/driver"
"github.com/hajimehoshi/ebiten/v2/internal/graphics" "github.com/hajimehoshi/ebiten/v2/internal/graphics"
"github.com/hajimehoshi/ebiten/v2/internal/graphicsdriver"
) )
type Image struct { type Image struct {
id driver.ImageID id graphicsdriver.ImageID
graphics *Graphics graphics *Graphics
texture textureNative texture textureNative
stencil renderbufferNative stencil renderbufferNative
@ -30,7 +30,7 @@ type Image struct {
screen bool screen bool
} }
func (i *Image) ID() driver.ImageID { func (i *Image) ID() graphicsdriver.ImageID {
return i.id return i.id
} }
@ -118,7 +118,7 @@ func (i *Image) ensureStencilBuffer() error {
return nil return nil
} }
func (i *Image) ReplacePixels(args []*driver.ReplacePixelsArgs) { func (i *Image) ReplacePixels(args []*graphicsdriver.ReplacePixelsArgs) {
if i.screen { if i.screen {
panic("opengl: ReplacePixels cannot be called on the screen, that doesn't have a texture") panic("opengl: ReplacePixels cannot be called on the screen, that doesn't have a texture")
} }

View File

@ -18,8 +18,8 @@ import (
"fmt" "fmt"
"runtime" "runtime"
"github.com/hajimehoshi/ebiten/v2/internal/driver"
"github.com/hajimehoshi/ebiten/v2/internal/graphics" "github.com/hajimehoshi/ebiten/v2/internal/graphics"
"github.com/hajimehoshi/ebiten/v2/internal/graphicsdriver"
"github.com/hajimehoshi/ebiten/v2/internal/shaderir" "github.com/hajimehoshi/ebiten/v2/internal/shaderir"
) )
@ -116,8 +116,8 @@ func init() {
type programKey struct { type programKey struct {
useColorM bool useColorM bool
filter driver.Filter filter graphicsdriver.Filter
address driver.Address address graphicsdriver.Address
} }
// openGLState is a state for // openGLState is a state for
@ -132,7 +132,7 @@ type openGLState struct {
programs map[programKey]program programs map[programKey]program
lastProgram program lastProgram program
lastUniforms map[string]driver.Uniform lastUniforms map[string]graphicsdriver.Uniform
lastActiveTexture int lastActiveTexture int
} }
@ -183,15 +183,15 @@ func (s *openGLState) reset(context *context) error {
defer context.deleteShader(shaderVertexModelviewNative) defer context.deleteShader(shaderVertexModelviewNative)
for _, c := range []bool{false, true} { for _, c := range []bool{false, true} {
for _, a := range []driver.Address{ for _, a := range []graphicsdriver.Address{
driver.AddressClampToZero, graphicsdriver.AddressClampToZero,
driver.AddressRepeat, graphicsdriver.AddressRepeat,
driver.AddressUnsafe, graphicsdriver.AddressUnsafe,
} { } {
for _, f := range []driver.Filter{ for _, f := range []graphicsdriver.Filter{
driver.FilterNearest, graphicsdriver.FilterNearest,
driver.FilterLinear, graphicsdriver.FilterLinear,
driver.FilterScreen, graphicsdriver.FilterScreen,
} { } {
shaderFragmentColorMatrixNative, err := context.newFragmentShader(fragmentShaderStr(c, f, a)) shaderFragmentColorMatrixNative, err := context.newFragmentShader(fragmentShaderStr(c, f, a))
if err != nil { if err != nil {
@ -242,7 +242,7 @@ func areSameFloat32Array(a, b []float32) bool {
type uniformVariable struct { type uniformVariable struct {
name string name string
value driver.Uniform value graphicsdriver.Uniform
typ shaderir.Type typ shaderir.Type
} }
@ -296,7 +296,7 @@ func (g *Graphics) useProgram(program program, uniforms []uniformVariable, textu
// TODO: Remember whether the location is available or not. // TODO: Remember whether the location is available or not.
g.context.uniformFloat(program, u.name, u.value.Float32) g.context.uniformFloat(program, u.name, u.value.Float32)
if g.state.lastUniforms == nil { if g.state.lastUniforms == nil {
g.state.lastUniforms = map[string]driver.Uniform{} g.state.lastUniforms = map[string]graphicsdriver.Uniform{}
} }
g.state.lastUniforms[u.name] = u.value g.state.lastUniforms[u.name] = u.value
} else { } else {
@ -313,7 +313,7 @@ func (g *Graphics) useProgram(program program, uniforms []uniformVariable, textu
} }
g.context.uniformFloats(program, u.name, u.value.Float32s, u.typ) g.context.uniformFloats(program, u.name, u.value.Float32s, u.typ)
if g.state.lastUniforms == nil { if g.state.lastUniforms == nil {
g.state.lastUniforms = map[string]driver.Uniform{} g.state.lastUniforms = map[string]graphicsdriver.Uniform{}
} }
g.state.lastUniforms[u.name] = u.value g.state.lastUniforms[u.name] = u.value
} }

View File

@ -17,20 +17,20 @@ package opengl
import ( import (
"fmt" "fmt"
"github.com/hajimehoshi/ebiten/v2/internal/driver" "github.com/hajimehoshi/ebiten/v2/internal/graphicsdriver"
"github.com/hajimehoshi/ebiten/v2/internal/shaderir" "github.com/hajimehoshi/ebiten/v2/internal/shaderir"
"github.com/hajimehoshi/ebiten/v2/internal/shaderir/glsl" "github.com/hajimehoshi/ebiten/v2/internal/shaderir/glsl"
) )
type Shader struct { type Shader struct {
id driver.ShaderID id graphicsdriver.ShaderID
graphics *Graphics graphics *Graphics
ir *shaderir.Program ir *shaderir.Program
p program p program
} }
func newShader(id driver.ShaderID, graphics *Graphics, program *shaderir.Program) (*Shader, error) { func newShader(id graphicsdriver.ShaderID, graphics *Graphics, program *shaderir.Program) (*Shader, error) {
s := &Shader{ s := &Shader{
id: id, id: id,
graphics: graphics, graphics: graphics,
@ -42,7 +42,7 @@ func newShader(id driver.ShaderID, graphics *Graphics, program *shaderir.Program
return s, nil return s, nil
} }
func (s *Shader) ID() driver.ShaderID { func (s *Shader) ID() graphicsdriver.ShaderID {
return s.id return s.id
} }

View File

@ -20,8 +20,8 @@ import (
"github.com/hajimehoshi/ebiten/v2/internal/affine" "github.com/hajimehoshi/ebiten/v2/internal/affine"
"github.com/hajimehoshi/ebiten/v2/internal/buffered" "github.com/hajimehoshi/ebiten/v2/internal/buffered"
"github.com/hajimehoshi/ebiten/v2/internal/driver"
"github.com/hajimehoshi/ebiten/v2/internal/graphics" "github.com/hajimehoshi/ebiten/v2/internal/graphics"
"github.com/hajimehoshi/ebiten/v2/internal/graphicsdriver"
"github.com/hajimehoshi/ebiten/v2/internal/shaderir" "github.com/hajimehoshi/ebiten/v2/internal/shaderir"
) )
@ -87,14 +87,14 @@ func (m *Mipmap) Pixels(x, y, width, height int) ([]byte, error) {
return m.orig.Pixels(x, y, width, height) return m.orig.Pixels(x, y, width, height)
} }
func (m *Mipmap) DrawTriangles(srcs [graphics.ShaderImageNum]*Mipmap, vertices []float32, indices []uint16, colorm affine.ColorM, mode driver.CompositeMode, filter driver.Filter, address driver.Address, dstRegion, srcRegion driver.Region, subimageOffsets [graphics.ShaderImageNum - 1][2]float32, shader *Shader, uniforms []driver.Uniform, evenOdd bool, canSkipMipmap bool) { func (m *Mipmap) DrawTriangles(srcs [graphics.ShaderImageNum]*Mipmap, vertices []float32, indices []uint16, colorm affine.ColorM, mode graphicsdriver.CompositeMode, filter graphicsdriver.Filter, address graphicsdriver.Address, dstRegion, srcRegion graphicsdriver.Region, subimageOffsets [graphics.ShaderImageNum - 1][2]float32, shader *Shader, uniforms []graphicsdriver.Uniform, evenOdd bool, canSkipMipmap bool) {
if len(indices) == 0 { if len(indices) == 0 {
return return
} }
level := 0 level := 0
// TODO: Do we need to check all the sources' states of being volatile? // TODO: Do we need to check all the sources' states of being volatile?
if !canSkipMipmap && srcs[0] != nil && !srcs[0].volatile && filter != driver.FilterScreen { if !canSkipMipmap && srcs[0] != nil && !srcs[0].volatile && filter != graphicsdriver.FilterScreen {
level = math.MaxInt32 level = math.MaxInt32
for i := 0; i < len(indices)/3; i++ { for i := 0; i < len(indices)/3; i++ {
const n = graphics.VertexFloatNum const n = graphics.VertexFloatNum
@ -176,12 +176,12 @@ func (m *Mipmap) level(level int) *buffered.Image {
var src *buffered.Image var src *buffered.Image
var vs []float32 var vs []float32
var filter driver.Filter var filter graphicsdriver.Filter
switch { switch {
case level == 1: case level == 1:
src = m.orig src = m.orig
vs = graphics.QuadVertices(0, 0, float32(m.width), float32(m.height), 0.5, 0, 0, 0.5, 0, 0, 1, 1, 1, 1) vs = graphics.QuadVertices(0, 0, float32(m.width), float32(m.height), 0.5, 0, 0, 0.5, 0, 0, 1, 1, 1, 1)
filter = driver.FilterLinear filter = graphicsdriver.FilterLinear
case level > 1: case level > 1:
src = m.level(level - 1) src = m.level(level - 1)
if src == nil { if src == nil {
@ -191,7 +191,7 @@ func (m *Mipmap) level(level int) *buffered.Image {
w := sizeForLevel(m.width, level-1) w := sizeForLevel(m.width, level-1)
h := sizeForLevel(m.height, level-1) h := sizeForLevel(m.height, level-1)
vs = graphics.QuadVertices(0, 0, float32(w), float32(h), 0.5, 0, 0, 0.5, 0, 0, 1, 1, 1, 1) vs = graphics.QuadVertices(0, 0, float32(w), float32(h), 0.5, 0, 0, 0.5, 0, 0, 1, 1, 1, 1)
filter = driver.FilterLinear filter = graphicsdriver.FilterLinear
default: default:
panic(fmt.Sprintf("ebiten: invalid level: %d", level)) panic(fmt.Sprintf("ebiten: invalid level: %d", level))
} }
@ -213,13 +213,13 @@ func (m *Mipmap) level(level int) *buffered.Image {
s := buffered.NewImage(w2, h2) s := buffered.NewImage(w2, h2)
s.SetVolatile(m.volatile) s.SetVolatile(m.volatile)
dstRegion := driver.Region{ dstRegion := graphicsdriver.Region{
X: 0, X: 0,
Y: 0, Y: 0,
Width: float32(w2), Width: float32(w2),
Height: float32(h2), Height: float32(h2),
} }
s.DrawTriangles([graphics.ShaderImageNum]*buffered.Image{src}, vs, is, affine.ColorMIdentity{}, driver.CompositeModeCopy, filter, driver.AddressUnsafe, dstRegion, driver.Region{}, [graphics.ShaderImageNum - 1][2]float32{}, nil, nil, false) s.DrawTriangles([graphics.ShaderImageNum]*buffered.Image{src}, vs, is, affine.ColorMIdentity{}, graphicsdriver.CompositeModeCopy, filter, graphicsdriver.AddressUnsafe, dstRegion, graphicsdriver.Region{}, [graphics.ShaderImageNum - 1][2]float32{}, nil, nil, false)
m.setImg(level, s) m.setImg(level, s)
return m.imgs[level] return m.imgs[level]
@ -253,10 +253,10 @@ func (m *Mipmap) disposeMipmaps() {
} }
// mipmapLevel returns an appropriate mipmap level for the given distance. // mipmapLevel returns an appropriate mipmap level for the given distance.
func mipmapLevelFromDistance(dx0, dy0, dx1, dy1, sx0, sy0, sx1, sy1 float32, filter driver.Filter) int { func mipmapLevelFromDistance(dx0, dy0, dx1, dy1, sx0, sy0, sx1, sy1 float32, filter graphicsdriver.Filter) int {
const maxLevel = 6 const maxLevel = 6
if filter == driver.FilterScreen { if filter == graphicsdriver.FilterScreen {
return 0 return 0
} }
@ -277,7 +277,7 @@ func mipmapLevelFromDistance(dx0, dy0, dx1, dy1, sx0, sy0, sx1, sy1 float32, fil
return 0 return 0
} }
if filter != driver.FilterLinear { if filter != graphicsdriver.FilterLinear {
return 0 return 0
} }

View File

@ -19,9 +19,9 @@ import (
"image" "image"
"github.com/hajimehoshi/ebiten/v2/internal/affine" "github.com/hajimehoshi/ebiten/v2/internal/affine"
"github.com/hajimehoshi/ebiten/v2/internal/driver"
"github.com/hajimehoshi/ebiten/v2/internal/graphics" "github.com/hajimehoshi/ebiten/v2/internal/graphics"
"github.com/hajimehoshi/ebiten/v2/internal/graphicscommand" "github.com/hajimehoshi/ebiten/v2/internal/graphicscommand"
"github.com/hajimehoshi/ebiten/v2/internal/graphicsdriver"
) )
type Pixels struct { type Pixels struct {
@ -70,13 +70,13 @@ type drawTrianglesHistoryItem struct {
vertices []float32 vertices []float32
indices []uint16 indices []uint16
colorm affine.ColorM colorm affine.ColorM
mode driver.CompositeMode mode graphicsdriver.CompositeMode
filter driver.Filter filter graphicsdriver.Filter
address driver.Address address graphicsdriver.Address
dstRegion driver.Region dstRegion graphicsdriver.Region
srcRegion driver.Region srcRegion graphicsdriver.Region
shader *Shader shader *Shader
uniforms []driver.Uniform uniforms []graphicsdriver.Uniform
evenOdd bool evenOdd bool
} }
@ -193,13 +193,13 @@ func (i *Image) Extend(width, height int) *Image {
sw, sh := i.image.InternalSize() sw, sh := i.image.InternalSize()
vs := quadVertices(0, 0, float32(sw), float32(sh), 0, 0, float32(sw), float32(sh), 1, 1, 1, 1) vs := quadVertices(0, 0, float32(sw), float32(sh), 0, 0, float32(sw), float32(sh), 1, 1, 1, 1)
is := graphics.QuadIndices() is := graphics.QuadIndices()
dr := driver.Region{ dr := graphicsdriver.Region{
X: 0, X: 0,
Y: 0, Y: 0,
Width: float32(sw), Width: float32(sw),
Height: float32(sh), Height: float32(sh),
} }
newImg.DrawTriangles(srcs, offsets, vs, is, affine.ColorMIdentity{}, driver.CompositeModeCopy, driver.FilterNearest, driver.AddressUnsafe, dr, driver.Region{}, nil, nil, false) newImg.DrawTriangles(srcs, offsets, vs, is, affine.ColorMIdentity{}, graphicsdriver.CompositeModeCopy, graphicsdriver.FilterNearest, graphicsdriver.AddressUnsafe, dr, graphicsdriver.Region{}, nil, nil, false)
// Overwrite the history as if the image newImg is created only by ReplacePixels. Now drawTrianglesHistory // Overwrite the history as if the image newImg is created only by ReplacePixels. Now drawTrianglesHistory
// and basePixels cannot be mixed. // and basePixels cannot be mixed.
@ -256,13 +256,13 @@ func clearImage(i *graphicscommand.Image) {
is := graphics.QuadIndices() is := graphics.QuadIndices()
srcs := [graphics.ShaderImageNum]*graphicscommand.Image{emptyImage.image} srcs := [graphics.ShaderImageNum]*graphicscommand.Image{emptyImage.image}
var offsets [graphics.ShaderImageNum - 1][2]float32 var offsets [graphics.ShaderImageNum - 1][2]float32
dstRegion := driver.Region{ dstRegion := graphicsdriver.Region{
X: 0, X: 0,
Y: 0, Y: 0,
Width: float32(dw), Width: float32(dw),
Height: float32(dh), Height: float32(dh),
} }
i.DrawTriangles(srcs, offsets, vs, is, affine.ColorMIdentity{}, driver.CompositeModeClear, driver.FilterNearest, driver.AddressUnsafe, dstRegion, driver.Region{}, nil, nil, false) i.DrawTriangles(srcs, offsets, vs, is, affine.ColorMIdentity{}, graphicsdriver.CompositeModeClear, graphicsdriver.FilterNearest, graphicsdriver.AddressUnsafe, dstRegion, graphicsdriver.Region{}, nil, nil, false)
} }
// BasePixelsForTesting returns the image's basePixels for testing. // BasePixelsForTesting returns the image's basePixels for testing.
@ -365,7 +365,7 @@ func (i *Image) ReplacePixels(pixels []byte, x, y, width, height int) {
// 5: Color G // 5: Color G
// 6: Color B // 6: Color B
// 7: Color Y // 7: Color Y
func (i *Image) DrawTriangles(srcs [graphics.ShaderImageNum]*Image, offsets [graphics.ShaderImageNum - 1][2]float32, vertices []float32, indices []uint16, colorm affine.ColorM, mode driver.CompositeMode, filter driver.Filter, address driver.Address, dstRegion, srcRegion driver.Region, shader *Shader, uniforms []driver.Uniform, evenOdd bool) { func (i *Image) DrawTriangles(srcs [graphics.ShaderImageNum]*Image, offsets [graphics.ShaderImageNum - 1][2]float32, vertices []float32, indices []uint16, colorm affine.ColorM, mode graphicsdriver.CompositeMode, filter graphicsdriver.Filter, address graphicsdriver.Address, dstRegion, srcRegion graphicsdriver.Region, shader *Shader, uniforms []graphicsdriver.Uniform, evenOdd bool) {
if i.priority { if i.priority {
panic("restorable: DrawTriangles cannot be called on a priority image") panic("restorable: DrawTriangles cannot be called on a priority image")
} }
@ -410,7 +410,7 @@ func (i *Image) DrawTriangles(srcs [graphics.ShaderImageNum]*Image, offsets [gra
} }
// appendDrawTrianglesHistory appends a draw-image history item to the image. // appendDrawTrianglesHistory appends a draw-image history item to the image.
func (i *Image) appendDrawTrianglesHistory(srcs [graphics.ShaderImageNum]*Image, offsets [graphics.ShaderImageNum - 1][2]float32, vertices []float32, indices []uint16, colorm affine.ColorM, mode driver.CompositeMode, filter driver.Filter, address driver.Address, dstRegion, srcRegion driver.Region, shader *Shader, uniforms []driver.Uniform, evenOdd bool) { func (i *Image) appendDrawTrianglesHistory(srcs [graphics.ShaderImageNum]*Image, offsets [graphics.ShaderImageNum - 1][2]float32, vertices []float32, indices []uint16, colorm affine.ColorM, mode graphicsdriver.CompositeMode, filter graphicsdriver.Filter, address graphicsdriver.Address, dstRegion, srcRegion graphicsdriver.Region, shader *Shader, uniforms []graphicsdriver.Uniform, evenOdd bool) {
if i.stale || i.volatile || i.screen { if i.stale || i.volatile || i.screen {
return return
} }

View File

@ -19,8 +19,8 @@ import (
"path/filepath" "path/filepath"
"github.com/hajimehoshi/ebiten/v2/internal/debug" "github.com/hajimehoshi/ebiten/v2/internal/debug"
"github.com/hajimehoshi/ebiten/v2/internal/driver"
"github.com/hajimehoshi/ebiten/v2/internal/graphicscommand" "github.com/hajimehoshi/ebiten/v2/internal/graphicscommand"
"github.com/hajimehoshi/ebiten/v2/internal/graphicsdriver"
) )
// forceRestoring reports whether restoring forcely happens or not. // forceRestoring reports whether restoring forcely happens or not.
@ -112,7 +112,7 @@ func RestoreIfNeeded() error {
} }
err := graphicscommand.ResetGraphicsDriverState() err := graphicscommand.ResetGraphicsDriverState()
if err == driver.GraphicsNotReady { if err == graphicsdriver.GraphicsNotReady {
return nil return nil
} }
if err != nil { if err != nil {

View File

@ -20,8 +20,8 @@ import (
"testing" "testing"
"github.com/hajimehoshi/ebiten/v2/internal/affine" "github.com/hajimehoshi/ebiten/v2/internal/affine"
"github.com/hajimehoshi/ebiten/v2/internal/driver"
"github.com/hajimehoshi/ebiten/v2/internal/graphics" "github.com/hajimehoshi/ebiten/v2/internal/graphics"
"github.com/hajimehoshi/ebiten/v2/internal/graphicsdriver"
"github.com/hajimehoshi/ebiten/v2/internal/restorable" "github.com/hajimehoshi/ebiten/v2/internal/restorable"
t "github.com/hajimehoshi/ebiten/v2/internal/testing" t "github.com/hajimehoshi/ebiten/v2/internal/testing"
) )
@ -132,13 +132,13 @@ func TestRestoreChain(t *testing.T) {
for i := 0; i < num-1; i++ { for i := 0; i < num-1; i++ {
vs := quadVertices(1, 1, 0, 0) vs := quadVertices(1, 1, 0, 0)
is := graphics.QuadIndices() is := graphics.QuadIndices()
dr := driver.Region{ dr := graphicsdriver.Region{
X: 0, X: 0,
Y: 0, Y: 0,
Width: 1, Width: 1,
Height: 1, Height: 1,
} }
imgs[i+1].DrawTriangles([graphics.ShaderImageNum]*restorable.Image{imgs[i]}, [graphics.ShaderImageNum - 1][2]float32{}, vs, is, affine.ColorMIdentity{}, driver.CompositeModeCopy, driver.FilterNearest, driver.AddressUnsafe, dr, driver.Region{}, nil, nil, false) imgs[i+1].DrawTriangles([graphics.ShaderImageNum]*restorable.Image{imgs[i]}, [graphics.ShaderImageNum - 1][2]float32{}, vs, is, affine.ColorMIdentity{}, graphicsdriver.CompositeModeCopy, graphicsdriver.FilterNearest, graphicsdriver.AddressUnsafe, dr, graphicsdriver.Region{}, nil, nil, false)
} }
if err := restorable.ResolveStaleImages(); err != nil { if err := restorable.ResolveStaleImages(); err != nil {
t.Fatal(err) t.Fatal(err)
@ -180,16 +180,16 @@ func TestRestoreChain2(t *testing.T) {
imgs[8].ReplacePixels([]byte{clr8.R, clr8.G, clr8.B, clr8.A}, 0, 0, w, h) imgs[8].ReplacePixels([]byte{clr8.R, clr8.G, clr8.B, clr8.A}, 0, 0, w, h)
is := graphics.QuadIndices() is := graphics.QuadIndices()
dr := driver.Region{ dr := graphicsdriver.Region{
X: 0, X: 0,
Y: 0, Y: 0,
Width: w, Width: w,
Height: h, Height: h,
} }
imgs[8].DrawTriangles([graphics.ShaderImageNum]*restorable.Image{imgs[7]}, [graphics.ShaderImageNum - 1][2]float32{}, quadVertices(w, h, 0, 0), is, affine.ColorMIdentity{}, driver.CompositeModeCopy, driver.FilterNearest, driver.AddressUnsafe, dr, driver.Region{}, nil, nil, false) imgs[8].DrawTriangles([graphics.ShaderImageNum]*restorable.Image{imgs[7]}, [graphics.ShaderImageNum - 1][2]float32{}, quadVertices(w, h, 0, 0), is, affine.ColorMIdentity{}, graphicsdriver.CompositeModeCopy, graphicsdriver.FilterNearest, graphicsdriver.AddressUnsafe, dr, graphicsdriver.Region{}, nil, nil, false)
imgs[9].DrawTriangles([graphics.ShaderImageNum]*restorable.Image{imgs[8]}, [graphics.ShaderImageNum - 1][2]float32{}, quadVertices(w, h, 0, 0), is, affine.ColorMIdentity{}, driver.CompositeModeCopy, driver.FilterNearest, driver.AddressUnsafe, dr, driver.Region{}, nil, nil, false) imgs[9].DrawTriangles([graphics.ShaderImageNum]*restorable.Image{imgs[8]}, [graphics.ShaderImageNum - 1][2]float32{}, quadVertices(w, h, 0, 0), is, affine.ColorMIdentity{}, graphicsdriver.CompositeModeCopy, graphicsdriver.FilterNearest, graphicsdriver.AddressUnsafe, dr, graphicsdriver.Region{}, nil, nil, false)
for i := 0; i < 7; i++ { for i := 0; i < 7; i++ {
imgs[i+1].DrawTriangles([graphics.ShaderImageNum]*restorable.Image{imgs[i]}, [graphics.ShaderImageNum - 1][2]float32{}, quadVertices(w, h, 0, 0), is, affine.ColorMIdentity{}, driver.CompositeModeCopy, driver.FilterNearest, driver.AddressUnsafe, dr, driver.Region{}, nil, nil, false) imgs[i+1].DrawTriangles([graphics.ShaderImageNum]*restorable.Image{imgs[i]}, [graphics.ShaderImageNum - 1][2]float32{}, quadVertices(w, h, 0, 0), is, affine.ColorMIdentity{}, graphicsdriver.CompositeModeCopy, graphicsdriver.FilterNearest, graphicsdriver.AddressUnsafe, dr, graphicsdriver.Region{}, nil, nil, false)
} }
if err := restorable.ResolveStaleImages(); err != nil { if err := restorable.ResolveStaleImages(); err != nil {
@ -229,16 +229,16 @@ func TestRestoreOverrideSource(t *testing.T) {
clr1 := color.RGBA{0x00, 0x00, 0x01, 0xff} clr1 := color.RGBA{0x00, 0x00, 0x01, 0xff}
img1.ReplacePixels([]byte{clr0.R, clr0.G, clr0.B, clr0.A}, 0, 0, w, h) img1.ReplacePixels([]byte{clr0.R, clr0.G, clr0.B, clr0.A}, 0, 0, w, h)
is := graphics.QuadIndices() is := graphics.QuadIndices()
dr := driver.Region{ dr := graphicsdriver.Region{
X: 0, X: 0,
Y: 0, Y: 0,
Width: w, Width: w,
Height: h, Height: h,
} }
img2.DrawTriangles([graphics.ShaderImageNum]*restorable.Image{img1}, [graphics.ShaderImageNum - 1][2]float32{}, quadVertices(w, h, 0, 0), is, affine.ColorMIdentity{}, driver.CompositeModeSourceOver, driver.FilterNearest, driver.AddressUnsafe, dr, driver.Region{}, nil, nil, false) img2.DrawTriangles([graphics.ShaderImageNum]*restorable.Image{img1}, [graphics.ShaderImageNum - 1][2]float32{}, quadVertices(w, h, 0, 0), is, affine.ColorMIdentity{}, graphicsdriver.CompositeModeSourceOver, graphicsdriver.FilterNearest, graphicsdriver.AddressUnsafe, dr, graphicsdriver.Region{}, nil, nil, false)
img3.DrawTriangles([graphics.ShaderImageNum]*restorable.Image{img2}, [graphics.ShaderImageNum - 1][2]float32{}, quadVertices(w, h, 0, 0), is, affine.ColorMIdentity{}, driver.CompositeModeSourceOver, driver.FilterNearest, driver.AddressUnsafe, dr, driver.Region{}, nil, nil, false) img3.DrawTriangles([graphics.ShaderImageNum]*restorable.Image{img2}, [graphics.ShaderImageNum - 1][2]float32{}, quadVertices(w, h, 0, 0), is, affine.ColorMIdentity{}, graphicsdriver.CompositeModeSourceOver, graphicsdriver.FilterNearest, graphicsdriver.AddressUnsafe, dr, graphicsdriver.Region{}, nil, nil, false)
img0.ReplacePixels([]byte{clr1.R, clr1.G, clr1.B, clr1.A}, 0, 0, w, h) img0.ReplacePixels([]byte{clr1.R, clr1.G, clr1.B, clr1.A}, 0, 0, w, h)
img1.DrawTriangles([graphics.ShaderImageNum]*restorable.Image{img0}, [graphics.ShaderImageNum - 1][2]float32{}, quadVertices(w, h, 0, 0), is, affine.ColorMIdentity{}, driver.CompositeModeSourceOver, driver.FilterNearest, driver.AddressUnsafe, dr, driver.Region{}, nil, nil, false) img1.DrawTriangles([graphics.ShaderImageNum]*restorable.Image{img0}, [graphics.ShaderImageNum - 1][2]float32{}, quadVertices(w, h, 0, 0), is, affine.ColorMIdentity{}, graphicsdriver.CompositeModeSourceOver, graphicsdriver.FilterNearest, graphicsdriver.AddressUnsafe, dr, graphicsdriver.Region{}, nil, nil, false)
if err := restorable.ResolveStaleImages(); err != nil { if err := restorable.ResolveStaleImages(); err != nil {
t.Fatal(err) t.Fatal(err)
} }
@ -317,30 +317,30 @@ func TestRestoreComplexGraph(t *testing.T) {
}() }()
vs := quadVertices(w, h, 0, 0) vs := quadVertices(w, h, 0, 0)
is := graphics.QuadIndices() is := graphics.QuadIndices()
dr := driver.Region{ dr := graphicsdriver.Region{
X: 0, X: 0,
Y: 0, Y: 0,
Width: w, Width: w,
Height: h, Height: h,
} }
var offsets [graphics.ShaderImageNum - 1][2]float32 var offsets [graphics.ShaderImageNum - 1][2]float32
img3.DrawTriangles([graphics.ShaderImageNum]*restorable.Image{img0}, offsets, vs, is, affine.ColorMIdentity{}, driver.CompositeModeSourceOver, driver.FilterNearest, driver.AddressUnsafe, dr, driver.Region{}, nil, nil, false) img3.DrawTriangles([graphics.ShaderImageNum]*restorable.Image{img0}, offsets, vs, is, affine.ColorMIdentity{}, graphicsdriver.CompositeModeSourceOver, graphicsdriver.FilterNearest, graphicsdriver.AddressUnsafe, dr, graphicsdriver.Region{}, nil, nil, false)
vs = quadVertices(w, h, 1, 0) vs = quadVertices(w, h, 1, 0)
img3.DrawTriangles([graphics.ShaderImageNum]*restorable.Image{img1}, offsets, vs, is, affine.ColorMIdentity{}, driver.CompositeModeSourceOver, driver.FilterNearest, driver.AddressUnsafe, dr, driver.Region{}, nil, nil, false) img3.DrawTriangles([graphics.ShaderImageNum]*restorable.Image{img1}, offsets, vs, is, affine.ColorMIdentity{}, graphicsdriver.CompositeModeSourceOver, graphicsdriver.FilterNearest, graphicsdriver.AddressUnsafe, dr, graphicsdriver.Region{}, nil, nil, false)
vs = quadVertices(w, h, 1, 0) vs = quadVertices(w, h, 1, 0)
img4.DrawTriangles([graphics.ShaderImageNum]*restorable.Image{img1}, offsets, vs, is, affine.ColorMIdentity{}, driver.CompositeModeSourceOver, driver.FilterNearest, driver.AddressUnsafe, dr, driver.Region{}, nil, nil, false) img4.DrawTriangles([graphics.ShaderImageNum]*restorable.Image{img1}, offsets, vs, is, affine.ColorMIdentity{}, graphicsdriver.CompositeModeSourceOver, graphicsdriver.FilterNearest, graphicsdriver.AddressUnsafe, dr, graphicsdriver.Region{}, nil, nil, false)
vs = quadVertices(w, h, 2, 0) vs = quadVertices(w, h, 2, 0)
img4.DrawTriangles([graphics.ShaderImageNum]*restorable.Image{img2}, offsets, vs, is, affine.ColorMIdentity{}, driver.CompositeModeSourceOver, driver.FilterNearest, driver.AddressUnsafe, dr, driver.Region{}, nil, nil, false) img4.DrawTriangles([graphics.ShaderImageNum]*restorable.Image{img2}, offsets, vs, is, affine.ColorMIdentity{}, graphicsdriver.CompositeModeSourceOver, graphicsdriver.FilterNearest, graphicsdriver.AddressUnsafe, dr, graphicsdriver.Region{}, nil, nil, false)
vs = quadVertices(w, h, 0, 0) vs = quadVertices(w, h, 0, 0)
img5.DrawTriangles([graphics.ShaderImageNum]*restorable.Image{img3}, offsets, vs, is, affine.ColorMIdentity{}, driver.CompositeModeSourceOver, driver.FilterNearest, driver.AddressUnsafe, dr, driver.Region{}, nil, nil, false) img5.DrawTriangles([graphics.ShaderImageNum]*restorable.Image{img3}, offsets, vs, is, affine.ColorMIdentity{}, graphicsdriver.CompositeModeSourceOver, graphicsdriver.FilterNearest, graphicsdriver.AddressUnsafe, dr, graphicsdriver.Region{}, nil, nil, false)
vs = quadVertices(w, h, 0, 0) vs = quadVertices(w, h, 0, 0)
img6.DrawTriangles([graphics.ShaderImageNum]*restorable.Image{img3}, offsets, vs, is, affine.ColorMIdentity{}, driver.CompositeModeSourceOver, driver.FilterNearest, driver.AddressUnsafe, dr, driver.Region{}, nil, nil, false) img6.DrawTriangles([graphics.ShaderImageNum]*restorable.Image{img3}, offsets, vs, is, affine.ColorMIdentity{}, graphicsdriver.CompositeModeSourceOver, graphicsdriver.FilterNearest, graphicsdriver.AddressUnsafe, dr, graphicsdriver.Region{}, nil, nil, false)
vs = quadVertices(w, h, 1, 0) vs = quadVertices(w, h, 1, 0)
img6.DrawTriangles([graphics.ShaderImageNum]*restorable.Image{img4}, offsets, vs, is, affine.ColorMIdentity{}, driver.CompositeModeSourceOver, driver.FilterNearest, driver.AddressUnsafe, dr, driver.Region{}, nil, nil, false) img6.DrawTriangles([graphics.ShaderImageNum]*restorable.Image{img4}, offsets, vs, is, affine.ColorMIdentity{}, graphicsdriver.CompositeModeSourceOver, graphicsdriver.FilterNearest, graphicsdriver.AddressUnsafe, dr, graphicsdriver.Region{}, nil, nil, false)
vs = quadVertices(w, h, 0, 0) vs = quadVertices(w, h, 0, 0)
img7.DrawTriangles([graphics.ShaderImageNum]*restorable.Image{img2}, offsets, vs, is, affine.ColorMIdentity{}, driver.CompositeModeSourceOver, driver.FilterNearest, driver.AddressUnsafe, dr, driver.Region{}, nil, nil, false) img7.DrawTriangles([graphics.ShaderImageNum]*restorable.Image{img2}, offsets, vs, is, affine.ColorMIdentity{}, graphicsdriver.CompositeModeSourceOver, graphicsdriver.FilterNearest, graphicsdriver.AddressUnsafe, dr, graphicsdriver.Region{}, nil, nil, false)
vs = quadVertices(w, h, 2, 0) vs = quadVertices(w, h, 2, 0)
img7.DrawTriangles([graphics.ShaderImageNum]*restorable.Image{img3}, offsets, vs, is, affine.ColorMIdentity{}, driver.CompositeModeSourceOver, driver.FilterNearest, driver.AddressUnsafe, dr, driver.Region{}, nil, nil, false) img7.DrawTriangles([graphics.ShaderImageNum]*restorable.Image{img3}, offsets, vs, is, affine.ColorMIdentity{}, graphicsdriver.CompositeModeSourceOver, graphicsdriver.FilterNearest, graphicsdriver.AddressUnsafe, dr, graphicsdriver.Region{}, nil, nil, false)
if err := restorable.ResolveStaleImages(); err != nil { if err := restorable.ResolveStaleImages(); err != nil {
t.Fatal(err) t.Fatal(err)
} }
@ -432,14 +432,14 @@ func TestRestoreRecursive(t *testing.T) {
img0.Dispose() img0.Dispose()
}() }()
is := graphics.QuadIndices() is := graphics.QuadIndices()
dr := driver.Region{ dr := graphicsdriver.Region{
X: 0, X: 0,
Y: 0, Y: 0,
Width: w, Width: w,
Height: h, Height: h,
} }
img1.DrawTriangles([graphics.ShaderImageNum]*restorable.Image{img0}, [graphics.ShaderImageNum - 1][2]float32{}, quadVertices(w, h, 1, 0), is, affine.ColorMIdentity{}, driver.CompositeModeSourceOver, driver.FilterNearest, driver.AddressUnsafe, dr, driver.Region{}, nil, nil, false) img1.DrawTriangles([graphics.ShaderImageNum]*restorable.Image{img0}, [graphics.ShaderImageNum - 1][2]float32{}, quadVertices(w, h, 1, 0), is, affine.ColorMIdentity{}, graphicsdriver.CompositeModeSourceOver, graphicsdriver.FilterNearest, graphicsdriver.AddressUnsafe, dr, graphicsdriver.Region{}, nil, nil, false)
img0.DrawTriangles([graphics.ShaderImageNum]*restorable.Image{img1}, [graphics.ShaderImageNum - 1][2]float32{}, quadVertices(w, h, 1, 0), is, affine.ColorMIdentity{}, driver.CompositeModeSourceOver, driver.FilterNearest, driver.AddressUnsafe, dr, driver.Region{}, nil, nil, false) img0.DrawTriangles([graphics.ShaderImageNum]*restorable.Image{img1}, [graphics.ShaderImageNum - 1][2]float32{}, quadVertices(w, h, 1, 0), is, affine.ColorMIdentity{}, graphicsdriver.CompositeModeSourceOver, graphicsdriver.FilterNearest, graphicsdriver.AddressUnsafe, dr, graphicsdriver.Region{}, nil, nil, false)
if err := restorable.ResolveStaleImages(); err != nil { if err := restorable.ResolveStaleImages(); err != nil {
t.Fatal(err) t.Fatal(err)
} }
@ -533,13 +533,13 @@ func TestDrawTrianglesAndReplacePixels(t *testing.T) {
vs := quadVertices(1, 1, 0, 0) vs := quadVertices(1, 1, 0, 0)
is := graphics.QuadIndices() is := graphics.QuadIndices()
dr := driver.Region{ dr := graphicsdriver.Region{
X: 0, X: 0,
Y: 0, Y: 0,
Width: 2, Width: 2,
Height: 1, Height: 1,
} }
img1.DrawTriangles([graphics.ShaderImageNum]*restorable.Image{img0}, [graphics.ShaderImageNum - 1][2]float32{}, vs, is, affine.ColorMIdentity{}, driver.CompositeModeCopy, driver.FilterNearest, driver.AddressUnsafe, dr, driver.Region{}, nil, nil, false) img1.DrawTriangles([graphics.ShaderImageNum]*restorable.Image{img0}, [graphics.ShaderImageNum - 1][2]float32{}, vs, is, affine.ColorMIdentity{}, graphicsdriver.CompositeModeCopy, graphicsdriver.FilterNearest, graphicsdriver.AddressUnsafe, dr, graphicsdriver.Region{}, nil, nil, false)
img1.ReplacePixels([]byte{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff}, 0, 0, 2, 1) img1.ReplacePixels([]byte{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff}, 0, 0, 2, 1)
if err := restorable.ResolveStaleImages(); err != nil { if err := restorable.ResolveStaleImages(); err != nil {
@ -576,14 +576,14 @@ func TestDispose(t *testing.T) {
defer img2.Dispose() defer img2.Dispose()
is := graphics.QuadIndices() is := graphics.QuadIndices()
dr := driver.Region{ dr := graphicsdriver.Region{
X: 0, X: 0,
Y: 0, Y: 0,
Width: 1, Width: 1,
Height: 1, Height: 1,
} }
img1.DrawTriangles([graphics.ShaderImageNum]*restorable.Image{img2}, [graphics.ShaderImageNum - 1][2]float32{}, quadVertices(1, 1, 0, 0), is, affine.ColorMIdentity{}, driver.CompositeModeCopy, driver.FilterNearest, driver.AddressUnsafe, dr, driver.Region{}, nil, nil, false) img1.DrawTriangles([graphics.ShaderImageNum]*restorable.Image{img2}, [graphics.ShaderImageNum - 1][2]float32{}, quadVertices(1, 1, 0, 0), is, affine.ColorMIdentity{}, graphicsdriver.CompositeModeCopy, graphicsdriver.FilterNearest, graphicsdriver.AddressUnsafe, dr, graphicsdriver.Region{}, nil, nil, false)
img0.DrawTriangles([graphics.ShaderImageNum]*restorable.Image{img1}, [graphics.ShaderImageNum - 1][2]float32{}, quadVertices(1, 1, 0, 0), is, affine.ColorMIdentity{}, driver.CompositeModeCopy, driver.FilterNearest, driver.AddressUnsafe, dr, driver.Region{}, nil, nil, false) img0.DrawTriangles([graphics.ShaderImageNum]*restorable.Image{img1}, [graphics.ShaderImageNum - 1][2]float32{}, quadVertices(1, 1, 0, 0), is, affine.ColorMIdentity{}, graphicsdriver.CompositeModeCopy, graphicsdriver.FilterNearest, graphicsdriver.AddressUnsafe, dr, graphicsdriver.Region{}, nil, nil, false)
img1.Dispose() img1.Dispose()
if err := restorable.ResolveStaleImages(); err != nil { if err := restorable.ResolveStaleImages(); err != nil {
@ -691,13 +691,13 @@ func TestReplacePixelsOnly(t *testing.T) {
vs := quadVertices(1, 1, 0, 0) vs := quadVertices(1, 1, 0, 0)
is := graphics.QuadIndices() is := graphics.QuadIndices()
dr := driver.Region{ dr := graphicsdriver.Region{
X: 0, X: 0,
Y: 0, Y: 0,
Width: 1, Width: 1,
Height: 1, Height: 1,
} }
img1.DrawTriangles([graphics.ShaderImageNum]*restorable.Image{img0}, [graphics.ShaderImageNum - 1][2]float32{}, vs, is, affine.ColorMIdentity{}, driver.CompositeModeCopy, driver.FilterNearest, driver.AddressUnsafe, dr, driver.Region{}, nil, nil, false) img1.DrawTriangles([graphics.ShaderImageNum]*restorable.Image{img0}, [graphics.ShaderImageNum - 1][2]float32{}, vs, is, affine.ColorMIdentity{}, graphicsdriver.CompositeModeCopy, graphicsdriver.FilterNearest, graphicsdriver.AddressUnsafe, dr, graphicsdriver.Region{}, nil, nil, false)
img0.ReplacePixels([]byte{5, 6, 7, 8}, 0, 0, 1, 1) img0.ReplacePixels([]byte{5, 6, 7, 8}, 0, 0, 1, 1)
// BasePixelsForTesting is available without GPU accessing. // BasePixelsForTesting is available without GPU accessing.
@ -751,13 +751,13 @@ func TestReadPixelsFromVolatileImage(t *testing.T) {
src.ReplacePixels(pix, 0, 0, w, h) src.ReplacePixels(pix, 0, 0, w, h)
vs := quadVertices(1, 1, 0, 0) vs := quadVertices(1, 1, 0, 0)
is := graphics.QuadIndices() is := graphics.QuadIndices()
dr := driver.Region{ dr := graphicsdriver.Region{
X: 0, X: 0,
Y: 0, Y: 0,
Width: w, Width: w,
Height: h, Height: h,
} }
dst.DrawTriangles([graphics.ShaderImageNum]*restorable.Image{src}, [graphics.ShaderImageNum - 1][2]float32{}, vs, is, affine.ColorMIdentity{}, driver.CompositeModeCopy, driver.FilterNearest, driver.AddressUnsafe, dr, driver.Region{}, nil, nil, false) dst.DrawTriangles([graphics.ShaderImageNum]*restorable.Image{src}, [graphics.ShaderImageNum - 1][2]float32{}, vs, is, affine.ColorMIdentity{}, graphicsdriver.CompositeModeCopy, graphicsdriver.FilterNearest, graphicsdriver.AddressUnsafe, dr, graphicsdriver.Region{}, nil, nil, false)
// Read the pixels. If the implementation is correct, dst tries to read its pixels from GPU due to being // Read the pixels. If the implementation is correct, dst tries to read its pixels from GPU due to being
// stale. // stale.
@ -778,13 +778,13 @@ func TestAllowReplacePixelsAfterDrawTriangles(t *testing.T) {
vs := quadVertices(w, h, 0, 0) vs := quadVertices(w, h, 0, 0)
is := graphics.QuadIndices() is := graphics.QuadIndices()
dr := driver.Region{ dr := graphicsdriver.Region{
X: 0, X: 0,
Y: 0, Y: 0,
Width: w, Width: w,
Height: h, Height: h,
} }
dst.DrawTriangles([graphics.ShaderImageNum]*restorable.Image{src}, [graphics.ShaderImageNum - 1][2]float32{}, vs, is, affine.ColorMIdentity{}, driver.CompositeModeSourceOver, driver.FilterNearest, driver.AddressUnsafe, dr, driver.Region{}, nil, nil, false) dst.DrawTriangles([graphics.ShaderImageNum]*restorable.Image{src}, [graphics.ShaderImageNum - 1][2]float32{}, vs, is, affine.ColorMIdentity{}, graphicsdriver.CompositeModeSourceOver, graphicsdriver.FilterNearest, graphicsdriver.AddressUnsafe, dr, graphicsdriver.Region{}, nil, nil, false)
dst.ReplacePixels(make([]byte, 4*w*h), 0, 0, w, h) dst.ReplacePixels(make([]byte, 4*w*h), 0, 0, w, h)
// ReplacePixels for a whole image doesn't panic. // ReplacePixels for a whole image doesn't panic.
} }
@ -802,13 +802,13 @@ func TestDisallowReplacePixelsForPartAfterDrawTriangles(t *testing.T) {
vs := quadVertices(w, h, 0, 0) vs := quadVertices(w, h, 0, 0)
is := graphics.QuadIndices() is := graphics.QuadIndices()
dr := driver.Region{ dr := graphicsdriver.Region{
X: 0, X: 0,
Y: 0, Y: 0,
Width: w, Width: w,
Height: h, Height: h,
} }
dst.DrawTriangles([graphics.ShaderImageNum]*restorable.Image{src}, [graphics.ShaderImageNum - 1][2]float32{}, vs, is, affine.ColorMIdentity{}, driver.CompositeModeSourceOver, driver.FilterNearest, driver.AddressUnsafe, dr, driver.Region{}, nil, nil, false) dst.DrawTriangles([graphics.ShaderImageNum]*restorable.Image{src}, [graphics.ShaderImageNum - 1][2]float32{}, vs, is, affine.ColorMIdentity{}, graphicsdriver.CompositeModeSourceOver, graphicsdriver.FilterNearest, graphicsdriver.AddressUnsafe, dr, graphicsdriver.Region{}, nil, nil, false)
dst.ReplacePixels(make([]byte, 4), 0, 0, 1, 1) dst.ReplacePixels(make([]byte, 4), 0, 0, 1, 1)
} }
@ -879,13 +879,13 @@ func TestMutateSlices(t *testing.T) {
vs := quadVertices(w, h, 0, 0) vs := quadVertices(w, h, 0, 0)
is := make([]uint16, len(graphics.QuadIndices())) is := make([]uint16, len(graphics.QuadIndices()))
copy(is, graphics.QuadIndices()) copy(is, graphics.QuadIndices())
dr := driver.Region{ dr := graphicsdriver.Region{
X: 0, X: 0,
Y: 0, Y: 0,
Width: w, Width: w,
Height: h, Height: h,
} }
dst.DrawTriangles([graphics.ShaderImageNum]*restorable.Image{src}, [graphics.ShaderImageNum - 1][2]float32{}, vs, is, affine.ColorMIdentity{}, driver.CompositeModeSourceOver, driver.FilterNearest, driver.AddressUnsafe, dr, driver.Region{}, nil, nil, false) dst.DrawTriangles([graphics.ShaderImageNum]*restorable.Image{src}, [graphics.ShaderImageNum - 1][2]float32{}, vs, is, affine.ColorMIdentity{}, graphicsdriver.CompositeModeSourceOver, graphicsdriver.FilterNearest, graphicsdriver.AddressUnsafe, dr, graphicsdriver.Region{}, nil, nil, false)
for i := range vs { for i := range vs {
vs[i] = 0 vs[i] = 0
} }

View File

@ -19,8 +19,8 @@ import (
"testing" "testing"
"github.com/hajimehoshi/ebiten/v2/internal/affine" "github.com/hajimehoshi/ebiten/v2/internal/affine"
"github.com/hajimehoshi/ebiten/v2/internal/driver"
"github.com/hajimehoshi/ebiten/v2/internal/graphics" "github.com/hajimehoshi/ebiten/v2/internal/graphics"
"github.com/hajimehoshi/ebiten/v2/internal/graphicsdriver"
"github.com/hajimehoshi/ebiten/v2/internal/restorable" "github.com/hajimehoshi/ebiten/v2/internal/restorable"
etesting "github.com/hajimehoshi/ebiten/v2/internal/testing" etesting "github.com/hajimehoshi/ebiten/v2/internal/testing"
) )
@ -44,13 +44,13 @@ func clearImage(img *restorable.Image, w, h int) {
dx1, dy1, sx1, sy1, 0, 0, 0, 0, dx1, dy1, sx1, sy1, 0, 0, 0, 0,
} }
is := graphics.QuadIndices() is := graphics.QuadIndices()
dr := driver.Region{ dr := graphicsdriver.Region{
X: 0, X: 0,
Y: 0, Y: 0,
Width: float32(w), Width: float32(w),
Height: float32(h), Height: float32(h),
} }
img.DrawTriangles([graphics.ShaderImageNum]*restorable.Image{emptyImage}, [graphics.ShaderImageNum - 1][2]float32{}, vs, is, affine.ColorMIdentity{}, driver.CompositeModeClear, driver.FilterNearest, driver.AddressUnsafe, dr, driver.Region{}, nil, nil, false) img.DrawTriangles([graphics.ShaderImageNum]*restorable.Image{emptyImage}, [graphics.ShaderImageNum - 1][2]float32{}, vs, is, affine.ColorMIdentity{}, graphicsdriver.CompositeModeClear, graphicsdriver.FilterNearest, graphicsdriver.AddressUnsafe, dr, graphicsdriver.Region{}, nil, nil, false)
} }
func TestShader(t *testing.T) { func TestShader(t *testing.T) {
@ -59,13 +59,13 @@ func TestShader(t *testing.T) {
ir := etesting.ShaderProgramFill(0xff, 0, 0, 0xff) ir := etesting.ShaderProgramFill(0xff, 0, 0, 0xff)
s := restorable.NewShader(&ir) s := restorable.NewShader(&ir)
dr := driver.Region{ dr := graphicsdriver.Region{
X: 0, X: 0,
Y: 0, Y: 0,
Width: 1, Width: 1,
Height: 1, Height: 1,
} }
img.DrawTriangles([graphics.ShaderImageNum]*restorable.Image{}, [graphics.ShaderImageNum - 1][2]float32{}, quadVertices(1, 1, 0, 0), graphics.QuadIndices(), nil, driver.CompositeModeCopy, driver.FilterNearest, driver.AddressUnsafe, dr, driver.Region{}, s, nil, false) img.DrawTriangles([graphics.ShaderImageNum]*restorable.Image{}, [graphics.ShaderImageNum - 1][2]float32{}, quadVertices(1, 1, 0, 0), graphics.QuadIndices(), nil, graphicsdriver.CompositeModeCopy, graphicsdriver.FilterNearest, graphicsdriver.AddressUnsafe, dr, graphicsdriver.Region{}, s, nil, false)
if err := restorable.ResolveStaleImages(); err != nil { if err := restorable.ResolveStaleImages(); err != nil {
t.Fatal(err) t.Fatal(err)
@ -95,13 +95,13 @@ func TestShaderChain(t *testing.T) {
ir := etesting.ShaderProgramImages(1) ir := etesting.ShaderProgramImages(1)
s := restorable.NewShader(&ir) s := restorable.NewShader(&ir)
for i := 0; i < num-1; i++ { for i := 0; i < num-1; i++ {
dr := driver.Region{ dr := graphicsdriver.Region{
X: 0, X: 0,
Y: 0, Y: 0,
Width: 1, Width: 1,
Height: 1, Height: 1,
} }
imgs[i+1].DrawTriangles([graphics.ShaderImageNum]*restorable.Image{imgs[i]}, [graphics.ShaderImageNum - 1][2]float32{}, quadVertices(1, 1, 0, 0), graphics.QuadIndices(), nil, driver.CompositeModeCopy, driver.FilterNearest, driver.AddressUnsafe, dr, driver.Region{}, s, nil, false) imgs[i+1].DrawTriangles([graphics.ShaderImageNum]*restorable.Image{imgs[i]}, [graphics.ShaderImageNum - 1][2]float32{}, quadVertices(1, 1, 0, 0), graphics.QuadIndices(), nil, graphicsdriver.CompositeModeCopy, graphicsdriver.FilterNearest, graphicsdriver.AddressUnsafe, dr, graphicsdriver.Region{}, s, nil, false)
} }
if err := restorable.ResolveStaleImages(); err != nil { if err := restorable.ResolveStaleImages(); err != nil {
@ -134,13 +134,13 @@ func TestShaderMultipleSources(t *testing.T) {
ir := etesting.ShaderProgramImages(3) ir := etesting.ShaderProgramImages(3)
s := restorable.NewShader(&ir) s := restorable.NewShader(&ir)
var offsets [graphics.ShaderImageNum - 1][2]float32 var offsets [graphics.ShaderImageNum - 1][2]float32
dr := driver.Region{ dr := graphicsdriver.Region{
X: 0, X: 0,
Y: 0, Y: 0,
Width: 1, Width: 1,
Height: 1, Height: 1,
} }
dst.DrawTriangles(srcs, offsets, quadVertices(1, 1, 0, 0), graphics.QuadIndices(), nil, driver.CompositeModeCopy, driver.FilterNearest, driver.AddressUnsafe, dr, driver.Region{}, s, nil, false) dst.DrawTriangles(srcs, offsets, quadVertices(1, 1, 0, 0), graphics.QuadIndices(), nil, graphicsdriver.CompositeModeCopy, graphicsdriver.FilterNearest, graphicsdriver.AddressUnsafe, dr, graphicsdriver.Region{}, s, nil, false)
// Clear one of the sources after DrawTriangles. dst should not be affected. // Clear one of the sources after DrawTriangles. dst should not be affected.
clearImage(srcs[0], 1, 1) clearImage(srcs[0], 1, 1)
@ -176,13 +176,13 @@ func TestShaderMultipleSourcesOnOneTexture(t *testing.T) {
{1, 0}, {1, 0},
{2, 0}, {2, 0},
} }
dr := driver.Region{ dr := graphicsdriver.Region{
X: 0, X: 0,
Y: 0, Y: 0,
Width: 1, Width: 1,
Height: 1, Height: 1,
} }
dst.DrawTriangles(srcs, offsets, quadVertices(1, 1, 0, 0), graphics.QuadIndices(), nil, driver.CompositeModeCopy, driver.FilterNearest, driver.AddressUnsafe, dr, driver.Region{}, s, nil, false) dst.DrawTriangles(srcs, offsets, quadVertices(1, 1, 0, 0), graphics.QuadIndices(), nil, graphicsdriver.CompositeModeCopy, graphicsdriver.FilterNearest, graphicsdriver.AddressUnsafe, dr, graphicsdriver.Region{}, s, nil, false)
// Clear one of the sources after DrawTriangles. dst should not be affected. // Clear one of the sources after DrawTriangles. dst should not be affected.
clearImage(srcs[0], 3, 1) clearImage(srcs[0], 3, 1)
@ -207,13 +207,13 @@ func TestShaderDispose(t *testing.T) {
ir := etesting.ShaderProgramFill(0xff, 0, 0, 0xff) ir := etesting.ShaderProgramFill(0xff, 0, 0, 0xff)
s := restorable.NewShader(&ir) s := restorable.NewShader(&ir)
dr := driver.Region{ dr := graphicsdriver.Region{
X: 0, X: 0,
Y: 0, Y: 0,
Width: 1, Width: 1,
Height: 1, Height: 1,
} }
img.DrawTriangles([graphics.ShaderImageNum]*restorable.Image{}, [graphics.ShaderImageNum - 1][2]float32{}, quadVertices(1, 1, 0, 0), graphics.QuadIndices(), nil, driver.CompositeModeCopy, driver.FilterNearest, driver.AddressUnsafe, dr, driver.Region{}, s, nil, false) img.DrawTriangles([graphics.ShaderImageNum]*restorable.Image{}, [graphics.ShaderImageNum - 1][2]float32{}, quadVertices(1, 1, 0, 0), graphics.QuadIndices(), nil, graphicsdriver.CompositeModeCopy, graphicsdriver.FilterNearest, graphicsdriver.AddressUnsafe, 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 invalidates all the images using this shader i.e., all the images become
// stale. // stale.

View File

@ -34,13 +34,13 @@ package ui
import "C" import "C"
import ( import (
"github.com/hajimehoshi/ebiten/v2/internal/driver" "github.com/hajimehoshi/ebiten/v2/internal/graphicsdriver"
"github.com/hajimehoshi/ebiten/v2/internal/graphicsdriver/metal" "github.com/hajimehoshi/ebiten/v2/internal/graphicsdriver/metal"
"github.com/hajimehoshi/ebiten/v2/internal/graphicsdriver/metal/mtl" "github.com/hajimehoshi/ebiten/v2/internal/graphicsdriver/metal/mtl"
"github.com/hajimehoshi/ebiten/v2/internal/graphicsdriver/opengl" "github.com/hajimehoshi/ebiten/v2/internal/graphicsdriver/opengl"
) )
var graphics driver.Graphics var graphics graphicsdriver.Graphics
func supportsMetal() bool { func supportsMetal() bool {
// On old mac devices like iMac 2011, Metal is not supported (#779). // On old mac devices like iMac 2011, Metal is not supported (#779).
@ -64,6 +64,6 @@ func init() {
graphics = opengl.Get() graphics = opengl.Get()
} }
func Graphics() driver.Graphics { func Graphics() graphicsdriver.Graphics {
return graphics return graphics
} }

View File

@ -22,12 +22,12 @@ package ui
import ( import (
"fmt" "fmt"
"github.com/hajimehoshi/ebiten/v2/internal/driver" "github.com/hajimehoshi/ebiten/v2/internal/graphicsdriver"
"github.com/hajimehoshi/ebiten/v2/internal/graphicsdriver/metal" "github.com/hajimehoshi/ebiten/v2/internal/graphicsdriver/metal"
"github.com/hajimehoshi/ebiten/v2/internal/graphicsdriver/metal/mtl" "github.com/hajimehoshi/ebiten/v2/internal/graphicsdriver/metal/mtl"
) )
func Graphics() driver.Graphics { func Graphics() graphicsdriver.Graphics {
if _, err := mtl.CreateSystemDefaultDevice(); err != nil { if _, err := mtl.CreateSystemDefaultDevice(); err != nil {
panic(fmt.Sprintf("mobile: mtl.CreateSystemDefaultDevice failed on iOS: %v", err)) panic(fmt.Sprintf("mobile: mtl.CreateSystemDefaultDevice failed on iOS: %v", err))
} }

View File

@ -18,10 +18,10 @@
package ui package ui
import ( import (
"github.com/hajimehoshi/ebiten/v2/internal/driver" "github.com/hajimehoshi/ebiten/v2/internal/graphicsdriver"
"github.com/hajimehoshi/ebiten/v2/internal/graphicsdriver/opengl" "github.com/hajimehoshi/ebiten/v2/internal/graphicsdriver/opengl"
) )
func Graphics() driver.Graphics { func Graphics() graphicsdriver.Graphics {
return opengl.Get() return opengl.Get()
} }

View File

@ -21,8 +21,8 @@ import (
"go/token" "go/token"
"strings" "strings"
"github.com/hajimehoshi/ebiten/v2/internal/driver"
"github.com/hajimehoshi/ebiten/v2/internal/graphics" "github.com/hajimehoshi/ebiten/v2/internal/graphics"
"github.com/hajimehoshi/ebiten/v2/internal/graphicsdriver"
"github.com/hajimehoshi/ebiten/v2/internal/mipmap" "github.com/hajimehoshi/ebiten/v2/internal/mipmap"
"github.com/hajimehoshi/ebiten/v2/internal/shader" "github.com/hajimehoshi/ebiten/v2/internal/shader"
"github.com/hajimehoshi/ebiten/v2/internal/shaderir" "github.com/hajimehoshi/ebiten/v2/internal/shaderir"
@ -173,7 +173,7 @@ func (s *Shader) Dispose() {
s.shader = nil s.shader = nil
} }
func (s *Shader) convertUniforms(uniforms map[string]interface{}) []driver.Uniform { func (s *Shader) convertUniforms(uniforms map[string]interface{}) []graphicsdriver.Uniform {
type index struct { type index struct {
resultIndex int resultIndex int
shaderUniformIndex int shaderUniformIndex int
@ -192,16 +192,16 @@ func (s *Shader) convertUniforms(uniforms map[string]interface{}) []driver.Unifo
idx++ idx++
} }
us := make([]driver.Uniform, len(names)) us := make([]graphicsdriver.Uniform, len(names))
for name, idx := range names { for name, idx := range names {
if v, ok := uniforms[name]; ok { if v, ok := uniforms[name]; ok {
switch v := v.(type) { switch v := v.(type) {
case float32: case float32:
us[idx.resultIndex] = driver.Uniform{ us[idx.resultIndex] = graphicsdriver.Uniform{
Float32: v, Float32: v,
} }
case []float32: case []float32:
us[idx.resultIndex] = driver.Uniform{ us[idx.resultIndex] = graphicsdriver.Uniform{
Float32s: v, Float32s: v,
} }
default: default:
@ -219,14 +219,14 @@ func (s *Shader) convertUniforms(uniforms map[string]interface{}) []driver.Unifo
return us return us
} }
func zeroUniformValue(name string, t shaderir.Type) driver.Uniform { func zeroUniformValue(name string, t shaderir.Type) graphicsdriver.Uniform {
switch t.Main { switch t.Main {
case shaderir.Float: case shaderir.Float:
return driver.Uniform{ return graphicsdriver.Uniform{
Float32: 0, Float32: 0,
} }
case shaderir.Array, shaderir.Vec2, shaderir.Vec3, shaderir.Vec4, shaderir.Mat2, shaderir.Mat3, shaderir.Mat4: case shaderir.Array, shaderir.Vec2, shaderir.Vec3, shaderir.Vec4, shaderir.Mat2, shaderir.Mat3, shaderir.Mat4:
return driver.Uniform{ return graphicsdriver.Uniform{
Float32s: make([]float32, t.FloatNum()), Float32s: make([]float32, t.FloatNum()),
} }
default: default:

View File

@ -23,8 +23,8 @@ import (
"github.com/hajimehoshi/ebiten/v2/internal/buffered" "github.com/hajimehoshi/ebiten/v2/internal/buffered"
"github.com/hajimehoshi/ebiten/v2/internal/clock" "github.com/hajimehoshi/ebiten/v2/internal/clock"
"github.com/hajimehoshi/ebiten/v2/internal/debug" "github.com/hajimehoshi/ebiten/v2/internal/debug"
"github.com/hajimehoshi/ebiten/v2/internal/driver"
"github.com/hajimehoshi/ebiten/v2/internal/graphics" "github.com/hajimehoshi/ebiten/v2/internal/graphics"
"github.com/hajimehoshi/ebiten/v2/internal/graphicsdriver"
"github.com/hajimehoshi/ebiten/v2/internal/hooks" "github.com/hajimehoshi/ebiten/v2/internal/hooks"
"github.com/hajimehoshi/ebiten/v2/internal/ui" "github.com/hajimehoshi/ebiten/v2/internal/ui"
) )
@ -209,11 +209,11 @@ func (c *uiContext) updateFrameImpl(updateCount int) error {
s := c.screenScale(ui.Get().DeviceScaleFactor()) s := c.screenScale(ui.Get().DeviceScaleFactor())
switch vd := ui.Graphics().FramebufferYDirection(); vd { switch vd := ui.Graphics().FramebufferYDirection(); vd {
case driver.Upward: case graphicsdriver.Upward:
op.GeoM.Scale(s, -s) op.GeoM.Scale(s, -s)
_, h := c.offscreen.Size() _, h := c.offscreen.Size()
op.GeoM.Translate(0, float64(h)*s) op.GeoM.Translate(0, float64(h)*s)
case driver.Downward: case graphicsdriver.Downward:
op.GeoM.Scale(s, s) op.GeoM.Scale(s, s)
default: default:
panic(fmt.Sprintf("ebiten: invalid v-direction: %d", vd)) panic(fmt.Sprintf("ebiten: invalid v-direction: %d", vd))