mth/ebiten
1
0
Fork 0
mirror of https://github.com/hajimehoshi/ebiten.git synced 2024-09-19 21:02:18 +02:00
Code Issues Packages Projects Releases Wiki Activity

Remove dot imports from tests - Remove dot imports (#1837)

Browse Source 
Closes #1824
This commit is contained in:
r3vit 2021-10-02 12:58:48 +02:00 committed by GitHub
parent 3c8c17eace
commit 57c45a13e4
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
22 changed files with 928 additions and 928 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

30
audio/audio_test.go
View File

@ -20,17 +20,17 @@ import (
"testing"
"time"
. "github.com/hajimehoshi/ebiten/v2/audio"
"github.com/hajimehoshi/ebiten/v2/audio"
)
var context *Context
var context *audio.Context
func setup() {
context = NewContext(44100)
context = audio.NewContext(44100)
}
func teardown() {
ResetContextForTesting()
audio.ResetContextForTesting()
context = nil
}
@ -39,14 +39,14 @@ func TestGC(t *testing.T) {
setup()
defer teardown()
p, _ := NewPlayer(context, bytes.NewReader(make([]byte, 4)))
got := PlayersNumForTesting()
p, _ := audio.NewPlayer(context, bytes.NewReader(make([]byte, 4)))
got := audio.PlayersNumForTesting()
if want := 0; got != want {
t.Errorf("PlayersNum(): got: %d, want: %d", got, want)
}
p.Play()
got = PlayersNumForTesting()
got = audio.PlayersNumForTesting()
if want := 1; got != want {
t.Errorf("PlayersNum() after Play: got: %d, want: %d", got, want)
}
@ -56,11 +56,11 @@ func TestGC(t *testing.T) {
runtime.GC()
for i := 0; i < 10; i++ {
got = PlayersNumForTesting()
got = audio.PlayersNumForTesting()
if want := 0; got == want {
return
}
if err := UpdateForTesting(); err != nil {
if err := audio.UpdateForTesting(); err != nil {
t.Error(err)
}
// 200[ms] should be enough all the bytes are consumed.
@ -76,24 +76,24 @@ func TestSameSourcePlayers(t *testing.T) {
defer teardown()
src := bytes.NewReader(make([]byte, 4))
p0, err := NewPlayer(context, src)
p0, err := audio.NewPlayer(context, src)
if err != nil {
t.Fatal(err)
}
p1, err := NewPlayer(context, src)
p1, err := audio.NewPlayer(context, src)
if err != nil {
t.Fatal(err)
}
// As the player does not play yet, error doesn't happen.
if err := UpdateForTesting(); err != nil {
if err := audio.UpdateForTesting(); err != nil {
t.Error(err)
}
p0.Play()
p1.Play()
if err := UpdateForTesting(); err == nil {
if err := audio.UpdateForTesting(); err == nil {
t.Errorf("got: nil, want: an error")
}
}
@ -103,7 +103,7 @@ func TestPauseBeforeInit(t *testing.T) {
defer teardown()
src := bytes.NewReader(make([]byte, 4))
p, err := NewPlayer(context, src)
p, err := audio.NewPlayer(context, src)
if err != nil {
t.Fatal(err)
}
@ -112,7 +112,7 @@ func TestPauseBeforeInit(t *testing.T) {
p.Pause()
p.Play()
if err := UpdateForTesting(); err != nil {
if err := audio.UpdateForTesting(); err != nil {
t.Error(err)
}
}

6
audio/internal/convert/float32_test.go
View File

@ -20,7 +20,7 @@ import (
"math"
"testing"
. "github.com/hajimehoshi/ebiten/v2/audio/internal/convert"
"github.com/hajimehoshi/ebiten/v2/audio/internal/convert"
)
type f32reader struct {
@ -37,7 +37,7 @@ func (f *f32reader) Read(buf []float32) (int, error) {
return n, nil
}
func newFloat32Reader(data []float32) Float32Reader {
func newFloat32Reader(data []float32) convert.Float32Reader {
return &f32reader{data: data}
}
@ -82,7 +82,7 @@ func TestFloat32Reader(t *testing.T) {
}
for i, c := range cases {
r := NewReaderFromFloat32Reader(newFloat32Reader(c.In))
r := convert.NewReaderFromFloat32Reader(newFloat32Reader(c.In))
got := []byte{}
for {

4
audio/internal/convert/resampling_test.go
View File

@ -20,7 +20,7 @@ import (
"math"
"testing"
. "github.com/hajimehoshi/ebiten/v2/audio/internal/convert"
"github.com/hajimehoshi/ebiten/v2/audio/internal/convert"
)
func soundAt(timeInSecond float64) float64 {
@ -69,7 +69,7 @@ func TestResampling(t *testing.T) {
}
for _, c := range cases {
inB := newSoundBytes(c.In)
outS := NewResampling(bytes.NewReader(inB), int64(len(inB)), c.In, c.Out)
outS := convert.NewResampling(bytes.NewReader(inB), int64(len(inB)), c.In, c.Out)
gotB, err := ioutil.ReadAll(outS)
if err != nil {
t.Fatal(err)

12
audio/loop_test.go
View File

@ -20,7 +20,7 @@ import (
"math"
"testing"
. "github.com/hajimehoshi/ebiten/v2/audio"
"github.com/hajimehoshi/ebiten/v2/audio"
)
func TestInfiniteLoop(t *testing.T) {
@ -32,7 +32,7 @@ func TestInfiniteLoop(t *testing.T) {
for i := range src {
src[i] = indexToByte(i)
}
l := NewInfiniteLoop(bytes.NewReader(src), int64(len(src)))
l := audio.NewInfiniteLoop(bytes.NewReader(src), int64(len(src)))
buf := make([]byte, len(src)*4)
if _, err := io.ReadFull(l, buf); err != nil {
@ -94,8 +94,8 @@ func TestInfiniteLoopWithIntro(t *testing.T) {
for i := range src {
src[i] = indexToByte(i)
}
srcInf := NewInfiniteLoop(bytes.NewReader(src), srcLength)
l := NewInfiniteLoopWithIntro(srcInf, introLength, loopLength)
srcInf := audio.NewInfiniteLoop(bytes.NewReader(src), srcLength)
l := audio.NewInfiniteLoopWithIntro(srcInf, introLength, loopLength)
buf := make([]byte, srcLength*4)
if _, err := io.ReadFull(l, buf); err != nil {
@ -151,7 +151,7 @@ func TestInfiniteLoopWithIntro(t *testing.T) {
func TestInfiniteLoopWithIncompleteSize(t *testing.T) {
// s1 should work as if 4092 is given.
s1 := NewInfiniteLoop(bytes.NewReader(make([]byte, 4096)), 4095)
s1 := audio.NewInfiniteLoop(bytes.NewReader(make([]byte, 4096)), 4095)
n1, err := s1.Seek(4093, io.SeekStart)
if err != nil {
t.Error(err)
@ -161,7 +161,7 @@ func TestInfiniteLoopWithIncompleteSize(t *testing.T) {
}
// s2 should work as if 2044 and 2044 are given.
s2 := NewInfiniteLoopWithIntro(bytes.NewReader(make([]byte, 4096)), 2047, 2046)
s2 := audio.NewInfiniteLoopWithIntro(bytes.NewReader(make([]byte, 4096)), 2047, 2046)
n2, err := s2.Seek(4093, io.SeekStart)
if err != nil {
t.Error(err)

6
audio/vorbis/vorbis_test.go
View File

@ -21,7 +21,7 @@ import (
"github.com/jfreymuth/oggvorbis"
"github.com/hajimehoshi/ebiten/v2/audio"
. "github.com/hajimehoshi/ebiten/v2/audio/vorbis"
"github.com/hajimehoshi/ebiten/v2/audio/vorbis"
)
var audioContext = audio.NewContext(44100)
@ -29,7 +29,7 @@ var audioContext = audio.NewContext(44100)
func TestMono(t *testing.T) {
bs := test_mono_ogg
s, err := DecodeWithSampleRate(audioContext.SampleRate(), bytes.NewReader(bs))
s, err := vorbis.DecodeWithSampleRate(audioContext.SampleRate(), bytes.NewReader(bs))
if err != nil {
t.Fatal(err)
}
@ -55,7 +55,7 @@ func TestMono(t *testing.T) {
func TestTooShort(t *testing.T) {
bs := test_tooshort_ogg
s, err := DecodeWithSampleRate(audioContext.SampleRate(), bytes.NewReader(bs))
s, err := vorbis.DecodeWithSampleRate(audioContext.SampleRate(), bytes.NewReader(bs))
if err != nil {
t.Fatal(err)
}

36
colorm_test.go
View File

@ -19,13 +19,13 @@ import (
"math"
"testing"
. "github.com/hajimehoshi/ebiten/v2"
"github.com/hajimehoshi/ebiten/v2"
)
func TestColorMInit(t *testing.T) {
var m ColorM
for i := 0; i < ColorMDim-1; i++ {
for j := 0; j < ColorMDim; j++ {
var m ebiten.ColorM
for i := 0; i < ebiten.ColorMDim-1; i++ {
for j := 0; j < ebiten.ColorMDim; j++ {
got := m.Element(i, j)
want := 0.0
if i == j {
@ -38,8 +38,8 @@ func TestColorMInit(t *testing.T) {
}
m.SetElement(0, 0, 1)
for i := 0; i < ColorMDim-1; i++ {
for j := 0; j < ColorMDim; j++ {
for i := 0; i < ebiten.ColorMDim-1; i++ {
for j := 0; j < ebiten.ColorMDim; j++ {
got := m.Element(i, j)
want := 0.0
if i == j {
@ -53,7 +53,7 @@ func TestColorMInit(t *testing.T) {
}
func TestColorMAssign(t *testing.T) {
m := ColorM{}
m := ebiten.ColorM{}
m.SetElement(0, 0, 1)
m2 := m
m.SetElement(0, 0, 0)
@ -71,7 +71,7 @@ func TestColorMTranslate(t *testing.T) {
{0, 0, 1, 0, 2.5},
{0, 0, 0, 1, 3.5},
}
m := ColorM{}
m := ebiten.ColorM{}
m.Translate(0.5, 1.5, 2.5, 3.5)
for i := 0; i < 4; i++ {
for j := 0; j < 5; j++ {
@ -91,7 +91,7 @@ func TestColorMScale(t *testing.T) {
{0, 0, 2.5, 0, 0},
{0, 0, 0, 3.5, 0},
}
m := ColorM{}
m := ebiten.ColorM{}
m.Scale(0.5, 1.5, 2.5, 3.5)
for i := 0; i < 4; i++ {
for j := 0; j < 5; j++ {
@ -111,7 +111,7 @@ func TestColorMTranslateAndScale(t *testing.T) {
{0, 0, 1, 0, 0},
{0, 0, 0, 0.5, 0.5},
}
m := ColorM{}
m := ebiten.ColorM{}
m.Translate(0, 0, 0, 1)
m.Scale(1, 1, 1, 0.5)
for i := 0; i < 4; i++ {
@ -132,7 +132,7 @@ func TestColorMMonochrome(t *testing.T) {
{0.2990, 0.5870, 0.1140, 0, 0},
{0, 0, 0, 1, 0},
}
m := ColorM{}
m := ebiten.ColorM{}
m.ChangeHSV(0, 0, 1)
for i := 0; i < 4; i++ {
for j := 0; j < 5; j++ {
@ -152,7 +152,7 @@ func TestColorMConcatSelf(t *testing.T) {
{30, 43, 51, 39, 34},
{25, 37, 39, 46, 36},
}
m := ColorM{}
m := ebiten.ColorM{}
for i := 0; i < 4; i++ {
for j := 0; j < 5; j++ {
m.SetElement(i, j, float64((i+j)%5+1))
@ -178,23 +178,23 @@ func absDiffU32(x, y uint32) uint32 {
}
func TestColorMApply(t *testing.T) {
mono := ColorM{}
mono := ebiten.ColorM{}
mono.ChangeHSV(0, 0, 1)
shiny := ColorM{}
shiny := ebiten.ColorM{}
shiny.Translate(1, 1, 1, 0)
shift := ColorM{}
shift := ebiten.ColorM{}
shift.Translate(0.5, 0.5, 0.5, 0.5)
cases := []struct {
ColorM ColorM
ColorM ebiten.ColorM
In color.Color
Out color.Color
Delta uint32
}{
{
ColorM: ColorM{},
ColorM: ebiten.ColorM{},
In: color.RGBA{1, 2, 3, 4},
Out: color.RGBA{1, 2, 3, 4},
Delta: 0x101,
@ -237,7 +237,7 @@ func TestColorMApply(t *testing.T) {
// #1765
func TestColorMConcat(t *testing.T) {
var a, b ColorM
var a, b ebiten.ColorM
a.SetElement(1, 2, -1)
a.Concat(b)
if got, want := a.Element(1, 2), -1.0; got != want {

36
examples/2048/2048/tile_test.go
View File

@ -15,28 +15,28 @@
package twenty48_test
import (
. "github.com/hajimehoshi/ebiten/v2/examples/2048/2048"
"github.com/hajimehoshi/ebiten/v2/examples/2048/2048"
"fmt"
"testing"
)
func cellsToTiles(cells []int, size int) map[*Tile]struct{} {
tiles := map[*Tile]struct{}{}
func cellsToTiles(cells []int, size int) map[*twenty48.Tile]struct{} {
tiles := map[*twenty48.Tile]struct{}{}
for j := 0; j < size; j++ {
for i := 0; i < size; i++ {
c := cells[i+j*size]
if c == 0 {
continue
}
t := NewTile(c, i, j)
t := twenty48.NewTile(c, i, j)
tiles[t] = struct{}{}
}
}
return tiles
}
func tilesToCells(tiles map[*Tile]struct{}, size int) ([]int, []int) {
func tilesToCells(tiles map[*twenty48.Tile]struct{}, size int) ([]int, []int) {
cells := make([]int, size*size)
nextCells := make([]int, size*size)
for t := range tiles {
@ -58,12 +58,12 @@ func tilesToCells(tiles map[*Tile]struct{}, size int) ([]int, []int) {
func TestMoveTiles(t *testing.T) {
const size = 4
testCases := []struct {
Dir Dir
Dir twenty48.Dir
Input []int
Want []int
}{
{
Dir: DirUp,
Dir: twenty48.DirUp,
Input: []int{
0, 0, 0, 0,
0, 0, 0, 0,
@ -78,7 +78,7 @@ func TestMoveTiles(t *testing.T) {
},
},
{
Dir: DirRight,
Dir: twenty48.DirRight,
Input: []int{
2, 0, 0, 0,
0, 2, 0, 0,
@ -93,7 +93,7 @@ func TestMoveTiles(t *testing.T) {
},
},
{
Dir: DirUp,
Dir: twenty48.DirUp,
Input: []int{
2, 0, 0, 0,
0, 2, 0, 0,
@ -108,7 +108,7 @@ func TestMoveTiles(t *testing.T) {
},
},
{
Dir: DirLeft,
Dir: twenty48.DirLeft,
Input: []int{
0, 2, 2, 2,
0, 0, 0, 0,
@ -123,7 +123,7 @@ func TestMoveTiles(t *testing.T) {
},
},
{
Dir: DirRight,
Dir: twenty48.DirRight,
Input: []int{
0, 0, 0, 2,
0, 0, 2, 2,
@ -138,7 +138,7 @@ func TestMoveTiles(t *testing.T) {
},
},
{
Dir: DirLeft,
Dir: twenty48.DirLeft,
Input: []int{
0, 0, 0, 2,
0, 0, 2, 2,
@ -153,7 +153,7 @@ func TestMoveTiles(t *testing.T) {
},
},
{
Dir: DirRight,
Dir: twenty48.DirRight,
Input: []int{
4, 8, 8, 4,
8, 8, 4, 4,
@ -168,7 +168,7 @@ func TestMoveTiles(t *testing.T) {
},
},
{
Dir: DirDown,
Dir: twenty48.DirDown,
Input: []int{
4, 8, 8, 4,
8, 8, 4, 4,
@ -183,7 +183,7 @@ func TestMoveTiles(t *testing.T) {
},
},
{
Dir: DirLeft,
Dir: twenty48.DirLeft,
Input: []int{
4, 8, 8, 4,
8, 8, 4, 4,
@ -198,7 +198,7 @@ func TestMoveTiles(t *testing.T) {
},
},
{
Dir: DirUp,
Dir: twenty48.DirUp,
Input: []int{
4, 8, 8, 4,
8, 8, 4, 4,
@ -213,7 +213,7 @@ func TestMoveTiles(t *testing.T) {
},
},
{
Dir: DirUp,
Dir: twenty48.DirUp,
Input: []int{
2, 4, 2, 4,
4, 2, 4, 2,
@ -231,7 +231,7 @@ func TestMoveTiles(t *testing.T) {
for _, test := range testCases {
want, _ := tilesToCells(cellsToTiles(test.Want, size), size)
tiles := cellsToTiles(test.Input, size)
moved := MoveTiles(tiles, size, test.Dir)
moved := twenty48.MoveTiles(tiles, size, test.Dir)
input, got := tilesToCells(tiles, size)
if !moved {
got = input

68
geom_test.go
View File

@ -19,13 +19,13 @@ import (
"math"
"testing"
. "github.com/hajimehoshi/ebiten/v2"
"github.com/hajimehoshi/ebiten/v2"
)
func TestGeoMInit(t *testing.T) {
var m GeoM
for i := 0; i < GeoMDim-1; i++ {
for j := 0; j < GeoMDim; j++ {
var m ebiten.GeoM
for i := 0; i < ebiten.GeoMDim-1; i++ {
for j := 0; j < ebiten.GeoMDim; j++ {
got := m.Element(i, j)
want := 0.0
if i == j {
@ -39,7 +39,7 @@ func TestGeoMInit(t *testing.T) {
}
func TestGeoMAssign(t *testing.T) {
m := GeoM{}
m := ebiten.GeoM{}
m.SetElement(0, 0, 1)
m2 := m
m.SetElement(0, 0, 0)
@ -51,9 +51,9 @@ func TestGeoMAssign(t *testing.T) {
}
func TestGeoMConcat(t *testing.T) {
matrix1 := GeoM{}
matrix1 := ebiten.GeoM{}
matrix1.Scale(2, 2)
matrix2 := GeoM{}
matrix2 := ebiten.GeoM{}
matrix2.Translate(1, 1)
matrix3 := matrix1
@ -93,7 +93,7 @@ func TestGeoMConcat(t *testing.T) {
}
func TestGeoMConcatSelf(t *testing.T) {
m := GeoM{}
m := ebiten.GeoM{}
m.SetElement(0, 0, 1)
m.SetElement(0, 1, 2)
m.SetElement(0, 2, 3)
@ -117,7 +117,7 @@ func TestGeoMConcatSelf(t *testing.T) {
}
}
func geoMToString(g GeoM) string {
func geoMToString(g ebiten.GeoM) string {
a := g.Element(0, 0)
b := g.Element(0, 1)
c := g.Element(1, 0)
@ -128,26 +128,26 @@ func geoMToString(g GeoM) string {
}
func TestGeoMApply(t *testing.T) {
trans := GeoM{}
trans := ebiten.GeoM{}
trans.Translate(1, 2)
scale := GeoM{}
scale := ebiten.GeoM{}
scale.Scale(1.5, 2.5)
cpx := GeoM{}
cpx := ebiten.GeoM{}
cpx.Rotate(math.Pi)
cpx.Scale(1.5, 2.5)
cpx.Translate(-2, -3)
cases := []struct {
GeoM GeoM
GeoM ebiten.GeoM
InX float64
InY float64
OutX float64
OutY float64
}{
{
GeoM: GeoM{},
GeoM: ebiten.GeoM{},
InX: 3.14159,
InY: 2.81828,
OutX: 3.14159,
@ -187,30 +187,30 @@ func TestGeoMApply(t *testing.T) {
}
func TestGeoMIsInvert(t *testing.T) {
zero := GeoM{}
zero := ebiten.GeoM{}
zero.Scale(0, 0)
trans := GeoM{}
trans := ebiten.GeoM{}
trans.Translate(1, 2)
scale := GeoM{}
scale := ebiten.GeoM{}
scale.Scale(1.5, 2.5)
cpx := GeoM{}
cpx := ebiten.GeoM{}
cpx.Rotate(math.Pi)
cpx.Scale(1.5, 2.5)
cpx.Translate(-2, -3)
cpx2 := GeoM{}
cpx2 := ebiten.GeoM{}
cpx2.Scale(2, 3)
cpx2.Rotate(0.234)
cpx2.Translate(100, 100)
skew := GeoM{}
skew := ebiten.GeoM{}
skew.Skew(1, 1)
cases := []struct {
GeoM GeoM
GeoM ebiten.GeoM
Invertible bool
}{
{
@ -218,7 +218,7 @@ func TestGeoMIsInvert(t *testing.T) {
Invertible: false,
},
{
GeoM: GeoM{},
GeoM: ebiten.GeoM{},
Invertible: true,
},
{
@ -286,8 +286,8 @@ func TestGeoMIsInvert(t *testing.T) {
}
}
func newGeoM(a, b, c, d, tx, ty float64) GeoM {
outp := GeoM{}
func newGeoM(a, b, c, d, tx, ty float64) ebiten.GeoM {
outp := ebiten.GeoM{}
outp.SetElement(0, 0, a)
outp.SetElement(0, 1, b)
outp.SetElement(0, 2, tx)
@ -298,7 +298,7 @@ func newGeoM(a, b, c, d, tx, ty float64) GeoM {
}
func TestGeomSkew(t *testing.T) {
testSkew := func(skewX, skewY float64, input, expected GeoM) {
testSkew := func(skewX, skewY float64, input, expected ebiten.GeoM) {
input.Skew(skewX, skewY)
for i := 0; i < 2; i++ {
for j := 0; j < 3; j++ {
@ -313,15 +313,15 @@ func TestGeomSkew(t *testing.T) {
}
// skewX = 0.25
expectedX := newGeoM(1, math.Tan(0.25), math.Tan(0), 1, 0, 0)
testSkew(0.25, 0, GeoM{}, expectedX)
testSkew(0.25, 0, ebiten.GeoM{}, expectedX)
// skewY = 0.25
expectedY := newGeoM(1, math.Tan(0), math.Tan(0.5), 1, 0, 0)
testSkew(0, 0.5, GeoM{}, expectedY)
testSkew(0, 0.5, ebiten.GeoM{}, expectedY)
// skewX, skewY = 0.3, 0.8
expectedXY := newGeoM(1, math.Tan(0.3), math.Tan(0.8), 1, 0, 0)
testSkew(0.3, 0.8, GeoM{}, expectedXY)
testSkew(0.3, 0.8, ebiten.GeoM{}, expectedXY)
// skewX, skewY = 0.4, -1.8 ; b, c = 2, 3
expectedOffDiag := newGeoM(1+3*math.Tan(0.4), 2+math.Tan(0.4), 3+math.Tan(-1.8), 1+2*math.Tan(-1.8), 0, 0)
@ -336,13 +336,13 @@ func TestGeomSkew(t *testing.T) {
func TestGeoMEquals(t *testing.T) {
tests := []struct {
a GeoM
b GeoM
a ebiten.GeoM
b ebiten.GeoM
want bool
}{
{
a: GeoM{},
b: GeoM{},
a: ebiten.GeoM{},
b: ebiten.GeoM{},
want: true,
},
{
@ -366,9 +366,9 @@ func TestGeoMEquals(t *testing.T) {
}
func BenchmarkGeoM(b *testing.B) {
var m GeoM
var m ebiten.GeoM
for i := 0; i < b.N; i++ {
m = GeoM{}
m = ebiten.GeoM{}
m.Translate(10, 20)
m.Scale(2, 3)
m.Rotate(math.Pi / 2)

448
image_test.go
View File

File diff suppressed because it is too large Load Diff

10
imagetobytes_test.go
View File

@ -21,7 +21,7 @@ import (
"image/color/palette"
"testing"
. "github.com/hajimehoshi/ebiten/v2"
"github.com/hajimehoshi/ebiten/v2"
)
func TestImageToBytes(t *testing.T) {
@ -93,7 +93,7 @@ func TestImageToBytes(t *testing.T) {
},
}
for i, c := range cases {
got := ImageToBytes(c.In)
got := ebiten.ImageToBytes(c.In)
want := c.Out
if !bytes.Equal(got, want) {
t.Errorf("Test %d: got: %v, want: %v", i, got, want)
@ -105,7 +105,7 @@ func BenchmarkImageToBytesRGBA(b *testing.B) {
img := image.NewRGBA(image.Rect(0, 0, 4096, 4096))
b.ResetTimer()
for i := 0; i < b.N; i++ {
ImageToBytes(img)
ebiten.ImageToBytes(img)
}
}
@ -113,7 +113,7 @@ func BenchmarkImageToBytesNRGBA(b *testing.B) {
img := image.NewNRGBA(image.Rect(0, 0, 4096, 4096))
b.ResetTimer()
for i := 0; i < b.N; i++ {
ImageToBytes(img)
ebiten.ImageToBytes(img)
}
}
@ -121,6 +121,6 @@ func BenchmarkImageToBytesPaletted(b *testing.B) {
img := image.NewPaletted(image.Rect(0, 0, 4096, 4096), palette.Plan9)
b.ResetTimer()
for i := 0; i < b.N; i++ {
ImageToBytes(img)
ebiten.ImageToBytes(img)
}
}

116
internal/affine/colorm_test.go
View File

@ -19,25 +19,25 @@ import (
"math/rand"
"testing"
. "github.com/hajimehoshi/ebiten/v2/internal/affine"
"github.com/hajimehoshi/ebiten/v2/internal/affine"
)
func TestColorMScale(t *testing.T) {
cases := []struct {
In ColorM
Out ColorM
In affine.ColorM
Out affine.ColorM
}{
{
ColorMIdentity{},
ColorMIdentity{}.Scale(0.25, 0.5, 0.75, 1),
affine.ColorMIdentity{},
affine.ColorMIdentity{}.Scale(0.25, 0.5, 0.75, 1),
},
{
ColorMIdentity{}.Scale(0.5, 0.5, 0.5, 0.8),
ColorMIdentity{}.Scale(0.125, 0.25, 0.375, 0.8),
affine.ColorMIdentity{}.Scale(0.5, 0.5, 0.5, 0.8),
affine.ColorMIdentity{}.Scale(0.125, 0.25, 0.375, 0.8),
},
{
ColorMIdentity{}.Translate(0, 0, 0, 0),
ColorMIdentity{}.Scale(0.25, 0.5, 0.75, 1),
affine.ColorMIdentity{}.Translate(0, 0, 0, 0),
affine.ColorMIdentity{}.Scale(0.25, 0.5, 0.75, 1),
},
}
for _, c := range cases {
@ -51,51 +51,51 @@ func TestColorMScale(t *testing.T) {
func TestColorMScaleOnly(t *testing.T) {
cases := []struct {
In ColorM
In affine.ColorM
Out bool
}{
{
ColorMIdentity{},
affine.ColorMIdentity{},
true,
},
{
ColorMIdentity{}.Translate(0, 0, 0, 0),
affine.ColorMIdentity{}.Translate(0, 0, 0, 0),
true,
},
{
ColorMIdentity{}.Translate(1, 0, 0, 0),
affine.ColorMIdentity{}.Translate(1, 0, 0, 0),
false,
},
{
ColorMIdentity{}.Translate(0, 0, 0, -1),
affine.ColorMIdentity{}.Translate(0, 0, 0, -1),
false,
},
{
ColorMIdentity{}.Scale(1, 1, 1, 1),
affine.ColorMIdentity{}.Scale(1, 1, 1, 1),
true,
},
{
ColorMIdentity{}.Scale(0, 0, 0, 0),
affine.ColorMIdentity{}.Scale(0, 0, 0, 0),
true,
},
{
ColorMIdentity{}.Scale(0.1, 0.2, 0.3, 0.4),
affine.ColorMIdentity{}.Scale(0.1, 0.2, 0.3, 0.4),
true,
},
{
ColorMIdentity{}.Scale(0.1, 0.2, 0.3, 0.4).Translate(1, 0, 0, 0),
affine.ColorMIdentity{}.Scale(0.1, 0.2, 0.3, 0.4).Translate(1, 0, 0, 0),
false,
},
{
ChangeHSV(ColorMIdentity{}, math.Pi/2, 0.5, 0.5),
affine.ChangeHSV(affine.ColorMIdentity{}, math.Pi/2, 0.5, 0.5),
false,
},
{
ColorMSetElement(ColorMIdentity{}, 0, 0, 2),
affine.ColorMSetElement(affine.ColorMIdentity{}, 0, 0, 2),
true,
},
{
ColorMSetElement(ColorMIdentity{}, 0, 1, 2),
affine.ColorMSetElement(affine.ColorMIdentity{}, 0, 1, 2),
false,
},
}
@ -109,22 +109,22 @@ func TestColorMScaleOnly(t *testing.T) {
}
func TestColorMIsInvertible(t *testing.T) {
var m ColorM = ColorMIdentity{}
m = ColorMSetElement(m, 1, 0, .5)
m = ColorMSetElement(m, 1, 1, .5)
m = ColorMSetElement(m, 1, 2, .5)
m = ColorMSetElement(m, 1, 3, .5)
m = ColorMSetElement(m, 1, 4, .5)
var m affine.ColorM = affine.ColorMIdentity{}
m = affine.ColorMSetElement(m, 1, 0, .5)
m = affine.ColorMSetElement(m, 1, 1, .5)
m = affine.ColorMSetElement(m, 1, 2, .5)
m = affine.ColorMSetElement(m, 1, 3, .5)
m = affine.ColorMSetElement(m, 1, 4, .5)
var cidentity ColorM = ColorMIdentity{}
var cinvalid ColorM = ColorMIdentity{}
cinvalid = ColorMSetElement(cinvalid, 0, 0, 0)
cinvalid = ColorMSetElement(cinvalid, 1, 1, 0)
cinvalid = ColorMSetElement(cinvalid, 2, 2, 0)
cinvalid = ColorMSetElement(cinvalid, 3, 3, 0)
var cidentity affine.ColorM = affine.ColorMIdentity{}
var cinvalid affine.ColorM = affine.ColorMIdentity{}
cinvalid = affine.ColorMSetElement(cinvalid, 0, 0, 0)
cinvalid = affine.ColorMSetElement(cinvalid, 1, 1, 0)
cinvalid = affine.ColorMSetElement(cinvalid, 2, 2, 0)
cinvalid = affine.ColorMSetElement(cinvalid, 3, 3, 0)
cases := []struct {
In ColorM
In affine.ColorM
Out bool
}{
{
@ -149,11 +149,11 @@ func TestColorMIsInvertible(t *testing.T) {
}
}
func arrayToColorM(es [4][5]float32) ColorM {
var a ColorM = ColorMIdentity{}
func arrayToColorM(es [4][5]float32) affine.ColorM {
var a affine.ColorM = affine.ColorMIdentity{}
for j := 0; j < 5; j++ {
for i := 0; i < 4; i++ {
a = ColorMSetElement(a, i, j, es[i][j])
a = affine.ColorMSetElement(a, i, j, es[i][j])
}
}
return a
@ -166,7 +166,7 @@ func abs(x float32) float32 {
return x
}
func equalWithDelta(a, b ColorM, delta float32) bool {
func equalWithDelta(a, b affine.ColorM, delta float32) bool {
for j := 0; j < 5; j++ {
for i := 0; i < 4; i++ {
ea := a.At(i, j)
@ -181,12 +181,12 @@ func equalWithDelta(a, b ColorM, delta float32) bool {
func TestColorMInvert(t *testing.T) {
cases := []struct {
In ColorM
Out ColorM
In affine.ColorM
Out affine.ColorM
}{
{
In: ColorMIdentity{},
Out: ColorMIdentity{},
In: affine.ColorMIdentity{},
Out: affine.ColorMIdentity{},
},
{
In: arrayToColorM([4][5]float32{
@ -203,7 +203,7 @@ func TestColorMInvert(t *testing.T) {
}),
},
{
In: ColorMIdentity{}.Scale(1, 2, 4, 8),
In: affine.ColorMIdentity{}.Scale(1, 2, 4, 8),
Out: arrayToColorM([4][5]float32{
{1, 0, 0, 0, 0},
{0, 0.5, 0, 0, 0},
@ -252,7 +252,7 @@ func BenchmarkColorMInvert(b *testing.B) {
r := rand.Float32
b.StopTimer()
var m ColorM = ColorMIdentity{}
var m affine.ColorM = affine.ColorMIdentity{}
for m.IsIdentity() || !m.IsInvertible() {
m = arrayToColorM([4][5]float32{
{r(), r(), r(), r(), r() * 10},
@ -270,24 +270,24 @@ func BenchmarkColorMInvert(b *testing.B) {
func TestColorMConcat(t *testing.T) {
cases := []struct {
In0 ColorM
In1 ColorM
Out ColorM
In0 affine.ColorM
In1 affine.ColorM
Out affine.ColorM
}{
{
ColorMIdentity{},
ColorMIdentity{},
ColorMIdentity{},
affine.ColorMIdentity{},
affine.ColorMIdentity{},
affine.ColorMIdentity{},
},
{
ColorMIdentity{}.Scale(1, 2, 3, 4),
ColorMIdentity{}.Scale(5, 6, 7, 8),
ColorMIdentity{}.Scale(5, 12, 21, 32),
affine.ColorMIdentity{}.Scale(1, 2, 3, 4),
affine.ColorMIdentity{}.Scale(5, 6, 7, 8),
affine.ColorMIdentity{}.Scale(5, 12, 21, 32),
},
{
ColorMIdentity{}.Scale(5, 6, 7, 8),
ColorMIdentity{}.Scale(1, 2, 3, 4),
ColorMIdentity{}.Scale(5, 12, 21, 32),
affine.ColorMIdentity{}.Scale(5, 6, 7, 8),
affine.ColorMIdentity{}.Scale(1, 2, 3, 4),
affine.ColorMIdentity{}.Scale(5, 12, 21, 32),
},
{
arrayToColorM([4][5]float32{
@ -296,7 +296,7 @@ func TestColorMConcat(t *testing.T) {
{4, 5, 1, 2, 3},
{3, 4, 5, 1, 2},
}),
ColorMIdentity{}.Scale(1, 2, 3, 4),
affine.ColorMIdentity{}.Scale(1, 2, 3, 4),
arrayToColorM([4][5]float32{
{1, 2, 3, 4, 5},
{10, 2, 4, 6, 8},
@ -305,7 +305,7 @@ func TestColorMConcat(t *testing.T) {
}),
},
{
ColorMIdentity{}.Scale(1, 2, 3, 4),
affine.ColorMIdentity{}.Scale(1, 2, 3, 4),
arrayToColorM([4][5]float32{
{1, 2, 3, 4, 5},
{5, 1, 2, 3, 4},

130
internal/atlas/image_test.go
View File

@ -20,7 +20,7 @@ import (
"testing"
"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"
t "github.com/hajimehoshi/ebiten/v2/internal/testing"
@ -32,8 +32,8 @@ const (
)
func TestMain(m *testing.M) {
SetImageSizeForTesting(minImageSizeForTesting, maxImageSizeForTesting)
defer ResetImageSizeForTesting()
atlas.SetImageSizeForTesting(minImageSizeForTesting, maxImageSizeForTesting)
defer atlas.ResetImageSizeForTesting()
t.MainWithRunLoop(m)
}
@ -59,22 +59,22 @@ const bigSize = 2049
func TestEnsureIsolated(t *testing.T) {
// Create img1 and img2 with this size so that the next images are allocated
// with non-upper-left location.
img1 := NewImage(bigSize, 100)
img1 := atlas.NewImage(bigSize, 100)
defer img1.MarkDisposed()
// Ensure img1's region is allocated.
img1.ReplacePixels(make([]byte, 4*bigSize*100))
img2 := NewImage(100, bigSize)
img2 := atlas.NewImage(100, bigSize)
defer img2.MarkDisposed()
img2.ReplacePixels(make([]byte, 4*100*bigSize))
const size = 32
img3 := NewImage(size/2, size/2)
img3 := atlas.NewImage(size/2, size/2)
defer img3.MarkDisposed()
img3.ReplacePixels(make([]byte, (size/2)*(size/2)*4))
img4 := NewImage(size, size)
img4 := atlas.NewImage(size, size)
defer img4.MarkDisposed()
pix := make([]byte, size*size*4)
@ -103,7 +103,7 @@ func TestEnsureIsolated(t *testing.T) {
Width: size,
Height: size,
}
img4.DrawTriangles([graphics.ShaderImageNum]*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{}, driver.CompositeModeCopy, driver.FilterNearest, driver.AddressUnsafe, dr, driver.Region{}, [graphics.ShaderImageNum - 1][2]float32{}, nil, nil, false)
want := false
if got := img4.IsOnAtlasForTesting(); got != want {
t.Errorf("got: %v, want: %v", got, want)
@ -133,24 +133,24 @@ func TestEnsureIsolated(t *testing.T) {
// Check further drawing doesn't cause panic.
// This bug was fixed by 03dcd948.
img4.DrawTriangles([graphics.ShaderImageNum]*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{}, driver.CompositeModeCopy, driver.FilterNearest, driver.AddressUnsafe, dr, driver.Region{}, [graphics.ShaderImageNum - 1][2]float32{}, nil, nil, false)
}
func TestReputOnAtlas(t *testing.T) {
const size = 16
img0 := NewImage(size, size)
img0 := atlas.NewImage(size, size)
defer img0.MarkDisposed()
img0.ReplacePixels(make([]byte, 4*size*size))
img1 := NewImage(size, size)
img1 := atlas.NewImage(size, size)
defer img1.MarkDisposed()
img1.ReplacePixels(make([]byte, 4*size*size))
if got, want := img1.IsOnAtlasForTesting(), true; got != want {
t.Errorf("got: %v, want: %v", got, want)
}
img2 := NewImage(size, size)
img2 := atlas.NewImage(size, size)
defer img2.MarkDisposed()
pix := make([]byte, 4*size*size)
for j := 0; j < size; j++ {
@ -163,7 +163,7 @@ func TestReputOnAtlas(t *testing.T) {
}
img2.ReplacePixels(pix)
img3 := NewImage(size, size)
img3 := atlas.NewImage(size, size)
img3.SetVolatile(true)
defer img3.MarkDisposed()
img1.ReplacePixels(make([]byte, 4*size*size))
@ -180,7 +180,7 @@ func TestReputOnAtlas(t *testing.T) {
Width: size,
Height: size,
}
img1.DrawTriangles([graphics.ShaderImageNum]*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{}, driver.CompositeModeCopy, driver.FilterNearest, driver.AddressUnsafe, dr, driver.Region{}, [graphics.ShaderImageNum - 1][2]float32{}, nil, nil, false)
if got, want := img1.IsOnAtlasForTesting(), false; got != want {
t.Errorf("got: %v, want: %v", got, want)
}
@ -188,16 +188,16 @@ func TestReputOnAtlas(t *testing.T) {
// Use img1 as a render source.
// Use the doubled count since img1 was on a texture atlas and became an isolated image once.
// Then, img1 requires longer time to recover to be on a textur atlas again.
for i := 0; i < BaseCountToPutOnAtlas*2; i++ {
if err := PutImagesOnAtlasForTesting(); err != nil {
for i := 0; i < atlas.BaseCountToPutOnAtlas*2; i++ {
if err := atlas.PutImagesOnAtlasForTesting(); err != nil {
t.Fatal(err)
}
img0.DrawTriangles([graphics.ShaderImageNum]*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{}, driver.CompositeModeCopy, driver.FilterNearest, driver.AddressUnsafe, dr, driver.Region{}, [graphics.ShaderImageNum - 1][2]float32{}, nil, nil, false)
if got, want := img1.IsOnAtlasForTesting(), false; got != want {
t.Errorf("got: %v, want: %v", got, want)
}
}
if err := PutImagesOnAtlasForTesting(); err != nil {
if err := atlas.PutImagesOnAtlasForTesting(); err != nil {
t.Fatal(err)
}
@ -220,7 +220,7 @@ func TestReputOnAtlas(t *testing.T) {
}
// img1 is on an atlas again.
img0.DrawTriangles([graphics.ShaderImageNum]*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{}, driver.CompositeModeCopy, driver.FilterNearest, driver.AddressUnsafe, dr, driver.Region{}, [graphics.ShaderImageNum - 1][2]float32{}, nil, nil, false)
if got, want := img1.IsOnAtlasForTesting(), true; got != want {
t.Errorf("got: %v, want: %v", got, want)
}
@ -244,39 +244,39 @@ func TestReputOnAtlas(t *testing.T) {
}
// Use img1 as a render target again.
img1.DrawTriangles([graphics.ShaderImageNum]*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{}, driver.CompositeModeCopy, driver.FilterNearest, driver.AddressUnsafe, dr, driver.Region{}, [graphics.ShaderImageNum - 1][2]float32{}, nil, nil, false)
if got, want := img1.IsOnAtlasForTesting(), false; got != want {
t.Errorf("got: %v, want: %v", got, want)
}
// Use img1 as a render source, but call ReplacePixels.
// Now use 4x count as img1 became an isolated image again.
for i := 0; i < BaseCountToPutOnAtlas*4; i++ {
if err := PutImagesOnAtlasForTesting(); err != nil {
for i := 0; i < atlas.BaseCountToPutOnAtlas*4; i++ {
if err := atlas.PutImagesOnAtlasForTesting(); err != nil {
t.Fatal(err)
}
img1.ReplacePixels(make([]byte, 4*size*size))
img0.DrawTriangles([graphics.ShaderImageNum]*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{}, driver.CompositeModeCopy, driver.FilterNearest, driver.AddressUnsafe, dr, driver.Region{}, [graphics.ShaderImageNum - 1][2]float32{}, nil, nil, false)
if got, want := img1.IsOnAtlasForTesting(), false; got != want {
t.Errorf("got: %v, want: %v", got, want)
}
}
if err := PutImagesOnAtlasForTesting(); err != nil {
if err := atlas.PutImagesOnAtlasForTesting(); err != nil {
t.Fatal(err)
}
// img1 is not on an atlas due to ReplacePixels.
img0.DrawTriangles([graphics.ShaderImageNum]*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{}, driver.CompositeModeCopy, driver.FilterNearest, driver.AddressUnsafe, dr, driver.Region{}, [graphics.ShaderImageNum - 1][2]float32{}, nil, nil, false)
if got, want := img1.IsOnAtlasForTesting(), false; got != want {
t.Errorf("got: %v, want: %v", got, want)
}
// Use img3 as a render source. As img3 is volatile, img3 is never on an atlas.
for i := 0; i < BaseCountToPutOnAtlas*2; i++ {
if err := PutImagesOnAtlasForTesting(); err != nil {
for i := 0; i < atlas.BaseCountToPutOnAtlas*2; i++ {
if err := atlas.PutImagesOnAtlasForTesting(); err != nil {
t.Fatal(err)
}
img0.DrawTriangles([graphics.ShaderImageNum]*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{}, driver.CompositeModeCopy, driver.FilterNearest, driver.AddressUnsafe, dr, driver.Region{}, [graphics.ShaderImageNum - 1][2]float32{}, nil, nil, false)
if got, want := img3.IsOnAtlasForTesting(), false; got != want {
t.Errorf("got: %v, want: %v", got, want)
}
@ -287,7 +287,7 @@ func TestReputOnAtlas(t *testing.T) {
func TestExtend(t *testing.T) {
const w0, h0 = 100, 100
img0 := NewImage(w0, h0)
img0 := atlas.NewImage(w0, h0)
defer img0.MarkDisposed()
p0 := make([]byte, 4*w0*h0)
@ -300,7 +300,7 @@ func TestExtend(t *testing.T) {
img0.ReplacePixels(p0)
const w1, h1 = minImageSizeForTesting + 1, 100
img1 := NewImage(w1, h1)
img1 := atlas.NewImage(w1, h1)
defer img1.MarkDisposed()
p1 := make([]byte, 4*w1*h1)
@ -354,9 +354,9 @@ func TestExtend(t *testing.T) {
func TestReplacePixelsAfterDrawTriangles(t *testing.T) {
const w, h = 256, 256
src := NewImage(w, h)
src := atlas.NewImage(w, h)
defer src.MarkDisposed()
dst := NewImage(w, h)
dst := atlas.NewImage(w, h)
defer dst.MarkDisposed()
pix := make([]byte, 4*w*h)
@ -376,7 +376,7 @@ func TestReplacePixelsAfterDrawTriangles(t *testing.T) {
Width: w,
Height: h,
}
dst.DrawTriangles([graphics.ShaderImageNum]*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{}, driver.CompositeModeCopy, driver.FilterNearest, driver.AddressUnsafe, dr, driver.Region{}, [graphics.ShaderImageNum - 1][2]float32{}, nil, nil, false)
dst.ReplacePixels(pix)
pix, err := dst.Pixels(0, 0, w, h)
@ -402,9 +402,9 @@ func TestReplacePixelsAfterDrawTriangles(t *testing.T) {
// Issue #887
func TestSmallImages(t *testing.T) {
const w, h = 4, 8
src := NewImage(w, h)
src := atlas.NewImage(w, h)
defer src.MarkDisposed()
dst := NewImage(w, h)
dst := atlas.NewImage(w, h)
defer dst.MarkDisposed()
pix := make([]byte, 4*w*h)
@ -424,7 +424,7 @@ func TestSmallImages(t *testing.T) {
Width: w,
Height: h,
}
dst.DrawTriangles([graphics.ShaderImageNum]*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{}, driver.CompositeModeSourceOver, driver.FilterNearest, driver.AddressUnsafe, dr, driver.Region{}, [graphics.ShaderImageNum - 1][2]float32{}, nil, nil, false)
pix, err := dst.Pixels(0, 0, w, h)
if err != nil {
@ -447,11 +447,11 @@ func TestSmallImages(t *testing.T) {
// Issue #887
func TestLongImages(t *testing.T) {
const w, h = 1, 6
src := NewImage(w, h)
src := atlas.NewImage(w, h)
defer src.MarkDisposed()
const dstW, dstH = 256, 256
dst := NewImage(dstW, dstH)
dst := atlas.NewImage(dstW, dstH)
defer dst.MarkDisposed()
pix := make([]byte, 4*w*h)
@ -472,7 +472,7 @@ func TestLongImages(t *testing.T) {
Width: dstW,
Height: dstH,
}
dst.DrawTriangles([graphics.ShaderImageNum]*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{}, driver.CompositeModeSourceOver, driver.FilterNearest, driver.AddressUnsafe, dr, driver.Region{}, [graphics.ShaderImageNum - 1][2]float32{}, nil, nil, false)
pix, err := dst.Pixels(0, 0, dstW, dstH)
if err != nil {
@ -495,11 +495,11 @@ func TestLongImages(t *testing.T) {
func TestDisposeImmediately(t *testing.T) {
// This tests restorable.Image.ClearPixels is called but ReplacePixels is not called.
img0 := NewImage(16, 16)
img0 := atlas.NewImage(16, 16)
img0.EnsureIsolatedForTesting()
defer img0.MarkDisposed()
img1 := NewImage(16, 16)
img1 := atlas.NewImage(16, 16)
img1.EnsureIsolatedForTesting()
defer img1.MarkDisposed()
@ -508,12 +508,12 @@ func TestDisposeImmediately(t *testing.T) {
// Issue #1028
func TestExtendWithBigImage(t *testing.T) {
img0 := NewImage(1, 1)
img0 := atlas.NewImage(1, 1)
defer img0.MarkDisposed()
img0.ReplacePixels(make([]byte, 4*1*1))
img1 := NewImage(minImageSizeForTesting+1, minImageSizeForTesting+1)
img1 := atlas.NewImage(minImageSizeForTesting+1, minImageSizeForTesting+1)
defer img1.MarkDisposed()
img1.ReplacePixels(make([]byte, 4*(minImageSizeForTesting+1)*(minImageSizeForTesting+1)))
@ -522,8 +522,8 @@ func TestExtendWithBigImage(t *testing.T) {
// Issue #1217
func TestMaxImageSize(t *testing.T) {
// This tests that a too-big image is allocated correctly.
s := maxImageSizeForTesting - 2*PaddingSize
img := NewImage(s, s)
s := maxImageSizeForTesting - 2*atlas.PaddingSize
img := atlas.NewImage(s, s)
defer img.MarkDisposed()
img.ReplacePixels(make([]byte, 4*s*s))
}
@ -536,7 +536,7 @@ func Disable_TestMinImageSize(t *testing.T) {
// This tests that extending a backend works correctly.
// Though the image size is minimum size of the backend, extending the backend happens due to the paddings.
s := minImageSizeForTesting
img := NewImage(s, s)
img := atlas.NewImage(s, s)
defer img.MarkDisposed()
img.ReplacePixels(make([]byte, 4*s*s))
}
@ -545,11 +545,11 @@ func Disable_TestMinImageSize(t *testing.T) {
func TestDisposedAndReputOnAtlas(t *testing.T) {
const size = 16
src := NewImage(size, size)
src := atlas.NewImage(size, size)
defer src.MarkDisposed()
src2 := NewImage(size, size)
src2 := atlas.NewImage(size, size)
defer src2.MarkDisposed()
dst := NewImage(size, size)
dst := atlas.NewImage(size, size)
defer dst.MarkDisposed()
// Use src as a render target so that src is not on an atlas.
@ -561,17 +561,17 @@ func TestDisposedAndReputOnAtlas(t *testing.T) {
Width: size,
Height: size,
}
src.DrawTriangles([graphics.ShaderImageNum]*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{}, driver.CompositeModeCopy, driver.FilterNearest, driver.AddressUnsafe, dr, driver.Region{}, [graphics.ShaderImageNum - 1][2]float32{}, nil, nil, false)
if got, want := src.IsOnAtlasForTesting(), false; got != want {
t.Errorf("got: %v, want: %v", got, want)
}
// Use src as a render source.
for i := 0; i < BaseCountToPutOnAtlas/2; i++ {
if err := PutImagesOnAtlasForTesting(); err != nil {
for i := 0; i < atlas.BaseCountToPutOnAtlas/2; i++ {
if err := atlas.PutImagesOnAtlasForTesting(); err != nil {
t.Fatal(err)
}
dst.DrawTriangles([graphics.ShaderImageNum]*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{}, driver.CompositeModeCopy, driver.FilterNearest, driver.AddressUnsafe, dr, driver.Region{}, [graphics.ShaderImageNum - 1][2]float32{}, nil, nil, false)
if got, want := src.IsOnAtlasForTesting(), false; got != want {
t.Errorf("got: %v, want: %v", got, want)
}
@ -581,10 +581,10 @@ func TestDisposedAndReputOnAtlas(t *testing.T) {
src.MarkDisposed()
// Force to dispose the image.
ResolveDeferredForTesting()
atlas.ResolveDeferredForTesting()
// Confirm that PutImagesOnAtlasForTesting doesn't panic.
if err := PutImagesOnAtlasForTesting(); err != nil {
if err := atlas.PutImagesOnAtlasForTesting(); err != nil {
t.Fatal(err)
}
}
@ -593,11 +593,11 @@ func TestDisposedAndReputOnAtlas(t *testing.T) {
func TestImageIsNotReputOnAtlasWithoutUsingAsSource(t *testing.T) {
const size = 16
src := NewImage(size, size)
src := atlas.NewImage(size, size)
defer src.MarkDisposed()
src2 := NewImage(size, size)
src2 := atlas.NewImage(size, size)
defer src2.MarkDisposed()
dst := NewImage(size, size)
dst := atlas.NewImage(size, size)
defer dst.MarkDisposed()
// Use src as a render target so that src is not on an atlas.
@ -611,15 +611,15 @@ func TestImageIsNotReputOnAtlasWithoutUsingAsSource(t *testing.T) {
}
// Use src2 as a rendering target, and make src2 an independent image.
src2.DrawTriangles([graphics.ShaderImageNum]*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{}, driver.CompositeModeCopy, driver.FilterNearest, driver.AddressUnsafe, dr, driver.Region{}, [graphics.ShaderImageNum - 1][2]float32{}, nil, nil, false)
if got, want := src2.IsOnAtlasForTesting(), false; got != want {
t.Errorf("got: %v, want: %v", got, want)
}
// Update the count without using src2 as a rendering source.
// This should not affect whether src2 is on an atlas or not.
for i := 0; i < BaseCountToPutOnAtlas; i++ {
if err := PutImagesOnAtlasForTesting(); err != nil {
for i := 0; i < atlas.BaseCountToPutOnAtlas; i++ {
if err := atlas.PutImagesOnAtlasForTesting(); err != nil {
t.Fatal(err)
}
if got, want := src2.IsOnAtlasForTesting(), false; got != want {
@ -628,17 +628,17 @@ func TestImageIsNotReputOnAtlasWithoutUsingAsSource(t *testing.T) {
}
// Update the count with using src2 as a rendering source.
for i := 0; i < BaseCountToPutOnAtlas; i++ {
if err := PutImagesOnAtlasForTesting(); err != nil {
for i := 0; i < atlas.BaseCountToPutOnAtlas; i++ {
if err := atlas.PutImagesOnAtlasForTesting(); err != nil {
t.Fatal(err)
}
dst.DrawTriangles([graphics.ShaderImageNum]*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{}, driver.CompositeModeCopy, driver.FilterNearest, driver.AddressUnsafe, dr, driver.Region{}, [graphics.ShaderImageNum - 1][2]float32{}, nil, nil, false)
if got, want := src2.IsOnAtlasForTesting(), false; got != want {
t.Errorf("got: %v, want: %v", got, want)
}
}
if err := PutImagesOnAtlasForTesting(); err != nil {
if err := atlas.PutImagesOnAtlasForTesting(); err != nil {
t.Fatal(err)
}
if got, want := src2.IsOnAtlasForTesting(), true; got != want {

22
internal/atlas/shader_test.go
View File

@ -19,7 +19,7 @@ import (
"testing"
"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"
etesting "github.com/hajimehoshi/ebiten/v2/internal/testing"
@ -28,7 +28,7 @@ import (
func TestShaderFillTwice(t *testing.T) {
const w, h = 1, 1
dst := NewImage(w, h)
dst := atlas.NewImage(w, h)
vs := quadVertices(w, h, 0, 0, 1)
is := graphics.QuadIndices()
@ -39,14 +39,14 @@ func TestShaderFillTwice(t *testing.T) {
Height: h,
}
p0 := etesting.ShaderProgramFill(0xff, 0xff, 0xff, 0xff)
s0 := NewShader(&p0)
dst.DrawTriangles([graphics.ShaderImageNum]*Image{}, vs, is, affine.ColorMIdentity{}, driver.CompositeModeCopy, driver.FilterNearest, driver.AddressUnsafe, dr, driver.Region{}, [graphics.ShaderImageNum - 1][2]float32{}, s0, nil, false)
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)
// Vertices must be recreated (#1755)
vs = quadVertices(w, h, 0, 0, 1)
p1 := etesting.ShaderProgramFill(0x80, 0x80, 0x80, 0xff)
s1 := NewShader(&p1)
dst.DrawTriangles([graphics.ShaderImageNum]*Image{}, vs, is, affine.ColorMIdentity{}, driver.CompositeModeCopy, driver.FilterNearest, driver.AddressUnsafe, dr, driver.Region{}, [graphics.ShaderImageNum - 1][2]float32{}, s1, nil, false)
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)
pix, err := dst.Pixels(0, 0, w, h)
if err != nil {
@ -60,10 +60,10 @@ func TestShaderFillTwice(t *testing.T) {
func TestImageDrawTwice(t *testing.T) {
const w, h = 1, 1
dst := NewImage(w, h)
src0 := NewImage(w, h)
dst := atlas.NewImage(w, h)
src0 := atlas.NewImage(w, h)
src0.ReplacePixels([]byte{0xff, 0xff, 0xff, 0xff})
src1 := NewImage(w, h)
src1 := atlas.NewImage(w, h)
src1.ReplacePixels([]byte{0x80, 0x80, 0x80, 0xff})
vs := quadVertices(w, h, 0, 0, 1)
@ -74,11 +74,11 @@ func TestImageDrawTwice(t *testing.T) {
Width: w,
Height: h,
}
dst.DrawTriangles([graphics.ShaderImageNum]*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{}, driver.CompositeModeCopy, driver.FilterNearest, driver.AddressUnsafe, dr, driver.Region{}, [graphics.ShaderImageNum - 1][2]float32{}, nil, nil, false)
// Vertices must be recreated (#1755)
vs = quadVertices(w, h, 0, 0, 1)
dst.DrawTriangles([graphics.ShaderImageNum]*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{}, driver.CompositeModeCopy, driver.FilterNearest, driver.AddressUnsafe, dr, driver.Region{}, [graphics.ShaderImageNum - 1][2]float32{}, nil, nil, false)
pix, err := dst.Pixels(0, 0, w, h)
if err != nil {

4
internal/graphics/math_test.go
View File

@ -17,7 +17,7 @@ package graphics_test
import (
"testing"
. "github.com/hajimehoshi/ebiten/v2/internal/graphics"
"github.com/hajimehoshi/ebiten/v2/internal/graphics"
)
func TestInternalImageSize(t *testing.T) {
@ -31,7 +31,7 @@ func TestInternalImageSize(t *testing.T) {
}
for _, testCase := range testCases {
got := InternalImageSize(testCase.arg)
got := graphics.InternalImageSize(testCase.arg)
wanted := testCase.expected
if wanted != got {
t.Errorf("Clp(%d) = %d, wanted %d", testCase.arg, got, wanted)

28
internal/graphicscommand/image_test.go
View File

@ -21,7 +21,7 @@ import (
"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/graphicscommand"
"github.com/hajimehoshi/ebiten/v2/internal/graphicscommand"
etesting "github.com/hajimehoshi/ebiten/v2/internal/testing"
)
@ -40,8 +40,8 @@ func quadVertices(w, h float32) []float32 {
func TestClear(t *testing.T) {
const w, h = 1024, 1024
src := NewImage(w/2, h/2)
dst := NewImage(w, h)
src := graphicscommand.NewImage(w/2, h/2)
dst := graphicscommand.NewImage(w, h)
vs := quadVertices(w/2, h/2)
is := graphics.QuadIndices()
@ -51,7 +51,7 @@ func TestClear(t *testing.T) {
Width: w,
Height: h,
}
dst.DrawTriangles([graphics.ShaderImageNum]*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{}, driver.CompositeModeClear, driver.FilterNearest, driver.AddressUnsafe, dr, driver.Region{}, nil, nil, false)
pix, err := dst.Pixels()
if err != nil {
@ -71,9 +71,9 @@ func TestClear(t *testing.T) {
func TestReplacePixelsPartAfterDrawTriangles(t *testing.T) {
const w, h = 32, 32
clr := NewImage(w, h)
src := NewImage(w/2, h/2)
dst := NewImage(w, h)
clr := graphicscommand.NewImage(w, h)
src := graphicscommand.NewImage(w/2, h/2)
dst := graphicscommand.NewImage(w, h)
vs := quadVertices(w/2, h/2)
is := graphics.QuadIndices()
dr := driver.Region{
@ -82,8 +82,8 @@ func TestReplacePixelsPartAfterDrawTriangles(t *testing.T) {
Width: w,
Height: h,
}
dst.DrawTriangles([graphics.ShaderImageNum]*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]*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{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{src}, [graphics.ShaderImageNum - 1][2]float32{}, vs, is, affine.ColorMIdentity{}, driver.CompositeModeSourceOver, driver.FilterNearest, driver.AddressUnsafe, dr, driver.Region{}, nil, nil, false)
dst.ReplacePixels(make([]byte, 4), 0, 0, 1, 1)
// TODO: Check the result.
@ -91,8 +91,8 @@ func TestReplacePixelsPartAfterDrawTriangles(t *testing.T) {
func TestShader(t *testing.T) {
const w, h = 16, 16
clr := NewImage(w, h)
dst := NewImage(w, h)
clr := graphicscommand.NewImage(w, h)
dst := graphicscommand.NewImage(w, h)
vs := quadVertices(w, h)
is := graphics.QuadIndices()
dr := driver.Region{
@ -101,11 +101,11 @@ func TestShader(t *testing.T) {
Width: w,
Height: h,
}
dst.DrawTriangles([graphics.ShaderImageNum]*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{}, driver.CompositeModeClear, driver.FilterNearest, driver.AddressUnsafe, dr, driver.Region{}, nil, nil, false)
ir := etesting.ShaderProgramFill(0xff, 0, 0, 0xff)
s := NewShader(&ir)
dst.DrawTriangles([graphics.ShaderImageNum]*Image{}, [graphics.ShaderImageNum - 1][2]float32{}, vs, is, affine.ColorMIdentity{}, driver.CompositeModeSourceOver, driver.FilterNearest, driver.AddressUnsafe, dr, driver.Region{}, s, nil, false)
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)
pix, err := dst.Pixels()
if err != nil {

14
internal/packing/packing_test.go
View File

@ -17,7 +17,7 @@ package packing_test
import (
"testing"
. "github.com/hajimehoshi/ebiten/v2/internal/packing"
"github.com/hajimehoshi/ebiten/v2/internal/packing"
)
func TestPage(t *testing.T) {
@ -211,8 +211,8 @@ func TestPage(t *testing.T) {
}
for _, c := range cases {
p := NewPage(1024, 1024)
nodes := []*Node{}
p := packing.NewPage(1024, 1024)
nodes := []*packing.Node{}
nnodes := 0
for i, in := range c.In {
if in.FreeNodeID == -1 {
@ -254,7 +254,7 @@ func TestPage(t *testing.T) {
}
func TestExtend(t *testing.T) {
p := NewPage(1024, 4096)
p := packing.NewPage(1024, 4096)
s := p.Size()
p.Alloc(s/2, s/2)
p.Extend(1)
@ -289,7 +289,7 @@ func TestExtend(t *testing.T) {
}
func TestExtend2(t *testing.T) {
p := NewPage(1024, 4096)
p := packing.NewPage(1024, 4096)
s := p.Size()
p.Alloc(s/2, s/2)
n1 := p.Alloc(s/2, s/2)
@ -331,7 +331,7 @@ func TestExtend2(t *testing.T) {
// Issue #1454
func TestExtendTooMuch(t *testing.T) {
p := NewPage(1024, 4096)
p := packing.NewPage(1024, 4096)
p.Alloc(1, 1)
if got, want := p.Extend(3), false; got != want {
t.Errorf("got: %t, want: %t", got, want)
@ -339,7 +339,7 @@ func TestExtendTooMuch(t *testing.T) {
}
func TestExtendWithoutAllocation(t *testing.T) {
p := NewPage(1024, 4096)
p := packing.NewPage(1024, 4096)
if got, want := p.Extend(2), true; got != want {
t.Errorf("got: %t, want: %t", got, want)

176
internal/restorable/images_test.go
View File

@ -22,16 +22,16 @@ import (
"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/restorable"
"github.com/hajimehoshi/ebiten/v2/internal/restorable"
t "github.com/hajimehoshi/ebiten/v2/internal/testing"
)
func TestMain(m *testing.M) {
EnableRestoringForTesting()
restorable.EnableRestoringForTesting()
t.MainWithRunLoop(m)
}
func pixelsToColor(p *Pixels, i, j int) color.RGBA {
func pixelsToColor(p *restorable.Pixels, i, j int) color.RGBA {
r, g, b, a := p.At(i, j)
return color.RGBA{r, g, b, a}
}
@ -56,15 +56,15 @@ func sameColors(c1, c2 color.RGBA, delta int) bool {
}
func TestRestore(t *testing.T) {
img0 := NewImage(1, 1)
img0 := restorable.NewImage(1, 1)
defer img0.Dispose()
clr0 := color.RGBA{0x00, 0x00, 0x00, 0xff}
img0.ReplacePixels([]byte{clr0.R, clr0.G, clr0.B, clr0.A}, 0, 0, 1, 1)
if err := ResolveStaleImages(); err != nil {
if err := restorable.ResolveStaleImages(); err != nil {
t.Fatal(err)
}
if err := RestoreIfNeeded(); err != nil {
if err := restorable.RestoreIfNeeded(); err != nil {
t.Fatal(err)
}
want := clr0
@ -75,15 +75,15 @@ func TestRestore(t *testing.T) {
}
func TestRestoreWithoutDraw(t *testing.T) {
img0 := NewImage(1024, 1024)
img0 := restorable.NewImage(1024, 1024)
defer img0.Dispose()
// If there is no drawing command on img0, img0 is cleared when restored.
if err := ResolveStaleImages(); err != nil {
if err := restorable.ResolveStaleImages(); err != nil {
t.Fatal(err)
}
if err := RestoreIfNeeded(); err != nil {
if err := restorable.RestoreIfNeeded(); err != nil {
t.Fatal(err)
}
@ -117,9 +117,9 @@ func quadVertices(sw, sh, x, y int) []float32 {
func TestRestoreChain(t *testing.T) {
const num = 10
imgs := []*Image{}
imgs := []*restorable.Image{}
for i := 0; i < num; i++ {
img := NewImage(1, 1)
img := restorable.NewImage(1, 1)
imgs = append(imgs, img)
}
defer func() {
@ -138,12 +138,12 @@ func TestRestoreChain(t *testing.T) {
Width: 1,
Height: 1,
}
imgs[i+1].DrawTriangles([graphics.ShaderImageNum]*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{}, driver.CompositeModeCopy, driver.FilterNearest, driver.AddressUnsafe, dr, driver.Region{}, nil, nil, false)
}
if err := ResolveStaleImages(); err != nil {
if err := restorable.ResolveStaleImages(); err != nil {
t.Fatal(err)
}
if err := RestoreIfNeeded(); err != nil {
if err := restorable.RestoreIfNeeded(); err != nil {
t.Fatal(err)
}
want := clr
@ -161,9 +161,9 @@ func TestRestoreChain2(t *testing.T) {
w = 1
h = 1
)
imgs := []*Image{}
imgs := []*restorable.Image{}
for i := 0; i < num; i++ {
img := NewImage(w, h)
img := restorable.NewImage(w, h)
imgs = append(imgs, img)
}
defer func() {
@ -186,16 +186,16 @@ func TestRestoreChain2(t *testing.T) {
Width: w,
Height: h,
}
imgs[8].DrawTriangles([graphics.ShaderImageNum]*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[9].DrawTriangles([graphics.ShaderImageNum]*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[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[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)
for i := 0; i < 7; i++ {
imgs[i+1].DrawTriangles([graphics.ShaderImageNum]*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{}, driver.CompositeModeCopy, driver.FilterNearest, driver.AddressUnsafe, dr, driver.Region{}, nil, nil, false)
}
if err := ResolveStaleImages(); err != nil {
if err := restorable.ResolveStaleImages(); err != nil {
t.Fatal(err)
}
if err := RestoreIfNeeded(); err != nil {
if err := restorable.RestoreIfNeeded(); err != nil {
t.Fatal(err)
}
for i, img := range imgs {
@ -215,10 +215,10 @@ func TestRestoreOverrideSource(t *testing.T) {
w = 1
h = 1
)
img0 := NewImage(w, h)
img1 := NewImage(w, h)
img2 := NewImage(w, h)
img3 := NewImage(w, h)
img0 := restorable.NewImage(w, h)
img1 := restorable.NewImage(w, h)
img2 := restorable.NewImage(w, h)
img3 := restorable.NewImage(w, h)
defer func() {
img3.Dispose()
img2.Dispose()
@ -235,14 +235,14 @@ func TestRestoreOverrideSource(t *testing.T) {
Width: w,
Height: h,
}
img2.DrawTriangles([graphics.ShaderImageNum]*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)
img3.DrawTriangles([graphics.ShaderImageNum]*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)
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)
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)
img0.ReplacePixels([]byte{clr1.R, clr1.G, clr1.B, clr1.A}, 0, 0, w, h)
img1.DrawTriangles([graphics.ShaderImageNum]*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)
if err := ResolveStaleImages(); err != nil {
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)
if err := restorable.ResolveStaleImages(); err != nil {
t.Fatal(err)
}
if err := RestoreIfNeeded(); err != nil {
if err := restorable.RestoreIfNeeded(); err != nil {
t.Fatal(err)
}
testCases := []struct {
@ -300,11 +300,11 @@ func TestRestoreComplexGraph(t *testing.T) {
img0 := newImageFromImage(base)
img1 := newImageFromImage(base)
img2 := newImageFromImage(base)
img3 := NewImage(w, h)
img4 := NewImage(w, h)
img5 := NewImage(w, h)
img6 := NewImage(w, h)
img7 := NewImage(w, h)
img3 := restorable.NewImage(w, h)
img4 := restorable.NewImage(w, h)
img5 := restorable.NewImage(w, h)
img6 := restorable.NewImage(w, h)
img7 := restorable.NewImage(w, h)
defer func() {
img7.Dispose()
img6.Dispose()
@ -324,33 +324,33 @@ func TestRestoreComplexGraph(t *testing.T) {
Height: h,
}
var offsets [graphics.ShaderImageNum - 1][2]float32
img3.DrawTriangles([graphics.ShaderImageNum]*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{}, driver.CompositeModeSourceOver, driver.FilterNearest, driver.AddressUnsafe, dr, driver.Region{}, nil, nil, false)
vs = quadVertices(w, h, 1, 0)
img3.DrawTriangles([graphics.ShaderImageNum]*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{}, driver.CompositeModeSourceOver, driver.FilterNearest, driver.AddressUnsafe, dr, driver.Region{}, nil, nil, false)
vs = quadVertices(w, h, 1, 0)
img4.DrawTriangles([graphics.ShaderImageNum]*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{}, driver.CompositeModeSourceOver, driver.FilterNearest, driver.AddressUnsafe, dr, driver.Region{}, nil, nil, false)
vs = quadVertices(w, h, 2, 0)
img4.DrawTriangles([graphics.ShaderImageNum]*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{}, driver.CompositeModeSourceOver, driver.FilterNearest, driver.AddressUnsafe, dr, driver.Region{}, nil, nil, false)
vs = quadVertices(w, h, 0, 0)
img5.DrawTriangles([graphics.ShaderImageNum]*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{}, driver.CompositeModeSourceOver, driver.FilterNearest, driver.AddressUnsafe, dr, driver.Region{}, nil, nil, false)
vs = quadVertices(w, h, 0, 0)
img6.DrawTriangles([graphics.ShaderImageNum]*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{}, driver.CompositeModeSourceOver, driver.FilterNearest, driver.AddressUnsafe, dr, driver.Region{}, nil, nil, false)
vs = quadVertices(w, h, 1, 0)
img6.DrawTriangles([graphics.ShaderImageNum]*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{}, driver.CompositeModeSourceOver, driver.FilterNearest, driver.AddressUnsafe, dr, driver.Region{}, nil, nil, false)
vs = quadVertices(w, h, 0, 0)
img7.DrawTriangles([graphics.ShaderImageNum]*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{}, driver.CompositeModeSourceOver, driver.FilterNearest, driver.AddressUnsafe, dr, driver.Region{}, nil, nil, false)
vs = quadVertices(w, h, 2, 0)
img7.DrawTriangles([graphics.ShaderImageNum]*Image{img3}, offsets, vs, is, affine.ColorMIdentity{}, driver.CompositeModeSourceOver, driver.FilterNearest, driver.AddressUnsafe, dr, driver.Region{}, nil, nil, false)
if err := ResolveStaleImages(); err != nil {
img7.DrawTriangles([graphics.ShaderImageNum]*restorable.Image{img3}, offsets, vs, is, affine.ColorMIdentity{}, driver.CompositeModeSourceOver, driver.FilterNearest, driver.AddressUnsafe, dr, driver.Region{}, nil, nil, false)
if err := restorable.ResolveStaleImages(); err != nil {
t.Fatal(err)
}
if err := RestoreIfNeeded(); err != nil {
if err := restorable.RestoreIfNeeded(); err != nil {
t.Fatal(err)
}
testCases := []struct {
name string
out string
image *Image
image *restorable.Image
}{
{
"0",
@ -407,9 +407,9 @@ func TestRestoreComplexGraph(t *testing.T) {
}
}
func newImageFromImage(rgba *image.RGBA) *Image {
func newImageFromImage(rgba *image.RGBA) *restorable.Image {
s := rgba.Bounds().Size()
img := NewImage(s.X, s.Y)
img := restorable.NewImage(s.X, s.Y)
img.ReplacePixels(rgba.Pix, 0, 0, s.X, s.Y)
return img
}
@ -426,7 +426,7 @@ func TestRestoreRecursive(t *testing.T) {
base.Pix[3] = 0xff
img0 := newImageFromImage(base)
img1 := NewImage(w, h)
img1 := restorable.NewImage(w, h)
defer func() {
img1.Dispose()
img0.Dispose()
@ -438,18 +438,18 @@ func TestRestoreRecursive(t *testing.T) {
Width: w,
Height: h,
}
img1.DrawTriangles([graphics.ShaderImageNum]*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)
img0.DrawTriangles([graphics.ShaderImageNum]*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)
if err := ResolveStaleImages(); err != nil {
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)
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)
if err := restorable.ResolveStaleImages(); err != nil {
t.Fatal(err)
}
if err := RestoreIfNeeded(); err != nil {
if err := restorable.RestoreIfNeeded(); err != nil {
t.Fatal(err)
}
testCases := []struct {
name string
out string
image *Image
image *restorable.Image
}{
{
"0",
@ -477,7 +477,7 @@ func TestRestoreRecursive(t *testing.T) {
}
func TestReplacePixels(t *testing.T) {
img := NewImage(17, 31)
img := restorable.NewImage(17, 31)
defer img.Dispose()
pix := make([]byte, 4*4*4)
@ -499,10 +499,10 @@ func TestReplacePixels(t *testing.T) {
}
}
}
if err := ResolveStaleImages(); err != nil {
if err := restorable.ResolveStaleImages(); err != nil {
t.Fatal(err)
}
if err := RestoreIfNeeded(); err != nil {
if err := restorable.RestoreIfNeeded(); err != nil {
t.Fatal(err)
}
for j := 7; j < 11; j++ {
@ -528,7 +528,7 @@ func TestDrawTrianglesAndReplacePixels(t *testing.T) {
base.Pix[3] = 0xff
img0 := newImageFromImage(base)
defer img0.Dispose()
img1 := NewImage(2, 1)
img1 := restorable.NewImage(2, 1)
defer img1.Dispose()
vs := quadVertices(1, 1, 0, 0)
@ -539,13 +539,13 @@ func TestDrawTrianglesAndReplacePixels(t *testing.T) {
Width: 2,
Height: 1,
}
img1.DrawTriangles([graphics.ShaderImageNum]*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{}, driver.CompositeModeCopy, driver.FilterNearest, driver.AddressUnsafe, dr, driver.Region{}, nil, nil, false)
img1.ReplacePixels([]byte{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff}, 0, 0, 2, 1)
if err := ResolveStaleImages(); err != nil {
if err := restorable.ResolveStaleImages(); err != nil {
t.Fatal(err)
}
if err := RestoreIfNeeded(); err != nil {
if err := restorable.RestoreIfNeeded(); err != nil {
t.Fatal(err)
}
r, g, b, a, err := img1.At(0, 0)
@ -582,14 +582,14 @@ func TestDispose(t *testing.T) {
Width: 1,
Height: 1,
}
img1.DrawTriangles([graphics.ShaderImageNum]*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)
img0.DrawTriangles([graphics.ShaderImageNum]*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)
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)
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)
img1.Dispose()
if err := ResolveStaleImages(); err != nil {
if err := restorable.ResolveStaleImages(); err != nil {
t.Fatal(err)
}
if err := RestoreIfNeeded(); err != nil {
if err := restorable.RestoreIfNeeded(); err != nil {
t.Fatal(err)
}
r, g, b, a, err := img0.At(0, 0)
@ -609,7 +609,7 @@ func TestReplacePixelsPart(t *testing.T) {
pix[i] = 0xff
}
img := NewImage(4, 4)
img := restorable.NewImage(4, 4)
// This doesn't make the image stale. Its base pixels are available.
img.ReplacePixels(pix, 1, 1, 2, 2)
@ -680,9 +680,9 @@ func TestReplacePixelsPart(t *testing.T) {
func TestReplacePixelsOnly(t *testing.T) {
const w, h = 128, 128
img0 := NewImage(w, h)
img0 := restorable.NewImage(w, h)
defer img0.Dispose()
img1 := NewImage(1, 1)
img1 := restorable.NewImage(1, 1)
defer img1.Dispose()
for i := 0; i < w*h; i += 5 {
@ -697,7 +697,7 @@ func TestReplacePixelsOnly(t *testing.T) {
Width: 1,
Height: 1,
}
img1.DrawTriangles([graphics.ShaderImageNum]*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{}, driver.CompositeModeCopy, driver.FilterNearest, driver.AddressUnsafe, dr, driver.Region{}, nil, nil, false)
img0.ReplacePixels([]byte{5, 6, 7, 8}, 0, 0, 1, 1)
// BasePixelsForTesting is available without GPU accessing.
@ -718,10 +718,10 @@ func TestReplacePixelsOnly(t *testing.T) {
}
}
if err := ResolveStaleImages(); err != nil {
if err := restorable.ResolveStaleImages(); err != nil {
t.Fatal(err)
}
if err := RestoreIfNeeded(); err != nil {
if err := restorable.RestoreIfNeeded(); err != nil {
t.Fatal(err)
}
want := color.RGBA{1, 2, 3, 4}
@ -736,9 +736,9 @@ func TestReplacePixelsOnly(t *testing.T) {
// Issue #793
func TestReadPixelsFromVolatileImage(t *testing.T) {
const w, h = 16, 16
dst := NewImage(w, h)
dst := restorable.NewImage(w, h)
dst.SetVolatile(true)
src := NewImage(w, h)
src := restorable.NewImage(w, h)
// First, make sure that dst has pixels
dst.ReplacePixels(make([]byte, 4*w*h), 0, 0, w, h)
@ -757,7 +757,7 @@ func TestReadPixelsFromVolatileImage(t *testing.T) {
Width: w,
Height: h,
}
dst.DrawTriangles([graphics.ShaderImageNum]*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{}, driver.CompositeModeCopy, driver.FilterNearest, driver.AddressUnsafe, dr, driver.Region{}, nil, nil, false)
// Read the pixels. If the implementation is correct, dst tries to read its pixels from GPU due to being
// stale.
@ -773,8 +773,8 @@ func TestReadPixelsFromVolatileImage(t *testing.T) {
func TestAllowReplacePixelsAfterDrawTriangles(t *testing.T) {
const w, h = 16, 16
src := NewImage(w, h)
dst := NewImage(w, h)
src := restorable.NewImage(w, h)
dst := restorable.NewImage(w, h)
vs := quadVertices(w, h, 0, 0)
is := graphics.QuadIndices()
@ -784,7 +784,7 @@ func TestAllowReplacePixelsAfterDrawTriangles(t *testing.T) {
Width: w,
Height: h,
}
dst.DrawTriangles([graphics.ShaderImageNum]*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{}, driver.CompositeModeSourceOver, driver.FilterNearest, driver.AddressUnsafe, dr, driver.Region{}, nil, nil, false)
dst.ReplacePixels(make([]byte, 4*w*h), 0, 0, w, h)
// ReplacePixels for a whole image doesn't panic.
}
@ -797,8 +797,8 @@ func TestDisallowReplacePixelsForPartAfterDrawTriangles(t *testing.T) {
}()
const w, h = 16, 16
src := NewImage(w, h)
dst := NewImage(w, h)
src := restorable.NewImage(w, h)
dst := restorable.NewImage(w, h)
vs := quadVertices(w, h, 0, 0)
is := graphics.QuadIndices()
@ -808,7 +808,7 @@ func TestDisallowReplacePixelsForPartAfterDrawTriangles(t *testing.T) {
Width: w,
Height: h,
}
dst.DrawTriangles([graphics.ShaderImageNum]*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{}, driver.CompositeModeSourceOver, driver.FilterNearest, driver.AddressUnsafe, dr, driver.Region{}, nil, nil, false)
dst.ReplacePixels(make([]byte, 4), 0, 0, 1, 1)
}
@ -818,7 +818,7 @@ func TestExtend(t *testing.T) {
}
const w, h = 16, 16
orig := NewImage(w, h)
orig := restorable.NewImage(w, h)
pix := make([]byte, 4*w*h)
for j := 0; j < h; j++ {
for i := 0; i < w; i++ {
@ -853,7 +853,7 @@ func TestExtend(t *testing.T) {
func TestClearPixels(t *testing.T) {
const w, h = 16, 16
img := NewImage(w, h)
img := restorable.NewImage(w, h)
img.ReplacePixels(make([]byte, 4*4*4), 0, 0, 4, 4)
img.ReplacePixels(make([]byte, 4*4*4), 4, 0, 4, 4)
img.ClearPixels(0, 0, 4, 4)
@ -865,8 +865,8 @@ func TestClearPixels(t *testing.T) {
func TestMutateSlices(t *testing.T) {
const w, h = 16, 16
dst := NewImage(w, h)
src := NewImage(w, h)
dst := restorable.NewImage(w, h)
src := restorable.NewImage(w, h)
pix := make([]byte, 4*w*h)
for i := 0; i < w*h; i++ {
pix[4*i] = byte(i)
@ -885,17 +885,17 @@ func TestMutateSlices(t *testing.T) {
Width: w,
Height: h,
}
dst.DrawTriangles([graphics.ShaderImageNum]*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{}, driver.CompositeModeSourceOver, driver.FilterNearest, driver.AddressUnsafe, dr, driver.Region{}, nil, nil, false)
for i := range vs {
vs[i] = 0
}
for i := range is {
is[i] = 0
}
if err := ResolveStaleImages(); err != nil {
if err := restorable.ResolveStaleImages(); err != nil {
t.Fatal(err)
}
if err := RestoreIfNeeded(); err != nil {
if err := restorable.RestoreIfNeeded(); err != nil {
t.Fatal(err)
}

64
internal/restorable/shader_test.go
View File

@ -21,12 +21,12 @@ import (
"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/restorable"
"github.com/hajimehoshi/ebiten/v2/internal/restorable"
etesting "github.com/hajimehoshi/ebiten/v2/internal/testing"
)
func clearImage(img *Image, w, h int) {
emptyImage := NewImage(3, 3)
func clearImage(img *restorable.Image, w, h int) {
emptyImage := restorable.NewImage(3, 3)
defer emptyImage.Dispose()
dx0 := float32(0)
@ -50,27 +50,27 @@ func clearImage(img *Image, w, h int) {
Width: float32(w),
Height: float32(h),
}
img.DrawTriangles([graphics.ShaderImageNum]*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{}, driver.CompositeModeClear, driver.FilterNearest, driver.AddressUnsafe, dr, driver.Region{}, nil, nil, false)
}
func TestShader(t *testing.T) {
img := NewImage(1, 1)
img := restorable.NewImage(1, 1)
defer img.Dispose()
ir := etesting.ShaderProgramFill(0xff, 0, 0, 0xff)
s := NewShader(&ir)
s := restorable.NewShader(&ir)
dr := driver.Region{
X: 0,
Y: 0,
Width: 1,
Height: 1,
}
img.DrawTriangles([graphics.ShaderImageNum]*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, driver.CompositeModeCopy, driver.FilterNearest, driver.AddressUnsafe, dr, driver.Region{}, s, nil, false)
if err := ResolveStaleImages(); err != nil {
if err := restorable.ResolveStaleImages(); err != nil {
t.Fatal(err)
}
if err := RestoreIfNeeded(); err != nil {
if err := restorable.RestoreIfNeeded(); err != nil {
t.Fatal(err)
}
@ -83,9 +83,9 @@ func TestShader(t *testing.T) {
func TestShaderChain(t *testing.T) {
const num = 10
imgs := []*Image{}
imgs := []*restorable.Image{}
for i := 0; i < num; i++ {
img := NewImage(1, 1)
img := restorable.NewImage(1, 1)
defer img.Dispose()
imgs = append(imgs, img)
}
@ -93,7 +93,7 @@ func TestShaderChain(t *testing.T) {
imgs[0].ReplacePixels([]byte{0xff, 0, 0, 0xff}, 0, 0, 1, 1)
ir := etesting.ShaderProgramImages(1)
s := NewShader(&ir)
s := restorable.NewShader(&ir)
for i := 0; i < num-1; i++ {
dr := driver.Region{
X: 0,
@ -101,13 +101,13 @@ func TestShaderChain(t *testing.T) {
Width: 1,
Height: 1,
}
imgs[i+1].DrawTriangles([graphics.ShaderImageNum]*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, driver.CompositeModeCopy, driver.FilterNearest, driver.AddressUnsafe, dr, driver.Region{}, s, nil, false)
}
if err := ResolveStaleImages(); err != nil {
if err := restorable.ResolveStaleImages(); err != nil {
t.Fatal(err)
}
if err := RestoreIfNeeded(); err != nil {
if err := restorable.RestoreIfNeeded(); err != nil {
t.Fatal(err)
}
@ -121,18 +121,18 @@ func TestShaderChain(t *testing.T) {
}
func TestShaderMultipleSources(t *testing.T) {
var srcs [graphics.ShaderImageNum]*Image
var srcs [graphics.ShaderImageNum]*restorable.Image
for i := range srcs {
srcs[i] = NewImage(1, 1)
srcs[i] = restorable.NewImage(1, 1)
}
srcs[0].ReplacePixels([]byte{0x40, 0, 0, 0xff}, 0, 0, 1, 1)
srcs[1].ReplacePixels([]byte{0, 0x80, 0, 0xff}, 0, 0, 1, 1)
srcs[2].ReplacePixels([]byte{0, 0, 0xc0, 0xff}, 0, 0, 1, 1)
dst := NewImage(1, 1)
dst := restorable.NewImage(1, 1)
ir := etesting.ShaderProgramImages(3)
s := NewShader(&ir)
s := restorable.NewShader(&ir)
var offsets [graphics.ShaderImageNum - 1][2]float32
dr := driver.Region{
X: 0,
@ -145,10 +145,10 @@ func TestShaderMultipleSources(t *testing.T) {
// Clear one of the sources after DrawTriangles. dst should not be affected.
clearImage(srcs[0], 1, 1)
if err := ResolveStaleImages(); err != nil {
if err := restorable.ResolveStaleImages(); err != nil {
t.Fatal(err)
}
if err := RestoreIfNeeded(); err != nil {
if err := restorable.RestoreIfNeeded(); err != nil {
t.Fatal(err)
}
@ -160,18 +160,18 @@ func TestShaderMultipleSources(t *testing.T) {
}
func TestShaderMultipleSourcesOnOneTexture(t *testing.T) {
src := NewImage(3, 1)
src := restorable.NewImage(3, 1)
src.ReplacePixels([]byte{
0x40, 0, 0, 0xff,
0, 0x80, 0, 0xff,
0, 0, 0xc0, 0xff,
}, 0, 0, 3, 1)
srcs := [graphics.ShaderImageNum]*Image{src, src, src}
srcs := [graphics.ShaderImageNum]*restorable.Image{src, src, src}
dst := NewImage(1, 1)
dst := restorable.NewImage(1, 1)
ir := etesting.ShaderProgramImages(3)
s := NewShader(&ir)
s := restorable.NewShader(&ir)
offsets := [graphics.ShaderImageNum - 1][2]float32{
{1, 0},
{2, 0},
@ -187,10 +187,10 @@ func TestShaderMultipleSourcesOnOneTexture(t *testing.T) {
// Clear one of the sources after DrawTriangles. dst should not be affected.
clearImage(srcs[0], 3, 1)
if err := ResolveStaleImages(); err != nil {
if err := restorable.ResolveStaleImages(); err != nil {
t.Fatal(err)
}
if err := RestoreIfNeeded(); err != nil {
if err := restorable.RestoreIfNeeded(); err != nil {
t.Fatal(err)
}
@ -202,27 +202,27 @@ func TestShaderMultipleSourcesOnOneTexture(t *testing.T) {
}
func TestShaderDispose(t *testing.T) {
img := NewImage(1, 1)
img := restorable.NewImage(1, 1)
defer img.Dispose()
ir := etesting.ShaderProgramFill(0xff, 0, 0, 0xff)
s := NewShader(&ir)
s := restorable.NewShader(&ir)
dr := driver.Region{
X: 0,
Y: 0,
Width: 1,
Height: 1,
}
img.DrawTriangles([graphics.ShaderImageNum]*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, driver.CompositeModeCopy, driver.FilterNearest, driver.AddressUnsafe, dr, driver.Region{}, s, nil, false)
// Dispose the shader. This should invalidates all the images using this shader i.e., all the images become
// stale.
s.Dispose()
if err := ResolveStaleImages(); err != nil {
if err := restorable.ResolveStaleImages(); err != nil {
t.Fatal(err)
}
if err := RestoreIfNeeded(); err != nil {
if err := restorable.RestoreIfNeeded(); err != nil {
t.Fatal(err)
}

4
internal/shader/shader_test.go
View File

@ -24,7 +24,7 @@ import (
"strings"
"testing"
. "github.com/hajimehoshi/ebiten/v2/internal/shader"
"github.com/hajimehoshi/ebiten/v2/internal/shader"
"github.com/hajimehoshi/ebiten/v2/internal/shaderir/glsl"
"github.com/hajimehoshi/ebiten/v2/internal/shaderir/metal"
)
@ -150,7 +150,7 @@ func TestCompile(t *testing.T) {
t.Fatal(err)
}
s, err := Compile(fset, f, "Vertex", "Fragment", 0)
s, err := shader.Compile(fset, f, "Vertex", "Fragment", 0)
if err != nil {
t.Error(err)
return

446
internal/shaderir/ir_test.go
View File

@ -18,59 +18,59 @@ import (
"go/constant"
"testing"
. "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/metal"
)
func block(localVars []Type, offset int, stmts ...Stmt) *Block {
return &Block{
func block(localVars []shaderir.Type, offset int, stmts ...shaderir.Stmt) *shaderir.Block {
return &shaderir.Block{
LocalVars: localVars,
LocalVarIndexOffset: offset,
Stmts: stmts,
}
}
func exprStmt(expr Expr) Stmt {
return Stmt{
Type: ExprStmt,
Exprs: []Expr{expr},
func exprStmt(expr shaderir.Expr) shaderir.Stmt {
return shaderir.Stmt{
Type: shaderir.ExprStmt,
Exprs: []shaderir.Expr{expr},
}
}
func blockStmt(block *Block) Stmt {
return Stmt{
Type: BlockStmt,
Blocks: []*Block{block},
func blockStmt(block *shaderir.Block) shaderir.Stmt {
return shaderir.Stmt{
Type: shaderir.BlockStmt,
Blocks: []*shaderir.Block{block},
}
}
func returnStmt(expr Expr) Stmt {
return Stmt{
Type: Return,
Exprs: []Expr{expr},
func returnStmt(expr shaderir.Expr) shaderir.Stmt {
return shaderir.Stmt{
Type: shaderir.Return,
Exprs: []shaderir.Expr{expr},
}
}
func assignStmt(lhs Expr, rhs Expr) Stmt {
return Stmt{
Type: Assign,
Exprs: []Expr{lhs, rhs},
func assignStmt(lhs shaderir.Expr, rhs shaderir.Expr) shaderir.Stmt {
return shaderir.Stmt{
Type: shaderir.Assign,
Exprs: []shaderir.Expr{lhs, rhs},
}
}
func ifStmt(cond Expr, block *Block, elseBlock *Block) Stmt {
return Stmt{
Type: If,
Exprs: []Expr{cond},
Blocks: []*Block{block, elseBlock},
func ifStmt(cond shaderir.Expr, block *shaderir.Block, elseBlock *shaderir.Block) shaderir.Stmt {
return shaderir.Stmt{
Type: shaderir.If,
Exprs: []shaderir.Expr{cond},
Blocks: []*shaderir.Block{block, elseBlock},
}
}
func forStmt(t Type, index, init, end int, op Op, delta int, block *Block) Stmt {
return Stmt{
Type: For,
Blocks: []*Block{block},
func forStmt(t shaderir.Type, index, init, end int, op shaderir.Op, delta int, block *shaderir.Block) shaderir.Stmt {
return shaderir.Stmt{
Type: shaderir.For,
Blocks: []*shaderir.Block{block},
ForVarType: t,
ForVarIndex: index,
ForInit: constant.MakeInt64(int64(init)),
@ -80,74 +80,74 @@ func forStmt(t Type, index, init, end int, op Op, delta int, block *Block) Stmt
}
}
func floatExpr(value float32) Expr {
return Expr{
Type: NumberExpr,
func floatExpr(value float32) shaderir.Expr {
return shaderir.Expr{
Type: shaderir.NumberExpr,
Const: constant.MakeFloat64(float64(value)),
}
}
func uniformVariableExpr(index int) Expr {
return Expr{
Type: UniformVariable,
func uniformVariableExpr(index int) shaderir.Expr {
return shaderir.Expr{
Type: shaderir.UniformVariable,
Index: index,
}
}
func localVariableExpr(index int) Expr {
return Expr{
Type: LocalVariable,
func localVariableExpr(index int) shaderir.Expr {
return shaderir.Expr{
Type: shaderir.LocalVariable,
Index: index,
}
}
func builtinFuncExpr(f BuiltinFunc) Expr {
return Expr{
Type: BuiltinFuncExpr,
func builtinFuncExpr(f shaderir.BuiltinFunc) shaderir.Expr {
return shaderir.Expr{
Type: shaderir.BuiltinFuncExpr,
BuiltinFunc: f,
}
}
func swizzlingExpr(swizzling string) Expr {
return Expr{
Type: SwizzlingExpr,
func swizzlingExpr(swizzling string) shaderir.Expr {
return shaderir.Expr{
Type: shaderir.SwizzlingExpr,
Swizzling: swizzling,
}
}
func functionExpr(index int) Expr {
return Expr{
Type: FunctionExpr,
func functionExpr(index int) shaderir.Expr {
return shaderir.Expr{
Type: shaderir.FunctionExpr,
Index: index,
}
}
func binaryExpr(op Op, exprs ...Expr) Expr {
return Expr{
Type: Binary,
func binaryExpr(op shaderir.Op, exprs ...shaderir.Expr) shaderir.Expr {
return shaderir.Expr{
Type: shaderir.Binary,
Op: op,
Exprs: exprs,
}
}
func selectionExpr(cond, a, b Expr) Expr {
return Expr{
Type: Selection,
Exprs: []Expr{cond, a, b},
func selectionExpr(cond, a, b shaderir.Expr) shaderir.Expr {
return shaderir.Expr{
Type: shaderir.Selection,
Exprs: []shaderir.Expr{cond, a, b},
}
}
func callExpr(callee Expr, args ...Expr) Expr {
return Expr{
Type: Call,
Exprs: append([]Expr{callee}, args...),
func callExpr(callee shaderir.Expr, args ...shaderir.Expr) shaderir.Expr {
return shaderir.Expr{
Type: shaderir.Call,
Exprs: append([]shaderir.Expr{callee}, args...),
}
}
func fieldSelectorExpr(a, b Expr) Expr {
return Expr{
Type: FieldSelector,
Exprs: []Expr{a, b},
func fieldSelectorExpr(a, b shaderir.Expr) shaderir.Expr {
return shaderir.Expr{
Type: shaderir.FieldSelector,
Exprs: []shaderir.Expr{a, b},
}
}
@ -156,22 +156,22 @@ func TestOutput(t *testing.T) {
tests := []struct {
Name string
Program Program
Program shaderir.Program
GlslVS string
GlslFS string
Metal string
}{
{
Name: "Empty",
Program: Program{},
Program: shaderir.Program{},
GlslVS: ``,
GlslFS: glsl.FragmentPrelude(glsl.GLSLVersionDefault),
},
{
Name: "Uniform",
Program: Program{
Uniforms: []Type{
{Main: Float},
Program: shaderir.Program{
Uniforms: []shaderir.Type{
{Main: shaderir.Float},
},
},
GlslVS: `uniform float U0;`,
@ -180,12 +180,12 @@ uniform float U0;`,
},
{
Name: "UniformStruct",
Program: Program{
Uniforms: []Type{
Program: shaderir.Program{
Uniforms: []shaderir.Type{
{
Main: Struct,
Sub: []Type{
{Main: Float},
Main: shaderir.Struct,
Sub: []shaderir.Type{
{Main: shaderir.Float},
},
},
},
@ -204,15 +204,15 @@ uniform S0 U0;`,
},
{
Name: "Vars",
Program: Program{
Uniforms: []Type{
{Main: Float},
Program: shaderir.Program{
Uniforms: []shaderir.Type{
{Main: shaderir.Float},
},
Attributes: []Type{
{Main: Vec2},
Attributes: []shaderir.Type{
{Main: shaderir.Vec2},
},
Varyings: []Type{
{Main: Vec3},
Varyings: []shaderir.Type{
{Main: shaderir.Vec3},
},
},
GlslVS: `uniform float U0;
@ -224,8 +224,8 @@ varying vec3 V0;`,
},
{
Name: "Func",
Program: Program{
Funcs: []Func{
Program: shaderir.Program{
Funcs: []shaderir.Func{
{
Index: 0,
},
@ -243,17 +243,17 @@ void F0(void) {
},
{
Name: "FuncParams",
Program: Program{
Funcs: []Func{
Program: shaderir.Program{
Funcs: []shaderir.Func{
{
Index: 0,
InParams: []Type{
{Main: Float},
{Main: Vec2},
{Main: Vec4},
InParams: []shaderir.Type{
{Main: shaderir.Float},
{Main: shaderir.Vec2},
{Main: shaderir.Vec4},
},
OutParams: []Type{
{Main: Mat4},
OutParams: []shaderir.Type{
{Main: shaderir.Mat4},
},
},
},
@ -270,14 +270,14 @@ void F0(in float l0, in vec2 l1, in vec4 l2, out mat4 l3) {
},
{
Name: "FuncReturn",
Program: Program{
Funcs: []Func{
Program: shaderir.Program{
Funcs: []shaderir.Func{
{
Index: 0,
InParams: []Type{
{Main: Float},
InParams: []shaderir.Type{
{Main: shaderir.Float},
},
Return: Type{Main: Float},
Return: shaderir.Type{Main: shaderir.Float},
Block: block(
nil,
1,
@ -302,19 +302,19 @@ float F0(in float l0) {
},
{
Name: "FuncLocals",
Program: Program{
Funcs: []Func{
Program: shaderir.Program{
Funcs: []shaderir.Func{
{
Index: 0,
InParams: []Type{
{Main: Float},
InParams: []shaderir.Type{
{Main: shaderir.Float},
},
OutParams: []Type{
{Main: Float},
OutParams: []shaderir.Type{
{Main: shaderir.Float},
},
Block: block([]Type{
{Main: Mat4},
{Main: Mat4},
Block: block([]shaderir.Type{
{Main: shaderir.Mat4},
{Main: shaderir.Mat4},
}, 2),
},
},
@ -335,27 +335,27 @@ void F0(in float l0, out float l1) {
},
{
Name: "FuncBlocks",
Program: Program{
Funcs: []Func{
Program: shaderir.Program{
Funcs: []shaderir.Func{
{
Index: 0,
InParams: []Type{
{Main: Float},
InParams: []shaderir.Type{
{Main: shaderir.Float},
},
OutParams: []Type{
{Main: Float},
OutParams: []shaderir.Type{
{Main: shaderir.Float},
},
Block: block(
[]Type{
{Main: Mat4},
{Main: Mat4},
[]shaderir.Type{
{Main: shaderir.Mat4},
{Main: shaderir.Mat4},
},
2,
blockStmt(
block(
[]Type{
{Main: Mat4},
{Main: Mat4},
[]shaderir.Type{
{Main: shaderir.Mat4},
{Main: shaderir.Mat4},
},
4,
),
@ -388,16 +388,16 @@ void F0(in float l0, out float l1) {
},
{
Name: "Add",
Program: Program{
Funcs: []Func{
Program: shaderir.Program{
Funcs: []shaderir.Func{
{
Index: 0,
InParams: []Type{
{Main: Float},
{Main: Float},
InParams: []shaderir.Type{
{Main: shaderir.Float},
{Main: shaderir.Float},
},
OutParams: []Type{
{Main: Float},
OutParams: []shaderir.Type{
{Main: shaderir.Float},
},
Block: block(
nil,
@ -405,7 +405,7 @@ void F0(in float l0, out float l1) {
assignStmt(
localVariableExpr(2),
binaryExpr(
Add,
shaderir.Add,
localVariableExpr(0),
localVariableExpr(1),
),
@ -428,17 +428,17 @@ void F0(in float l0, in float l1, out float l2) {
},
{
Name: "Selection",
Program: Program{
Funcs: []Func{
Program: shaderir.Program{
Funcs: []shaderir.Func{
{
Index: 0,
InParams: []Type{
{Main: Bool},
{Main: Float},
{Main: Float},
InParams: []shaderir.Type{
{Main: shaderir.Bool},
{Main: shaderir.Float},
{Main: shaderir.Float},
},
OutParams: []Type{
{Main: Float},
OutParams: []shaderir.Type{
{Main: shaderir.Float},
},
Block: block(
nil,
@ -469,16 +469,16 @@ void F0(in bool l0, in float l1, in float l2, out float l3) {
},
{
Name: "Call",
Program: Program{
Funcs: []Func{
Program: shaderir.Program{
Funcs: []shaderir.Func{
{
Index: 0,
InParams: []Type{
{Main: Float},
{Main: Float},
InParams: []shaderir.Type{
{Main: shaderir.Float},
{Main: shaderir.Float},
},
OutParams: []Type{
{Main: Vec2},
OutParams: []shaderir.Type{
{Main: shaderir.Vec2},
},
Block: block(
nil,
@ -516,16 +516,16 @@ void F0(in float l0, in float l1, out vec2 l2) {
},
{
Name: "BuiltinFunc",
Program: Program{
Funcs: []Func{
Program: shaderir.Program{
Funcs: []shaderir.Func{
{
Index: 0,
InParams: []Type{
{Main: Float},
{Main: Float},
InParams: []shaderir.Type{
{Main: shaderir.Float},
{Main: shaderir.Float},
},
OutParams: []Type{
{Main: Float},
OutParams: []shaderir.Type{
{Main: shaderir.Float},
},
Block: block(
nil,
@ -533,7 +533,7 @@ void F0(in float l0, in float l1, out vec2 l2) {
assignStmt(
localVariableExpr(2),
callExpr(
builtinFuncExpr(Min),
builtinFuncExpr(shaderir.Min),
localVariableExpr(0),
localVariableExpr(1),
),
@ -556,15 +556,15 @@ void F0(in float l0, in float l1, out float l2) {
},
{
Name: "FieldSelector",
Program: Program{
Funcs: []Func{
Program: shaderir.Program{
Funcs: []shaderir.Func{
{
Index: 0,
InParams: []Type{
{Main: Vec4},
InParams: []shaderir.Type{
{Main: shaderir.Vec4},
},
OutParams: []Type{
{Main: Vec2},
OutParams: []shaderir.Type{
{Main: shaderir.Vec2},
},
Block: block(
nil,
@ -594,23 +594,23 @@ void F0(in vec4 l0, out vec2 l1) {
},
{
Name: "If",
Program: Program{
Funcs: []Func{
Program: shaderir.Program{
Funcs: []shaderir.Func{
{
Index: 0,
InParams: []Type{
{Main: Float},
{Main: Float},
InParams: []shaderir.Type{
{Main: shaderir.Float},
{Main: shaderir.Float},
},
OutParams: []Type{
{Main: Float},
OutParams: []shaderir.Type{
{Main: shaderir.Float},
},
Block: block(
nil,
3,
ifStmt(
binaryExpr(
EqualOp,
shaderir.EqualOp,
localVariableExpr(0),
floatExpr(0),
),
@ -657,28 +657,28 @@ void F0(in float l0, in float l1, out float l2) {
},
{
Name: "For",
Program: Program{
Funcs: []Func{
Program: shaderir.Program{
Funcs: []shaderir.Func{
{
Index: 0,
InParams: []Type{
{Main: Float},
{Main: Float},
InParams: []shaderir.Type{
{Main: shaderir.Float},
{Main: shaderir.Float},
},
OutParams: []Type{
{Main: Float},
OutParams: []shaderir.Type{
{Main: shaderir.Float},
},
Block: block(
[]Type{
[]shaderir.Type{
{},
},
3,
forStmt(
Type{Main: Int},
shaderir.Type{Main: shaderir.Int},
3,
0,
100,
LessThanOp,
shaderir.LessThanOp,
1,
block(
nil,
@ -711,32 +711,32 @@ void F0(in float l0, in float l1, out float l2) {
},
{
Name: "For2",
Program: Program{
Funcs: []Func{
Program: shaderir.Program{
Funcs: []shaderir.Func{
{
Index: 0,
InParams: []Type{
{Main: Float},
{Main: Float},
InParams: []shaderir.Type{
{Main: shaderir.Float},
{Main: shaderir.Float},
},
OutParams: []Type{
{Main: Float},
OutParams: []shaderir.Type{
{Main: shaderir.Float},
},
Block: block(
[]Type{
[]shaderir.Type{
{},
},
3,
forStmt(
Type{Main: Int},
shaderir.Type{Main: shaderir.Int},
3,
0,
100,
LessThanOp,
shaderir.LessThanOp,
1,
block(
[]Type{
{Main: Int},
[]shaderir.Type{
{Main: shaderir.Int},
},
4,
assignStmt(
@ -783,33 +783,33 @@ void F0(float l0, float l1, thread float& l2) {
},
{
Name: "For3",
Program: Program{
Funcs: []Func{
Program: shaderir.Program{
Funcs: []shaderir.Func{
{
Index: 0,
InParams: []Type{
{Main: Float},
{Main: Float},
InParams: []shaderir.Type{
{Main: shaderir.Float},
{Main: shaderir.Float},
},
OutParams: []Type{
{Main: Float},
OutParams: []shaderir.Type{
{Main: shaderir.Float},
},
Block: block(
[]Type{
[]shaderir.Type{
{},
{},
},
3,
forStmt(
Type{Main: Int},
shaderir.Type{Main: shaderir.Int},
3,
0,
100,
LessThanOp,
shaderir.LessThanOp,
1,
block(
[]Type{
{Main: Int},
[]shaderir.Type{
{Main: shaderir.Int},
},
4,
assignStmt(
@ -819,15 +819,15 @@ void F0(float l0, float l1, thread float& l2) {
),
),
forStmt(
Type{Main: Float},
shaderir.Type{Main: shaderir.Float},
4,
0,
100,
LessThanOp,
shaderir.LessThanOp,
1,
block(
[]Type{
{Main: Int},
[]shaderir.Type{
{Main: shaderir.Int},
},
5,
assignStmt(
@ -886,20 +886,20 @@ void F0(float l0, float l1, thread float& l2) {
},
{
Name: "VertexFunc",
Program: Program{
Uniforms: []Type{
{Main: Float},
Program: shaderir.Program{
Uniforms: []shaderir.Type{
{Main: shaderir.Float},
},
Attributes: []Type{
{Main: Vec4},
{Main: Float},
{Main: Vec2},
Attributes: []shaderir.Type{
{Main: shaderir.Vec4},
{Main: shaderir.Float},
{Main: shaderir.Vec2},
},
Varyings: []Type{
{Main: Float},
{Main: Vec2},
Varyings: []shaderir.Type{
{Main: shaderir.Float},
{Main: shaderir.Vec2},
},
VertexFunc: VertexFunc{
VertexFunc: shaderir.VertexFunc{
Block: block(
nil,
4+1,
@ -937,20 +937,20 @@ varying vec2 V1;`,
},
{
Name: "FragmentFunc",
Program: Program{
Uniforms: []Type{
{Main: Float},
Program: shaderir.Program{
Uniforms: []shaderir.Type{
{Main: shaderir.Float},
},
Attributes: []Type{
{Main: Vec4},
{Main: Float},
{Main: Vec2},
Attributes: []shaderir.Type{
{Main: shaderir.Vec4},
{Main: shaderir.Float},
{Main: shaderir.Vec2},
},
Varyings: []Type{
{Main: Float},
{Main: Vec2},
Varyings: []shaderir.Type{
{Main: shaderir.Float},
{Main: shaderir.Vec2},
},
VertexFunc: VertexFunc{
VertexFunc: shaderir.VertexFunc{
Block: block(
nil,
5+1,
@ -968,11 +968,11 @@ varying vec2 V1;`,
),
),
},
FragmentFunc: FragmentFunc{
FragmentFunc: shaderir.FragmentFunc{
Block: block(
[]Type{
{Main: Float},
{Main: Vec2},
[]shaderir.Type{
{Main: shaderir.Float},
{Main: shaderir.Vec2},
},
3+1,
assignStmt(

188
shader_test.go
View File

@ -19,14 +19,14 @@ import (
"image/color"
"testing"
. "github.com/hajimehoshi/ebiten/v2"
"github.com/hajimehoshi/ebiten/v2"
)
func TestShaderFill(t *testing.T) {
const w, h = 16, 16
dst := NewImage(w, h)
s, err := NewShader([]byte(`package main
dst := ebiten.NewImage(w, h)
s, err := ebiten.NewShader([]byte(`package main
func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
return vec4(1, 0, 0, 1)
@ -55,8 +55,8 @@ func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
func TestShaderFillWithDrawImage(t *testing.T) {
const w, h = 16, 16
dst := NewImage(w, h)
s, err := NewShader([]byte(`package main
dst := ebiten.NewImage(w, h)
s, err := ebiten.NewShader([]byte(`package main
func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
return vec4(1, 0, 0, 1)
@ -66,8 +66,8 @@ func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
t.Fatal(err)
}
src := NewImage(w/2, h/2)
op := &DrawRectShaderOptions{}
src := ebiten.NewImage(w/2, h/2)
op := &ebiten.DrawRectShaderOptions{}
op.Images[0] = src
dst.DrawRectShader(w/2, h/2, s, op)
@ -88,8 +88,8 @@ func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
func TestShaderFillWithDrawTriangles(t *testing.T) {
const w, h = 16, 16
dst := NewImage(w, h)
s, err := NewShader([]byte(`package main
dst := ebiten.NewImage(w, h)
s, err := ebiten.NewShader([]byte(`package main
func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
return vec4(1, 0, 0, 1)
@ -99,11 +99,11 @@ func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
t.Fatal(err)
}
src := NewImage(w/2, h/2)
op := &DrawTrianglesShaderOptions{}
src := ebiten.NewImage(w/2, h/2)
op := &ebiten.DrawTrianglesShaderOptions{}
op.Images[0] = src
vs := []Vertex{
vs := []ebiten.Vertex{
{
DstX: 0,
DstY: 0,
@ -163,8 +163,8 @@ func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
func TestShaderFunction(t *testing.T) {
const w, h = 16, 16
dst := NewImage(w, h)
s, err := NewShader([]byte(`package main
dst := ebiten.NewImage(w, h)
s, err := ebiten.NewShader([]byte(`package main
func clr(red float) (float, float, float, float) {
return red, 0, 0, 1
@ -192,7 +192,7 @@ func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
}
func TestShaderShadowing(t *testing.T) {
if _, err := NewShader([]byte(`package main
if _, err := ebiten.NewShader([]byte(`package main
func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
var position vec4
@ -204,7 +204,7 @@ func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
}
func TestShaderDuplicatedVariables(t *testing.T) {
if _, err := NewShader([]byte(`package main
if _, err := ebiten.NewShader([]byte(`package main
func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
var foo vec4
@ -215,7 +215,7 @@ func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
t.Errorf("error must be non-nil but was nil")
}
if _, err := NewShader([]byte(`package main
if _, err := ebiten.NewShader([]byte(`package main
func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
var foo, foo vec4
@ -225,7 +225,7 @@ func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
t.Errorf("error must be non-nil but was nil")
}
if _, err := NewShader([]byte(`package main
if _, err := ebiten.NewShader([]byte(`package main
func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
var foo vec4
@ -236,7 +236,7 @@ func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
t.Errorf("error must be non-nil but was nil")
}
if _, err := NewShader([]byte(`package main
if _, err := ebiten.NewShader([]byte(`package main
func Foo() (vec4, vec4) {
return vec4(0), vec4(0)
@ -252,7 +252,7 @@ func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
}
func TestShaderDuplicatedFunctions(t *testing.T) {
if _, err := NewShader([]byte(`package main
if _, err := ebiten.NewShader([]byte(`package main
func Foo() {
}
@ -269,14 +269,14 @@ func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
}
func TestShaderNoMain(t *testing.T) {
if _, err := NewShader([]byte(`package main
if _, err := ebiten.NewShader([]byte(`package main
`)); err == nil {
t.Errorf("error must be non-nil but was nil")
}
}
func TestShaderNoNewVariables(t *testing.T) {
if _, err := NewShader([]byte(`package main
if _, err := ebiten.NewShader([]byte(`package main
func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
_ := 1
@ -286,7 +286,7 @@ func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
t.Errorf("error must be non-nil but was nil")
}
if _, err := NewShader([]byte(`package main
if _, err := ebiten.NewShader([]byte(`package main
func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
_, _ := 1, 1
@ -296,7 +296,7 @@ func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
t.Errorf("error must be non-nil but was nil")
}
if _, err := NewShader([]byte(`package main
if _, err := ebiten.NewShader([]byte(`package main
func Foo() (int, int) {
return 1, 1
@ -310,7 +310,7 @@ func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
t.Errorf("error must be non-nil but was nil")
}
if _, err := NewShader([]byte(`package main
if _, err := ebiten.NewShader([]byte(`package main
func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
a, _ := 1, 1
@ -321,7 +321,7 @@ func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
t.Error(err)
}
if _, err := NewShader([]byte(`package main
if _, err := ebiten.NewShader([]byte(`package main
func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
_, a := 1, 1
@ -334,7 +334,7 @@ func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
}
func TestShaderWrongReturn(t *testing.T) {
if _, err := NewShader([]byte(`package main
if _, err := ebiten.NewShader([]byte(`package main
func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
return 0.0
@ -343,7 +343,7 @@ func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
t.Errorf("error must be non-nil but was nil")
}
if _, err := NewShader([]byte(`package main
if _, err := ebiten.NewShader([]byte(`package main
func Foo() (float, float) {
return 0
@ -356,7 +356,7 @@ func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
t.Errorf("error must be non-nil but was nil")
}
if _, err := NewShader([]byte(`package main
if _, err := ebiten.NewShader([]byte(`package main
func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
}
@ -364,7 +364,7 @@ func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
t.Errorf("error must be non-nil but was nil")
}
if _, err := NewShader([]byte(`package main
if _, err := ebiten.NewShader([]byte(`package main
func Foo() float {
}
@ -378,7 +378,7 @@ func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
}
func TestShaderMultipleValueReturn(t *testing.T) {
if _, err := NewShader([]byte(`package main
if _, err := ebiten.NewShader([]byte(`package main
func Foo() (float, float) {
return 0.0
@ -391,7 +391,7 @@ func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
t.Errorf("error must be non-nil but was nil")
}
if _, err := NewShader([]byte(`package main
if _, err := ebiten.NewShader([]byte(`package main
func Foo() float {
return 0.0, 0.0
@ -404,7 +404,7 @@ func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
t.Errorf("error must be non-nil but was nil")
}
if _, err := NewShader([]byte(`package main
if _, err := ebiten.NewShader([]byte(`package main
func Foo() (float, float, float) {
return 0.0, 0.0
@ -417,7 +417,7 @@ func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
t.Errorf("error must be non-nil but was nil")
}
if _, err := NewShader([]byte(`package main
if _, err := ebiten.NewShader([]byte(`package main
func Foo() (float, float) {
return 0.0, 0.0
@ -434,7 +434,7 @@ func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
t.Errorf("error must be non-nil but was nil")
}
if _, err := NewShader([]byte(`package main
if _, err := ebiten.NewShader([]byte(`package main
func Foo() (float, float, float) {
return 0.0, 0.0, 0.0
@ -453,7 +453,7 @@ func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
}
func TestShaderInit(t *testing.T) {
if _, err := NewShader([]byte(`package main
if _, err := ebiten.NewShader([]byte(`package main
func init() {
}
@ -467,7 +467,7 @@ func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
}
func TestShaderUnspportedSyntax(t *testing.T) {
if _, err := NewShader([]byte(`package main
if _, err := ebiten.NewShader([]byte(`package main
func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
x := func() {
@ -479,7 +479,7 @@ func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
t.Errorf("error must be non-nil but was nil")
}
if _, err := NewShader([]byte(`package main
if _, err := ebiten.NewShader([]byte(`package main
func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
go func() {
@ -490,7 +490,7 @@ func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
t.Errorf("error must be non-nil but was nil")
}
if _, err := NewShader([]byte(`package main
if _, err := ebiten.NewShader([]byte(`package main
func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
ch := make(chan int)
@ -501,7 +501,7 @@ func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
t.Errorf("error must be non-nil but was nil")
}
if _, err := NewShader([]byte(`package main
if _, err := ebiten.NewShader([]byte(`package main
func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
x := 1i
@ -512,7 +512,7 @@ func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
t.Errorf("error must be non-nil but was nil")
}
if _, err := NewShader([]byte(`package main
if _, err := ebiten.NewShader([]byte(`package main
func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
var x [4]float
@ -524,7 +524,7 @@ func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
t.Errorf("error must be non-nil but was nil")
}
if _, err := NewShader([]byte(`package main
if _, err := ebiten.NewShader([]byte(`package main
func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
var x [4]float
@ -540,8 +540,8 @@ func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
func TestShaderUninitializedUniformVariables(t *testing.T) {
const w, h = 16, 16
dst := NewImage(w, h)
s, err := NewShader([]byte(`package main
dst := ebiten.NewImage(w, h)
s, err := ebiten.NewShader([]byte(`package main
var U vec4
@ -567,7 +567,7 @@ func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
}
func TestShaderForbidAssigningSpecialVariables(t *testing.T) {
if _, err := NewShader([]byte(`package main
if _, err := ebiten.NewShader([]byte(`package main
var U vec4
@ -579,7 +579,7 @@ func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
t.Errorf("error must be non-nil but was nil")
}
if _, err := NewShader([]byte(`package main
if _, err := ebiten.NewShader([]byte(`package main
var U vec4
@ -591,7 +591,7 @@ func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
t.Errorf("error must be non-nil but was nil")
}
if _, err := NewShader([]byte(`package main
if _, err := ebiten.NewShader([]byte(`package main
var U [2]vec4
@ -603,7 +603,7 @@ func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
t.Errorf("error must be non-nil but was nil")
}
if _, err := NewShader([]byte(`package main
if _, err := ebiten.NewShader([]byte(`package main
func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
texCoord = vec2(0)
@ -613,7 +613,7 @@ func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
t.Errorf("error must be non-nil but was nil")
}
if _, err := NewShader([]byte(`package main
if _, err := ebiten.NewShader([]byte(`package main
func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
texCoord.x = 0
@ -625,7 +625,7 @@ func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
}
func TestShaderBoolLiteral(t *testing.T) {
if _, err := NewShader([]byte(`package main
if _, err := ebiten.NewShader([]byte(`package main
func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
true := vec4(0)
@ -637,7 +637,7 @@ func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
}
func TestShaderUnusedVariable(t *testing.T) {
if _, err := NewShader([]byte(`package main
if _, err := ebiten.NewShader([]byte(`package main
func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
x := 0
@ -647,7 +647,7 @@ func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
t.Errorf("error must be non-nil but was nil")
}
if _, err := NewShader([]byte(`package main
if _, err := ebiten.NewShader([]byte(`package main
func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
x := 0
@ -658,7 +658,7 @@ func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
t.Errorf("error must be non-nil but was nil")
}
if _, err := NewShader([]byte(`package main
if _, err := ebiten.NewShader([]byte(`package main
func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
x := vec4(0)
@ -671,7 +671,7 @@ func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
// Increment statement treats a variable 'used'.
// https://play.golang.org/p/2RuYMrSLjt3
if _, err := NewShader([]byte(`package main
if _, err := ebiten.NewShader([]byte(`package main
func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
x := 0
@ -682,7 +682,7 @@ func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
t.Error(err)
}
if _, err := NewShader([]byte(`package main
if _, err := ebiten.NewShader([]byte(`package main
func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
var a int
@ -692,7 +692,7 @@ func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
t.Errorf("error must be non-nil but was nil")
}
if _, err := NewShader([]byte(`package main
if _, err := ebiten.NewShader([]byte(`package main
func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
var a, b int
@ -704,7 +704,7 @@ func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
}
func TestShaderBlankLhs(t *testing.T) {
if _, err := NewShader([]byte(`package main
if _, err := ebiten.NewShader([]byte(`package main
func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
x := _
@ -715,7 +715,7 @@ func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
t.Errorf("error must be non-nil but was nil")
}
if _, err := NewShader([]byte(`package main
if _, err := ebiten.NewShader([]byte(`package main
func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
var x int = _
@ -726,7 +726,7 @@ func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
t.Errorf("error must be non-nil but was nil")
}
if _, err := NewShader([]byte(`package main
if _, err := ebiten.NewShader([]byte(`package main
func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
x := 1
@ -738,7 +738,7 @@ func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
t.Errorf("error must be non-nil but was nil")
}
if _, err := NewShader([]byte(`package main
if _, err := ebiten.NewShader([]byte(`package main
func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
x := 1 + _
@ -749,7 +749,7 @@ func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
t.Errorf("error must be non-nil but was nil")
}
if _, err := NewShader([]byte(`package main
if _, err := ebiten.NewShader([]byte(`package main
func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
_++
@ -759,7 +759,7 @@ func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
t.Errorf("error must be non-nil but was nil")
}
if _, err := NewShader([]byte(`package main
if _, err := ebiten.NewShader([]byte(`package main
func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
_ += 1
@ -769,7 +769,7 @@ func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
t.Errorf("error must be non-nil but was nil")
}
if _, err := NewShader([]byte(`package main
if _, err := ebiten.NewShader([]byte(`package main
func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
_.x = 1
@ -781,7 +781,7 @@ func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
}
func TestShaderDuplicatedVarsAndConstants(t *testing.T) {
if _, err := NewShader([]byte(`package main
if _, err := ebiten.NewShader([]byte(`package main
func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
var a = 0
@ -792,7 +792,7 @@ func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
t.Errorf("error must be non-nil but was nil")
}
if _, err := NewShader([]byte(`package main
if _, err := ebiten.NewShader([]byte(`package main
func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
const a = 0
@ -803,7 +803,7 @@ func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
t.Errorf("error must be non-nil but was nil")
}
if _, err := NewShader([]byte(`package main
if _, err := ebiten.NewShader([]byte(`package main
func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
const a = 0
@ -814,7 +814,7 @@ func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
t.Errorf("error must be non-nil but was nil")
}
if _, err := NewShader([]byte(`package main
if _, err := ebiten.NewShader([]byte(`package main
const U0 = 0
var U0 float
@ -826,7 +826,7 @@ func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
t.Errorf("error must be non-nil but was nil")
}
if _, err := NewShader([]byte(`package main
if _, err := ebiten.NewShader([]byte(`package main
var U0 float
const U0 = 0
@ -842,8 +842,8 @@ func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
func TestShaderMatrix(t *testing.T) {
const w, h = 16, 16
dst := NewImage(w, h)
s, err := NewShader([]byte(`package main
dst := ebiten.NewImage(w, h)
s, err := ebiten.NewShader([]byte(`package main
func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
var a, b mat4
@ -862,8 +862,8 @@ func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
t.Fatal(err)
}
src := NewImage(w, h)
op := &DrawRectShaderOptions{}
src := ebiten.NewImage(w, h)
op := &ebiten.DrawRectShaderOptions{}
op.Images[0] = src
dst.DrawRectShader(w, h, s, op)
@ -881,7 +881,7 @@ func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
func TestShaderSubImage(t *testing.T) {
const w, h = 16, 16
s, err := NewShader([]byte(`package main
s, err := ebiten.NewShader([]byte(`package main
func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
r := imageSrc0At(texCoord).r
@ -893,7 +893,7 @@ func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
t.Fatal(err)
}
src0 := NewImage(w, h)
src0 := ebiten.NewImage(w, h)
pix0 := make([]byte, 4*w*h)
for j := 0; j < h; j++ {
for i := 0; i < w; i++ {
@ -906,9 +906,9 @@ func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
}
}
src0.ReplacePixels(pix0)
src0 = src0.SubImage(image.Rect(2, 3, 10, 11)).(*Image)
src0 = src0.SubImage(image.Rect(2, 3, 10, 11)).(*ebiten.Image)
src1 := NewImage(w, h)
src1 := ebiten.NewImage(w, h)
pix1 := make([]byte, 4*w*h)
for j := 0; j < h; j++ {
for i := 0; i < w; i++ {
@ -921,9 +921,9 @@ func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
}
}
src1.ReplacePixels(pix1)
src1 = src1.SubImage(image.Rect(6, 8, 14, 16)).(*Image)
src1 = src1.SubImage(image.Rect(6, 8, 14, 16)).(*ebiten.Image)
testPixels := func(testname string, dst *Image) {
testPixels := func(testname string, dst *ebiten.Image) {
for j := 0; j < h; j++ {
for i := 0; i < w; i++ {
got := dst.At(i, j).(color.RGBA)
@ -939,8 +939,8 @@ func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
}
t.Run("DrawRectShader", func(t *testing.T) {
dst := NewImage(w, h)
op := &DrawRectShaderOptions{}
dst := ebiten.NewImage(w, h)
op := &ebiten.DrawRectShaderOptions{}
op.Images[0] = src0
op.Images[1] = src1
dst.DrawRectShader(w/2, h/2, s, op)
@ -948,8 +948,8 @@ func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
})
t.Run("DrawTrianglesShader", func(t *testing.T) {
dst := NewImage(w, h)
vs := []Vertex{
dst := ebiten.NewImage(w, h)
vs := []ebiten.Vertex{
{
DstX: 0,
DstY: 0,
@ -993,7 +993,7 @@ func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
}
is := []uint16{0, 1, 2, 1, 2, 3}
op := &DrawTrianglesShaderOptions{}
op := &ebiten.DrawTrianglesShaderOptions{}
op.Images[0] = src0
op.Images[1] = src1
dst.DrawTrianglesShader(vs, is, s, op)
@ -1005,7 +1005,7 @@ func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
func TestShaderDerivatives(t *testing.T) {
const w, h = 16, 16
s, err := NewShader([]byte(`package main
s, err := ebiten.NewShader([]byte(`package main
func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
p := imageSrc0At(texCoord)
@ -1016,8 +1016,8 @@ func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
t.Fatal(err)
}
dst := NewImage(w, h)
src := NewImage(w, h)
dst := ebiten.NewImage(w, h)
src := ebiten.NewImage(w, h)
pix := make([]byte, 4*w*h)
for j := 0; j < h; j++ {
for i := 0; i < w; i++ {
@ -1032,7 +1032,7 @@ func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
}
src.ReplacePixels(pix)
op := &DrawRectShaderOptions{}
op := &ebiten.DrawRectShaderOptions{}
op.Images[0] = src
dst.DrawRectShader(w, h, s, op)
@ -1058,7 +1058,7 @@ func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
func TestShaderDerivatives2(t *testing.T) {
const w, h = 16, 16
s, err := NewShader([]byte(`package main
s, err := ebiten.NewShader([]byte(`package main
// This function uses dfdx and then should not be in GLSL's vertex shader (#1701).
func Foo(p vec4) vec4 {
@ -1074,8 +1074,8 @@ func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
t.Fatal(err)
}
dst := NewImage(w, h)
src := NewImage(w, h)
dst := ebiten.NewImage(w, h)
src := ebiten.NewImage(w, h)
pix := make([]byte, 4*w*h)
for j := 0; j < h; j++ {
for i := 0; i < w; i++ {
@ -1090,7 +1090,7 @@ func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
}
src.ReplacePixels(pix)
op := &DrawRectShaderOptions{}
op := &ebiten.DrawRectShaderOptions{}
op.Images[0] = src
dst.DrawRectShader(w, h, s, op)
@ -1165,13 +1165,13 @@ func Fragment(position vec4, texCoord vec2, color vec4) vec4 {
t.Run(shader.Name, func(t *testing.T) {
const w, h = 1, 1
dst := NewImage(w, h)
s, err := NewShader([]byte(shader.Shader))
dst := ebiten.NewImage(w, h)
s, err := ebiten.NewShader([]byte(shader.Shader))
if err != nil {
t.Fatal(err)
}
op := &DrawRectShaderOptions{}
op := &ebiten.DrawRectShaderOptions{}
op.Uniforms = shader.Uniforms
dst.DrawRectShader(w, h, s, op)
if got, want := dst.At(0, 0), (color.RGBA{0xff, 0xff, 0xff, 0xff}); got != want {

8
text/text_test.go
View File

@ -25,7 +25,7 @@ import (
"github.com/hajimehoshi/ebiten/v2"
t "github.com/hajimehoshi/ebiten/v2/internal/testing"
. "github.com/hajimehoshi/ebiten/v2/text"
"github.com/hajimehoshi/ebiten/v2/text"
)
func TestMain(m *testing.M) {
@ -35,7 +35,7 @@ func TestMain(m *testing.M) {
func TestTextColor(t *testing.T) {
clr := color.RGBA{0x80, 0x80, 0x80, 0x80}
img := ebiten.NewImage(30, 30)
Draw(img, "Hello", bitmapfont.Face, 12, 12, clr)
text.Draw(img, "Hello", bitmapfont.Face, 12, 12, clr)
w, h := img.Size()
allTransparent := true
@ -123,7 +123,7 @@ func TestTextOverlap(t *testing.T) {
// With testFace, 'b' is rendered at the previous position as 0xff.
// 'a' is rendered at the current position as 0x80.
Draw(dst, "ab", f, 0, 0, color.White)
text.Draw(dst, "ab", f, 0, 0, color.White)
for j := 0; j < testFaceSize; j++ {
for i := 0; i < testFaceSize; i++ {
got := dst.At(i, j)
@ -135,7 +135,7 @@ func TestTextOverlap(t *testing.T) {
}
// The glyph 'a' should be treated correctly.
Draw(dst, "a", f, testFaceSize, 0, color.White)
text.Draw(dst, "a", f, testFaceSize, 0, color.White)
for j := 0; j < testFaceSize; j++ {
for i := testFaceSize; i < testFaceSize*2; i++ {
got := dst.At(i, j)