Unify RenderTarget and Image into Image (#34)

hajimehoshi · Dec 22, 2014 · 0f8ac49 · 0f8ac49
1 parent f680986
commit 0f8ac49
Show file tree

Hide file tree

Showing 22 changed files with 131 additions and 133 deletions.
diff --git a/ebitenutil/debugprint.go b/ebitenutil/debugprint.go
@@ -24,18 +24,18 @@ import (
 )
 
 type debugPrintState struct {
-	textTexture            *ebiten.Image
-	debugPrintRenderTarget *ebiten.RenderTarget
+	textImage              *ebiten.Image
+	debugPrintRenderTarget *ebiten.Image
 	y                      int
 }
 
 var defaultDebugPrintState = new(debugPrintState)
 
-func DebugPrint(r *ebiten.RenderTarget, str string) {
+func DebugPrint(r *ebiten.Image, str string) {
 	defaultDebugPrintState.DebugPrint(r, str)
 }
 
-func (d *debugPrintState) drawText(rt *ebiten.RenderTarget, str string, x, y int, c color.Color) {
+func (d *debugPrintState) drawText(rt *ebiten.Image, str string, x, y int, c color.Color) {
 	parts := []ebiten.ImagePart{}
 	locationX, locationY := 0, 0
 	for _, c := range str {
@@ -57,24 +57,24 @@ func (d *debugPrintState) drawText(rt *ebiten.RenderTarget, str string, x, y int
 	geo := ebiten.TranslateGeometry(float64(x)+1, float64(y))
 	r, g, b, a := internal.RGBA(c)
 	clr := ebiten.ScaleColor(r, g, b, a)
-	rt.DrawImage(d.textTexture, parts, geo, clr)
+	rt.DrawImage(d.textImage, parts, geo, clr)
 }
 
-func (d *debugPrintState) DebugPrint(r *ebiten.RenderTarget, str string) {
-	if d.textTexture == nil {
+func (d *debugPrintState) DebugPrint(r *ebiten.Image, str string) {
+	if d.textImage == nil {
 		img, err := assets.TextImage()
 		if err != nil {
 			panic(err)
 		}
-		d.textTexture, err = ebiten.NewImage(img, ebiten.FilterNearest)
+		d.textImage, err = ebiten.NewImageFromImage(img, ebiten.FilterNearest)
 		if err != nil {
 			panic(err)
 		}
 	}
 	if d.debugPrintRenderTarget == nil {
 		width, height := 256, 256
 		var err error
-		d.debugPrintRenderTarget, err = ebiten.NewRenderTarget(width, height, ebiten.FilterNearest)
+		d.debugPrintRenderTarget, err = ebiten.NewImage(width, height, ebiten.FilterNearest)
 		if err != nil {
 			panic(err)
 		}

diff --git a/ebitenutil/image.go b/ebitenutil/image.go
@@ -32,9 +32,9 @@ func NewImageFromFile(path string, filter ebiten.Filter) (*ebiten.Image, image.I
 	if err != nil {
 		return nil, nil, err
 	}
-	texture, err := ebiten.NewImage(img, filter)
+	img2, err := ebiten.NewImageFromImage(img, filter)
 	if err != nil {
 		return nil, nil, err
 	}
-	return texture, img, err
+	return img2, img, err
 }
diff --git a/example/alphablending/main.go b/example/alphablending/main.go
@@ -31,11 +31,11 @@ const (
 
 type Game struct {
 	count           int
-	tmpRenderTarget *ebiten.RenderTarget
+	tmpRenderTarget *ebiten.Image
 	ebitenImage     *ebiten.Image
 }
 
-func (g *Game) Update(r *ebiten.RenderTarget) error {
+func (g *Game) Update(r *ebiten.Image) error {
 	g.count++
 	g.count %= 600
 	diff := float64(g.count) * 0.2
@@ -62,7 +62,7 @@ func (g *Game) Update(r *ebiten.RenderTarget) error {
 	for i := 0; i < 10; i++ {
 		geo := ebiten.TranslateGeometry(0, float64(i)*(diff))
 		clr := ebiten.ColorMatrixI()
-		if err := ebiten.DrawWholeImage(r, g.tmpRenderTarget.Image(), geo, clr); err != nil {
+		if err := ebiten.DrawWholeImage(r, g.tmpRenderTarget, geo, clr); err != nil {
 			return err
 		}
 	}
@@ -76,7 +76,7 @@ func main() {
 	if err != nil {
 		log.Fatal(err)
 	}
-	g.tmpRenderTarget, err = ebiten.NewRenderTarget(screenWidth, screenHeight, ebiten.FilterNearest)
+	g.tmpRenderTarget, err = ebiten.NewImage(screenWidth, screenHeight, ebiten.FilterNearest)
 	if err != nil {
 		log.Fatal(err)
 	}

diff --git a/example/blocks/blocks/field.go b/example/blocks/blocks/field.go
@@ -112,7 +112,7 @@ func (f *Field) flushLine(j int) bool {
 	return true
 }
 
-func (f *Field) Draw(r *ebiten.RenderTarget, images *Images, geo ebiten.GeometryMatrix) {
+func (f *Field) Draw(r *ebiten.Image, images *Images, geo ebiten.GeometryMatrix) {
 	blocks := make([][]BlockType, len(f.blocks))
 	for i, blockCol := range f.blocks {
 		blocks[i] = make([]BlockType, len(blockCol))

diff --git a/example/blocks/blocks/font.go b/example/blocks/blocks/font.go
@@ -33,7 +33,7 @@ func textWidth(str string) int {
 	return charWidth * len(str)
 }
 
-func drawText(rt *ebiten.RenderTarget, images *Images, str string, ox, oy, scale int, c color.Color) {
+func drawText(rt *ebiten.Image, images *Images, str string, ox, oy, scale int, c color.Color) {
 	fontImageId := images.GetImage("font")
 	parts := []ebiten.ImagePart{}
 
@@ -66,7 +66,7 @@ func drawText(rt *ebiten.RenderTarget, images *Images, str string, ox, oy, scale
 	rt.DrawImage(fontImageId, parts, geo, clr)
 }
 
-func drawTextWithShadow(rt *ebiten.RenderTarget, images *Images, str string, x, y, scale int, clr color.Color) {
+func drawTextWithShadow(rt *ebiten.Image, images *Images, str string, x, y, scale int, clr color.Color) {
 	drawText(rt, images, str, x+1, y+1, scale, color.NRGBA{0, 0, 0, 0x80})
 	drawText(rt, images, str, x, y, scale, clr)
 }
diff --git a/example/blocks/blocks/game.go b/example/blocks/blocks/game.go
@@ -70,7 +70,7 @@ func (game *Game) isInitialized() bool {
 	return true
 }
 
-func (game *Game) Update(r *ebiten.RenderTarget) error {
+func (game *Game) Update(r *ebiten.Image) error {
 	game.once.Do(func() {
 		game.images = NewImages()
 		for name, path := range imagePaths {

diff --git a/example/blocks/blocks/gamescene.go b/example/blocks/blocks/gamescene.go
@@ -109,7 +109,7 @@ func (s *GameScene) Update(state *GameState) {
 	}
 }
 
-func (s *GameScene) Draw(r *ebiten.RenderTarget, images *Images) {
+func (s *GameScene) Draw(r *ebiten.Image, images *Images) {
 	r.Fill(color.White)
 
 	field := images.GetImage("empty")

diff --git a/example/blocks/blocks/images.go b/example/blocks/blocks/images.go
@@ -38,7 +38,7 @@ type Images struct {
 	imagePaths        chan namePath
 	renderTargetSizes chan nameSize
 	images            map[string]*ebiten.Image
-	renderTargets     map[string]*ebiten.RenderTarget
+	renderTargets     map[string]*ebiten.Image
 	sync.RWMutex
 }
 
@@ -47,7 +47,7 @@ func NewImages() *Images {
 		imagePaths:        make(chan namePath),
 		renderTargetSizes: make(chan nameSize),
 		images:            map[string]*ebiten.Image{},
-		renderTargets:     map[string]*ebiten.RenderTarget{},
+		renderTargets:     map[string]*ebiten.Image{},
 	}
 	go func() {
 		for {
@@ -81,7 +81,7 @@ func (i *Images) loopMain() {
 			if err != nil {
 				panic(err)
 			}
-			id, err := ebiten.NewImage(img, ebiten.FilterNearest)
+			id, err := ebiten.NewImageFromImage(img, ebiten.FilterNearest)
 			if err != nil {
 				panic(err)
 			}
@@ -93,7 +93,7 @@ func (i *Images) loopMain() {
 		name := s.name
 		size := s.size
 		go func() {
-			id, err := ebiten.NewRenderTarget(size.Width, size.Height, ebiten.FilterNearest)
+			id, err := ebiten.NewImage(size.Width, size.Height, ebiten.FilterNearest)
 			if err != nil {
 				panic(err)
 			}
@@ -129,7 +129,7 @@ func (i *Images) GetImage(name string) *ebiten.Image {
 	return i.images[name]
 }
 
-func (i *Images) GetRenderTarget(name string) *ebiten.RenderTarget {
+func (i *Images) GetRenderTarget(name string) *ebiten.Image {
 	i.RLock()
 	defer i.RUnlock()
 	return i.renderTargets[name]

diff --git a/example/blocks/blocks/piece.go b/example/blocks/blocks/piece.go
@@ -138,7 +138,7 @@ const blockHeight = 10
 const fieldBlockNumX = 10
 const fieldBlockNumY = 20
 
-func drawBlocks(r *ebiten.RenderTarget, images *Images, blocks [][]BlockType, geo ebiten.GeometryMatrix) {
+func drawBlocks(r *ebiten.Image, images *Images, blocks [][]BlockType, geo ebiten.GeometryMatrix) {
 	parts := []ebiten.ImagePart{}
 	for i, blockCol := range blocks {
 		for j, block := range blockCol {
@@ -213,7 +213,7 @@ func (p *Piece) AbsorbInto(field *Field, x, y int, angle Angle) {
 	}
 }
 
-func (p *Piece) Draw(r *ebiten.RenderTarget, images *Images, fieldX, fieldY int, pieceX, pieceY int, angle Angle) {
+func (p *Piece) Draw(r *ebiten.Image, images *Images, fieldX, fieldY int, pieceX, pieceY int, angle Angle) {
 	size := len(p.blocks)
 	blocks := make([][]BlockType, size)
 	for i := range p.blocks {

diff --git a/example/blocks/blocks/scenemanager.go b/example/blocks/blocks/scenemanager.go
@@ -29,7 +29,7 @@ func init() {
 
 type Scene interface {
 	Update(state *GameState)
-	Draw(r *ebiten.RenderTarget, images *Images)
+	Draw(r *ebiten.Image, images *Images)
 }
 
 const transitionMaxCount = 20
@@ -60,7 +60,7 @@ func (s *SceneManager) Update(state *GameState) {
 	}
 }
 
-func (s *SceneManager) Draw(r *ebiten.RenderTarget, images *Images) {
+func (s *SceneManager) Draw(r *ebiten.Image, images *Images) {
 	if s.transitionCount == -1 {
 		s.current.Draw(r, images)
 		return
@@ -74,11 +74,11 @@ func (s *SceneManager) Draw(r *ebiten.RenderTarget, images *Images) {
 	s.next.Draw(to, images)
 
 	color := ebiten.ColorMatrixI()
-	ebiten.DrawWholeImage(r, from.Image(), ebiten.GeometryMatrixI(), color)
+	ebiten.DrawWholeImage(r, from, ebiten.GeometryMatrixI(), color)
 
 	alpha := float64(s.transitionCount) / float64(transitionMaxCount)
 	color.Elements[3][3] = alpha
-	ebiten.DrawWholeImage(r, to.Image(), ebiten.GeometryMatrixI(), color)
+	ebiten.DrawWholeImage(r, to, ebiten.GeometryMatrixI(), color)
 }
 
 func (s *SceneManager) GoTo(scene Scene) {

diff --git a/example/blocks/blocks/titlescene.go b/example/blocks/blocks/titlescene.go
@@ -40,7 +40,7 @@ func (s *TitleScene) Update(state *GameState) {
 	}
 }
 
-func (s *TitleScene) Draw(r *ebiten.RenderTarget, images *Images) {
+func (s *TitleScene) Draw(r *ebiten.Image, images *Images) {
 	drawTitleBackground(r, images, s.count)
 	drawLogo(r, images, "BLOCKS")
 
@@ -50,7 +50,7 @@ func (s *TitleScene) Draw(r *ebiten.RenderTarget, images *Images) {
 	drawTextWithShadow(r, images, message, x, y, 1, color.NRGBA{0x80, 0, 0, 0xff})
 }
 
-func drawTitleBackground(r *ebiten.RenderTarget, images *Images, c int) {
+func drawTitleBackground(r *ebiten.Image, images *Images, c int) {
 	const imageWidth = 32
 	const imageHeight = 32
 
@@ -73,7 +73,7 @@ func drawTitleBackground(r *ebiten.RenderTarget, images *Images, c int) {
 	r.DrawImage(backgroundImage, parts, geo, clr)
 }
 
-func drawLogo(r *ebiten.RenderTarget, images *Images, str string) {
+func drawLogo(r *ebiten.Image, images *Images, str string) {
 	scale := 4
 	textWidth := textWidth(str) * scale
 	x := (ScreenWidth - textWidth) / 2

diff --git a/example/image/main.go b/example/image/main.go
@@ -36,7 +36,7 @@ type Game struct {
 	gophersImage    *ebiten.Image
 }
 
-func (g *Game) Update(r *ebiten.RenderTarget) error {
+func (g *Game) Update(r *ebiten.Image) error {
 	g.count++
 	if ebiten.IsKeyPressed(ebiten.KeyLeft) {
 		g.horizontalCount--
@@ -60,7 +60,9 @@ func (g *Game) Update(r *ebiten.RenderTarget) error {
 	geo.Concat(ebiten.TranslateGeometry(screenWidth/2, screenHeight/2))
 	//clr := ebiten.RotateHue(float64(g.count%180) * 2 * math.Pi / 180)
 	clr := ebiten.ColorMatrixI()
-	ebiten.DrawWholeImage(r, g.gophersImage, geo, clr)
+	if err := ebiten.DrawWholeImage(r, g.gophersImage, geo, clr); err != nil {
+		return err
+	}
 	return nil
 }
 

diff --git a/example/mosaic/main.go b/example/mosaic/main.go
@@ -32,15 +32,15 @@ const mosaicRatio = 16
 
 type Game struct {
 	gophersImage        *ebiten.Image
-	gophersRenderTarget *ebiten.RenderTarget
+	gophersRenderTarget *ebiten.Image
 }
 
-func (g *Game) Update(r *ebiten.RenderTarget) error {
+func (g *Game) Update(r *ebiten.Image) error {
 	geo := ebiten.ScaleGeometry(1.0/mosaicRatio, 1.0/mosaicRatio)
 	ebiten.DrawWholeImage(g.gophersRenderTarget, g.gophersImage, geo, ebiten.ColorMatrixI())
 
 	geo = ebiten.ScaleGeometry(mosaicRatio/2.0, mosaicRatio/2.0)
-	ebiten.DrawWholeImage(r, g.gophersRenderTarget.Image(), geo, ebiten.ColorMatrixI())
+	ebiten.DrawWholeImage(r, g.gophersRenderTarget, geo, ebiten.ColorMatrixI())
 	return nil
 }
 
@@ -52,7 +52,7 @@ func main() {
 		log.Fatal(err)
 	}
 	w, h := g.gophersImage.Size()
-	g.gophersRenderTarget, err = ebiten.NewRenderTarget(w/mosaicRatio, h/mosaicRatio, ebiten.FilterNearest)
+	g.gophersRenderTarget, err = ebiten.NewImage(w/mosaicRatio, h/mosaicRatio, ebiten.FilterNearest)
 	if err != nil {
 		log.Fatal(err)
 	}

diff --git a/example/paint/main.go b/example/paint/main.go
@@ -33,11 +33,11 @@ const (
 type Game struct {
 	inited             bool
 	count              int
-	brushRenderTarget  *ebiten.RenderTarget
-	canvasRenderTarget *ebiten.RenderTarget
+	brushRenderTarget  *ebiten.Image
+	canvasRenderTarget *ebiten.Image
 }
 
-func (g *Game) Update(r *ebiten.RenderTarget) error {
+func (g *Game) Update(r *ebiten.Image) error {
 	if ebiten.IsMouseButtonPressed(ebiten.MouseButtonLeft) {
 		g.count++
 	}
@@ -54,10 +54,10 @@ func (g *Game) Update(r *ebiten.RenderTarget) error {
 		clr := ebiten.ScaleColor(1.0, 0.25, 0.25, 1.0)
 		theta := 2.0 * math.Pi * float64(g.count%60) / 60.0
 		clr.Concat(ebiten.RotateHue(theta))
-		ebiten.DrawWholeImage(g.canvasRenderTarget, g.brushRenderTarget.Image(), geo, clr)
+		ebiten.DrawWholeImage(g.canvasRenderTarget, g.brushRenderTarget, geo, clr)
 	}
 
-	ebiten.DrawWholeImage(r, g.canvasRenderTarget.Image(), ebiten.GeometryMatrixI(), ebiten.ColorMatrixI())
+	ebiten.DrawWholeImage(r, g.canvasRenderTarget, ebiten.GeometryMatrixI(), ebiten.ColorMatrixI())
 
 	ebitenutil.DebugPrint(r, fmt.Sprintf("(%d, %d)", mx, my))
 	return nil
@@ -66,11 +66,11 @@ func (g *Game) Update(r *ebiten.RenderTarget) error {
 func main() {
 	g := new(Game)
 	var err error
-	g.brushRenderTarget, err = ebiten.NewRenderTarget(1, 1, ebiten.FilterNearest)
+	g.brushRenderTarget, err = ebiten.NewImage(1, 1, ebiten.FilterNearest)
 	if err != nil {
 		log.Fatal(err)
 	}
-	g.canvasRenderTarget, err = ebiten.NewRenderTarget(screenWidth, screenHeight, ebiten.FilterNearest)
+	g.canvasRenderTarget, err = ebiten.NewImage(screenWidth, screenHeight, ebiten.FilterNearest)
 	if err != nil {
 		log.Fatal(err)
 	}

diff --git a/example/perspective/main.go b/example/perspective/main.go
@@ -32,7 +32,7 @@ type Game struct {
 	gophersImage *ebiten.Image
 }
 
-func (g *Game) Update(r *ebiten.RenderTarget) error {
+func (g *Game) Update(r *ebiten.Image) error {
 	parts := []ebiten.ImagePart{}
 	w, h := g.gophersImage.Size()
 	for i := 0; i < h; i++ {

diff --git a/gamecontext.go b/gamecontext.go
@@ -47,12 +47,12 @@ func glFilter(f Filter) int {
 	}
 }
 
-// NewRenderTarget returns a new RenderTarget.
-func NewRenderTarget(width, height int, filter Filter) (*RenderTarget, error) {
-	return currentUI.newRenderTarget(width, height, glFilter(filter))
+// NewImage returns an empty image.
+func NewImage(width, height int, filter Filter) (*Image, error) {
+	return currentUI.newImage(width, height, glFilter(filter))
 }
 
-// NewImage returns a new image.
-func NewImage(img image.Image, filter Filter) (*Image, error) {
-	return currentUI.newImage(img, glFilter(filter))
+// NewImage creates a new image with the given image (img).
+func NewImageFromImage(img image.Image, filter Filter) (*Image, error) {
+	return currentUI.newImageFromImage(img, glFilter(filter))
 }