ebiten/internal/restorable/image.go

661 lines
19 KiB
Go
Raw Normal View History

2016-07-16 21:41:28 +02:00
// Copyright 2016 The Ebiten Authors
2016-07-13 19:35:20 +02:00
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
2016-09-03 15:05:05 +02:00
package restorable
2016-07-13 19:35:20 +02:00
import (
"fmt"
"image/color"
2016-07-13 19:35:20 +02:00
2020-10-03 19:35:13 +02:00
"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"
2016-07-13 19:35:20 +02:00
)
2019-02-12 15:31:52 +01:00
type Pixels struct {
baseColor color.RGBA
rectToPixels *rectToPixels
2019-02-12 15:31:52 +01:00
}
// Apply applies the Pixels state to the given image especially for restoring.
func (p *Pixels) Apply(img *graphicscommand.Image) {
// Pixels doesn't clear the image. This is a caller's responsibility.
if p.baseColor != (color.RGBA{}) {
fillImage(img, p.baseColor)
}
if p.rectToPixels == nil {
return
}
p.rectToPixels.apply(img)
2019-02-12 15:31:52 +01:00
}
func (p *Pixels) AddOrReplace(pix []byte, x, y, width, height int) {
if p.rectToPixels == nil {
p.rectToPixels = &rectToPixels{}
2019-02-12 15:31:52 +01:00
}
p.rectToPixels.addOrReplace(pix, x, y, width, height)
}
func (p *Pixels) Remove(x, y, width, height int) {
// Note that we don't care whether the region is actually removed or not here. There is an actual case that
// the region is allocated but nothing is rendered. See TestDisposeImmediately at shareable package.
if p.rectToPixels == nil {
return
}
p.rectToPixels.remove(x, y, width, height)
}
func (p *Pixels) At(i, j int) (byte, byte, byte, byte) {
if p.rectToPixels != nil {
if r, g, b, a, ok := p.rectToPixels.at(i, j); ok {
return r, g, b, a
}
2019-02-12 15:31:52 +01:00
}
return p.baseColor.R, p.baseColor.G, p.baseColor.B, p.baseColor.A
2019-02-12 15:31:52 +01:00
}
// drawTrianglesHistoryItem is an item for history of draw-image commands.
type drawTrianglesHistoryItem struct {
images [graphics.ShaderImageNum]*Image
offsets [graphics.ShaderImageNum - 1][2]float32
vertices []float32
indices []uint16
colorm *affine.ColorM
mode driver.CompositeMode
filter driver.Filter
address driver.Address
sourceRegion driver.Region
shader *Shader
uniforms []interface{}
2016-07-13 19:35:20 +02:00
}
2016-09-09 18:36:56 +02:00
// Image represents an image that can be restored when GL context is lost.
2016-09-03 15:05:05 +02:00
type Image struct {
2018-10-28 12:10:05 +01:00
image *graphicscommand.Image
width int
height int
basePixels Pixels
2017-09-19 18:35:56 +02:00
// drawTrianglesHistory is a set of draw-image commands.
2017-09-21 16:33:27 +02:00
// TODO: This should be merged with the similar command queue in package graphics (#433).
drawTrianglesHistory []*drawTrianglesHistoryItem
2017-05-29 20:31:29 +02:00
// stale indicates whether the image needs to be synced with GPU as soon as possible.
stale bool
// volatile indicates whether the image is cleared whenever a frame starts.
volatile bool
2017-05-29 19:06:45 +02:00
// screen indicates whether the image is used as an actual screen.
screen bool
// priority indicates whether the image is restored in high priority when context-lost happens.
priority bool
2016-07-13 19:35:20 +02:00
}
var emptyImage *Image
func init() {
// w and h are the empty image's size. They indicate the 1x1 image with 1px padding around.
const w, h = 3, 3
emptyImage = &Image{
image: graphicscommand.NewImage(w, h),
width: w,
height: h,
priority: true,
}
pix := make([]byte, 4*w*h)
for i := range pix {
pix[i] = 0xff
}
2019-07-15 19:16:00 +02:00
2019-07-19 21:53:18 +02:00
// As emptyImage is the source at clearImage, initialize this with ReplacePixels, not clearImage.
2019-07-15 19:16:00 +02:00
// This operation is also important when restoring emptyImage.
emptyImage.ReplacePixels(pix, 0, 0, w, h)
theImages.add(emptyImage)
}
// NewImage creates an empty image with the given size.
//
// The returned image is cleared.
//
// Note that Dispose is not called automatically.
func NewImage(width, height int) *Image {
2017-05-03 16:15:18 +02:00
i := &Image{
image: graphicscommand.NewImage(width, height),
width: width,
height: height,
}
fillImage(i.image, color.RGBA{})
2017-05-03 16:15:18 +02:00
theImages.add(i)
return i
}
// SetVolatile sets the volatile state of the image.
//
// Regular non-volatile images need to record drawing history or read its pixels from GPU if necessary so that all
// the images can be restored automatically from the context lost. However, such recording the drawing history or
// reading pixels from GPU are expensive operations. Volatile images can skip such oprations, but the image content
// is cleared every frame instead.
func (i *Image) SetVolatile(volatile bool) {
changed := i.volatile != volatile
i.volatile = volatile
if changed {
i.makeStale()
}
}
// Extend extends the image by the given size.
// Extend creates a new image with the given size and copies the pixels of the given source image.
// Extend disposes itself after its call.
//
// If the given size (width and height) is smaller than the source image, ExtendImage panics.
//
// The image must be ReplacePixels-only image. Extend panics when Fill or DrawTriangles are applied on the image.
//
// Extend panics when the image is stale.
func (i *Image) Extend(width, height int) *Image {
2019-09-20 22:40:05 +02:00
if i.width > width || i.height > height {
panic(fmt.Sprintf("restorable: the original size (%d, %d) cannot be extended to (%d, %d)", i.width, i.height, width, height))
}
if i.stale {
panic("restorable: Extend at a stale image is forbidden")
}
if len(i.drawTrianglesHistory) > 0 {
panic("restorable: Extend after DrawTriangles is forbidden")
}
newImg := NewImage(width, height)
newImg.SetVolatile(i.volatile)
i.basePixels.Apply(newImg.image)
if i.basePixels.baseColor != (color.RGBA{}) {
panic("restorable: baseColor must be empty at Extend")
}
newImg.basePixels = i.basePixels
i.Dispose()
return newImg
}
2017-09-14 17:24:18 +02:00
// NewScreenFramebufferImage creates a special image that framebuffer is one for the screen.
//
// The returned image is cleared.
//
// Note that Dispose is not called automatically.
func NewScreenFramebufferImage(width, height int) *Image {
2017-05-03 16:15:18 +02:00
i := &Image{
2018-12-26 19:11:56 +01:00
image: graphicscommand.NewScreenFramebufferImage(width, height),
width: width,
height: height,
2018-12-26 19:11:56 +01:00
screen: true,
}
fillImage(i.image, color.RGBA{})
2017-05-03 16:15:18 +02:00
theImages.add(i)
return i
2016-09-03 15:24:37 +02:00
}
// quadVertices returns vertices to render a quad. These values are passed to graphicscommand.Image.
func quadVertices(dx0, dy0, dx1, dy1, sx0, sy0, sx1, sy1, cr, cg, cb, ca float32) []float32 {
return []float32{
dx0, dy0, sx0, sy0, cr, cg, cb, ca,
dx1, dy0, sx1, sy0, cr, cg, cb, ca,
dx0, dy1, sx0, sy1, cr, cg, cb, ca,
dx1, dy1, sx1, sy1, cr, cg, cb, ca,
}
}
// Fill fills the specified part of the image with a solid color.
func (i *Image) Fill(clr color.RGBA) {
theImages.makeStaleIfDependingOn(i)
i.basePixels = Pixels{
baseColor: clr,
}
i.drawTrianglesHistory = nil
i.stale = false
// Do not call i.DrawTriangles as emptyImage is special (#928).
// baseColor is updated instead.
fillImage(i.image, i.basePixels.baseColor)
}
func fillImage(i *graphicscommand.Image, clr color.RGBA) {
if i == emptyImage.image {
panic("restorable: fillImage cannot be called on emptyImage")
}
var rf, gf, bf, af float32
if clr.A > 0 {
rf = float32(clr.R) / float32(clr.A)
gf = float32(clr.G) / float32(clr.A)
bf = float32(clr.B) / float32(clr.A)
af = float32(clr.A) / 0xff
}
// TODO: Use the previous composite mode if possible.
compositemode := driver.CompositeModeSourceOver
switch {
case af == 0.0:
compositemode = driver.CompositeModeClear
case af < 1.0:
compositemode = driver.CompositeModeCopy
}
2020-05-30 09:06:22 +02:00
// This needs to use 'InternalSize' to render the whole region, or edges are unexpectedly cleared on some
// devices.
//
// TODO: Can we unexport InternalSize()?
dw, dh := i.InternalSize()
sw, sh := emptyImage.width, emptyImage.height
vs := quadVertices(0, 0, float32(dw), float32(dh), 1, 1, float32(sw-1), float32(sh-1), rf, gf, bf, af)
is := graphics.QuadIndices()
srcs := [graphics.ShaderImageNum]*graphicscommand.Image{emptyImage.image}
var offsets [graphics.ShaderImageNum - 1][2]float32
i.DrawTriangles(srcs, offsets, vs, is, nil, compositemode, driver.FilterNearest, driver.AddressUnsafe, driver.Region{}, nil, nil)
}
2017-09-14 17:24:18 +02:00
// BasePixelsForTesting returns the image's basePixels for testing.
2019-02-12 15:31:52 +01:00
func (i *Image) BasePixelsForTesting() *Pixels {
return &i.basePixels
2017-05-31 18:27:56 +02:00
}
2017-09-14 17:24:18 +02:00
// makeStale makes the image stale.
2017-09-14 17:57:52 +02:00
func (i *Image) makeStale() {
i.basePixels = Pixels{}
i.drawTrianglesHistory = nil
2017-09-14 17:57:52 +02:00
i.stale = true
2018-03-25 12:42:44 +02:00
// Don't have to call makeStale recursively here.
// Restoring is done after topological sorting is done.
// If an image depends on another stale image, this means that
// the former image can be restored from the latest state of the latter image.
2016-07-26 19:16:31 +02:00
}
// ClearPixels clears the specified region by ReplacePixels.
func (i *Image) ClearPixels(x, y, width, height int) {
i.ReplacePixels(nil, x, y, width, height)
}
2017-09-14 17:24:18 +02:00
// ReplacePixels replaces the image pixels with the given pixels slice.
//
// ReplacePixels for a part is forbidden if the image is rendered with DrawTriangles or Fill.
func (i *Image) ReplacePixels(pixels []byte, x, y, width, height int) {
if width <= 0 || height <= 0 {
panic("restorable: width/height must be positive")
}
2019-09-20 22:40:05 +02:00
w, h := i.width, i.height
if x < 0 || y < 0 || w <= x || h <= y || x+width <= 0 || y+height <= 0 || w < x+width || h < y+height {
panic(fmt.Sprintf("restorable: out of range x: %d, y: %d, width: %d, height: %d", x, y, width, height))
}
2018-02-28 18:49:45 +01:00
// TODO: Avoid making other images stale if possible. (#514)
// For this purpuse, images should remember which part of that is used for DrawTriangles.
2017-09-14 17:57:52 +02:00
theImages.makeStaleIfDependingOn(i)
2018-02-28 18:49:45 +01:00
if pixels != nil {
i.image.ReplacePixels(pixels, x, y, width, height)
} else {
// TODO: When pixels == nil, we don't have to care the pixel state there. In such cases, the image
// accepts only ReplacePixels and not Fill or DrawTriangles.
// TODO: Separate Image struct into two: images for only-ReplacePixels, and the others.
i.image.ReplacePixels(make([]byte, 4*width*height), x, y, width, height)
}
if x == 0 && y == 0 && width == w && height == h {
if pixels != nil {
i.basePixels.AddOrReplace(pixels, 0, 0, w, h)
} else {
i.basePixels.Remove(0, 0, w, h)
}
i.drawTrianglesHistory = nil
i.stale = false
return
}
2018-12-26 19:06:44 +01:00
// It looked like ReplacePixels on a part of image deletes other region that are rendered by DrawTriangles
// (#593, #758).
if len(i.drawTrianglesHistory) > 0 {
panic("restorable: ReplacePixels for a part after DrawTriangles is forbidden")
}
2018-12-26 19:06:44 +01:00
if i.stale {
// TODO: panic here?
return
}
2018-12-26 19:06:44 +01:00
if pixels != nil {
i.basePixels.AddOrReplace(pixels, x, y, width, height)
} else {
i.basePixels.Remove(x, y, width, height)
2019-07-15 20:08:26 +02:00
}
2016-07-26 03:51:48 +02:00
}
// DrawTriangles draws triangles with the given image.
//
// The vertex floats are:
//
// 0: Destination X in pixels
// 1: Destination Y in pixels
// 2: Source X in pixels (not texels!)
// 3: Source Y in pixels
// 4: Color R [0.0-1.0]
// 5: Color G
// 6: Color B
// 7: Color Y
func (i *Image) DrawTriangles(srcs [graphics.ShaderImageNum]*Image, offsets [graphics.ShaderImageNum - 1][2]float32, vertices []float32, indices []uint16, colorm *affine.ColorM, mode driver.CompositeMode, filter driver.Filter, address driver.Address, sourceRegion driver.Region, shader *Shader, uniforms []interface{}) {
2019-01-20 18:17:09 +01:00
if i.priority {
panic("restorable: DrawTriangles cannot be called on a priority image")
2019-01-20 18:17:09 +01:00
}
if len(vertices) == 0 {
return
}
theImages.makeStaleIfDependingOn(i)
// TODO: Add tests to confirm this logic.
var srcstale bool
for _, src := range srcs {
if src == nil {
continue
}
if src.stale || src.volatile {
srcstale = true
break
}
}
if srcstale || i.screen || !needsRestoring() || i.volatile {
2017-09-14 17:57:52 +02:00
i.makeStale()
2016-09-03 16:42:44 +02:00
} else {
i.appendDrawTrianglesHistory(srcs, offsets, vertices, indices, colorm, mode, filter, address, sourceRegion, shader, uniforms)
2020-05-24 17:46:23 +02:00
}
var s *graphicscommand.Shader
var imgs [graphics.ShaderImageNum]*graphicscommand.Image
if shader == nil {
// Fast path for rendering without a shader (#1355).
imgs[0] = srcs[0].image
} else {
for i, src := range srcs {
if src == nil {
continue
}
imgs[i] = src.image
}
s = shader.shader
}
i.image.DrawTriangles(imgs, offsets, vertices, indices, colorm, mode, filter, address, sourceRegion, s, uniforms)
2016-09-03 16:42:44 +02:00
}
// appendDrawTrianglesHistory appends a draw-image history item to the image.
func (i *Image) appendDrawTrianglesHistory(srcs [graphics.ShaderImageNum]*Image, offsets [graphics.ShaderImageNum - 1][2]float32, vertices []float32, indices []uint16, colorm *affine.ColorM, mode driver.CompositeMode, filter driver.Filter, address driver.Address, sourceRegion driver.Region, shader *Shader, uniforms []interface{}) {
if i.stale || i.volatile || i.screen {
2016-07-26 19:16:31 +02:00
return
}
// TODO: Would it be possible to merge draw image history items?
const maxDrawTrianglesHistoryNum = 1024
if len(i.drawTrianglesHistory)+1 > maxDrawTrianglesHistoryNum {
2017-09-14 17:57:52 +02:00
i.makeStale()
return
}
2016-08-22 17:05:23 +02:00
// All images must be resolved and not stale each after frame.
// So we don't have to care if image is stale or not here.
vs := make([]float32, len(vertices))
copy(vs, vertices)
is := make([]uint16, len(indices))
copy(is, indices)
2020-05-24 17:46:23 +02:00
item := &drawTrianglesHistoryItem{
images: srcs,
offsets: offsets,
vertices: vs,
indices: is,
colorm: colorm,
mode: mode,
filter: filter,
address: address,
sourceRegion: sourceRegion,
shader: shader,
uniforms: uniforms,
2016-07-24 19:28:59 +02:00
}
i.drawTrianglesHistory = append(i.drawTrianglesHistory, item)
2016-07-13 19:35:20 +02:00
}
func (i *Image) readPixelsFromGPUIfNeeded() error {
if len(i.drawTrianglesHistory) > 0 || i.stale {
if err := graphicscommand.FlushCommands(); err != nil {
return err
}
if err := i.readPixelsFromGPU(); err != nil {
return err
}
2018-11-12 16:00:10 +01:00
}
return nil
2018-11-12 16:00:10 +01:00
}
2016-12-26 19:18:56 +01:00
// At returns a color value at (x, y).
2016-07-25 03:32:16 +02:00
//
// Note that this must not be called until context is available.
func (i *Image) At(x, y int) (byte, byte, byte, byte, error) {
2019-09-20 22:40:05 +02:00
if x < 0 || y < 0 || i.width <= x || i.height <= y {
return 0, 0, 0, 0, nil
}
if err := i.readPixelsFromGPUIfNeeded(); err != nil {
return 0, 0, 0, 0, err
}
r, g, b, a := i.basePixels.At(x, y)
return r, g, b, a, nil
2016-07-13 19:35:20 +02:00
}
2017-09-14 17:24:18 +02:00
// makeStaleIfDependingOn makes the image stale if the image depends on target.
2017-09-14 17:57:52 +02:00
func (i *Image) makeStaleIfDependingOn(target *Image) {
if i.stale {
return
2016-07-26 19:16:31 +02:00
}
2017-09-14 17:57:52 +02:00
if i.dependsOn(target) {
i.makeStale()
2016-07-13 19:35:20 +02:00
}
}
// makeStaleIfDependingOnShader makes the image stale if the image depends on shader.
func (i *Image) makeStaleIfDependingOnShader(shader *Shader) {
if i.stale {
return
}
if i.dependsOnShader(shader) {
i.makeStale()
}
}
2017-09-14 17:24:18 +02:00
// readPixelsFromGPU reads the pixels from GPU and resolves the image's 'stale' state.
func (i *Image) readPixelsFromGPU() error {
pix, err := i.image.Pixels()
if err != nil {
return err
}
i.basePixels = Pixels{}
i.basePixels.AddOrReplace(pix, 0, 0, i.width, i.height)
i.drawTrianglesHistory = nil
2017-09-14 17:57:52 +02:00
i.stale = false
return nil
}
2017-09-14 17:24:18 +02:00
// resolveStale resolves the image's 'stale' state.
func (i *Image) resolveStale() error {
2019-05-26 14:10:25 +02:00
if !needsRestoring() {
return nil
}
2017-09-14 17:57:52 +02:00
if i.volatile {
return nil
}
if i.screen {
return nil
}
2017-09-14 17:57:52 +02:00
if !i.stale {
return nil
2016-07-26 19:20:42 +02:00
}
return i.readPixelsFromGPU()
2016-07-26 19:20:42 +02:00
}
// dependsOn reports whether the image depends on target.
2017-09-14 17:57:52 +02:00
func (i *Image) dependsOn(target *Image) bool {
for _, c := range i.drawTrianglesHistory {
for _, img := range c.images {
if img == nil {
continue
}
if img == target {
2020-05-24 17:46:23 +02:00
return true
}
}
}
return false
}
// dependsOnShader reports whether the image depends on shader.
func (i *Image) dependsOnShader(shader *Shader) bool {
for _, c := range i.drawTrianglesHistory {
if c.shader == shader {
return true
}
}
return false
}
2017-09-14 17:24:18 +02:00
// dependingImages returns all images that is depended by the image.
2017-09-14 17:57:52 +02:00
func (i *Image) dependingImages() map[*Image]struct{} {
r := map[*Image]struct{}{}
for _, c := range i.drawTrianglesHistory {
for _, img := range c.images {
if img == nil {
continue
}
r[img] = struct{}{}
2020-05-24 17:46:23 +02:00
}
}
return r
}
2017-09-14 17:24:18 +02:00
// hasDependency returns a boolean value indicating whether the image depends on another image.
2017-09-14 17:57:52 +02:00
func (i *Image) hasDependency() bool {
if i.stale {
2016-07-26 19:16:31 +02:00
return false
}
return len(i.drawTrianglesHistory) > 0
2016-07-13 19:35:20 +02:00
}
2018-10-28 12:10:05 +01:00
// Restore restores *graphicscommand.Image from the pixels using its state.
func (i *Image) restore() error {
2019-09-20 22:40:05 +02:00
w, h := i.width, i.height
// Do not dispose the image here. The image should be already disposed.
2017-09-14 17:57:52 +02:00
if i.screen {
// The screen image should also be recreated because framebuffer might
// be changed.
i.image = graphicscommand.NewScreenFramebufferImage(w, h)
i.basePixels = Pixels{}
i.drawTrianglesHistory = nil
2017-09-14 17:57:52 +02:00
i.stale = false
return nil
}
2017-09-14 17:57:52 +02:00
if i.volatile {
i.image = graphicscommand.NewImage(w, h)
fillImage(i.image, color.RGBA{})
return nil
}
2017-09-14 17:57:52 +02:00
if i.stale {
panic("restorable: pixels must not be stale when restoring")
}
gimg := graphicscommand.NewImage(w, h)
// Clear the image explicitly.
if i != emptyImage {
// As fillImage uses emptyImage, fillImage cannot be called on emptyImage.
// It is OK to skip this since emptyImage has its entire pixel information.
fillImage(gimg, color.RGBA{})
}
i.basePixels.Apply(gimg)
for _, c := range i.drawTrianglesHistory {
2020-05-24 17:46:23 +02:00
var s *graphicscommand.Shader
if c.shader != nil {
s = c.shader.shader
}
var imgs [graphics.ShaderImageNum]*graphicscommand.Image
for i, img := range c.images {
if img == nil {
continue
}
if img.hasDependency() {
panic("restorable: all dependencies must be already resolved but not")
}
imgs[i] = img.image
}
gimg.DrawTriangles(imgs, c.offsets, c.vertices, c.indices, c.colorm, c.mode, c.filter, c.address, c.sourceRegion, s, c.uniforms)
2016-07-13 19:35:20 +02:00
}
if len(i.drawTrianglesHistory) > 0 {
i.basePixels = Pixels{}
pix, err := gimg.Pixels()
if err != nil {
return err
}
i.basePixels.AddOrReplace(pix, 0, 0, w, h)
2019-02-12 15:31:52 +01:00
}
i.image = gimg
i.drawTrianglesHistory = nil
2017-09-14 17:57:52 +02:00
i.stale = false
return nil
}
2017-09-14 17:24:18 +02:00
// Dispose disposes the image.
//
2017-09-14 20:13:36 +02:00
// After disposing, calling the function of the image causes unexpected results.
2017-09-14 17:57:52 +02:00
func (i *Image) Dispose() {
theImages.remove(i)
2017-09-14 17:57:52 +02:00
i.image.Dispose()
i.image = nil
i.basePixels = Pixels{}
i.drawTrianglesHistory = nil
2017-09-14 17:57:52 +02:00
i.stale = false
2016-07-13 19:35:20 +02:00
}
2016-09-03 17:07:06 +02:00
2019-05-26 14:10:25 +02:00
// isInvalidated returns a boolean value indicating whether the image is invalidated.
2017-09-14 17:24:18 +02:00
//
// If an image is invalidated, GL context is lost and all the images should be restored asap.
func (i *Image) isInvalidated() (bool, error) {
2017-08-06 16:00:24 +02:00
// FlushCommands is required because c.offscreen.impl might not have an actual texture.
if err := graphicscommand.FlushCommands(); err != nil {
return false, err
}
return i.image.IsInvalidated(), nil
2016-09-03 17:07:06 +02:00
}
2019-07-19 18:42:19 +02:00
func (i *Image) Dump(path string, blackbg bool) error {
return i.image.Dump(path, blackbg)
2019-07-19 18:42:19 +02:00
}