ebiten/gameforui.go

153 lines
4.0 KiB
Go
Raw Normal View History

// Copyright 2014 Hajime Hoshi
//
// 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.
2014-12-09 15:16:04 +01:00
package ebiten
2013-12-09 14:40:54 +01:00
2016-05-19 16:37:58 +02:00
import (
"fmt"
"image"
"math"
"sync/atomic"
"github.com/hajimehoshi/ebiten/v2/internal/atlas"
"github.com/hajimehoshi/ebiten/v2/internal/builtinshader"
"github.com/hajimehoshi/ebiten/v2/internal/ui"
2016-05-19 16:37:58 +02:00
)
var screenFilterEnabled atomic.Bool
func init() {
screenFilterEnabled.Store(true)
}
type gameForUI struct {
game Game
offscreen *Image
screen *Image
screenShader *Shader
imageDumper imageDumper
transparent bool
}
func newGameForUI(game Game, transparent bool) *gameForUI {
g := &gameForUI{
game: game,
transparent: transparent,
}
s, err := NewShader(builtinshader.ScreenShaderSource)
if err != nil {
panic(fmt.Sprintf("ebiten: compiling the screen shader failed: %v", err))
}
g.screenShader = s
return g
}
2022-10-13 17:38:08 +02:00
func (g *gameForUI) NewOffscreenImage(width, height int) *ui.Image {
if g.offscreen != nil {
g.offscreen.Deallocate()
2022-10-13 17:38:08 +02:00
g.offscreen = nil
}
// Keep the offscreen an unmanaged image that is always isolated from an atlas (#1938).
// The shader program for the screen is special and doesn't work well with an image on an atlas.
// An image on an atlas is surrounded by a transparent edge,
// and the shader program unexpectedly picks the pixel on the edges.
imageType := atlas.ImageTypeUnmanaged
2022-10-13 17:38:08 +02:00
g.offscreen = newImage(image.Rect(0, 0, width, height), imageType)
return g.offscreen.image
}
2022-10-13 17:38:08 +02:00
func (g *gameForUI) NewScreenImage(width, height int) *ui.Image {
if g.screen != nil {
g.screen.Deallocate()
2022-10-13 17:38:08 +02:00
g.screen = nil
}
2022-10-13 17:38:08 +02:00
g.screen = newImage(image.Rect(0, 0, width, height), atlas.ImageTypeScreen)
return g.screen.image
}
func (g *gameForUI) Layout(outsideWidth, outsideHeight float64) (float64, float64) {
if l, ok := g.game.(LayoutFer); ok {
2022-11-08 17:49:51 +01:00
return l.LayoutF(outsideWidth, outsideHeight)
}
// Even if the original value is less than 1, the value must be a positive integer (#2340).
// This is for a simple implementation of Layout, which returns the argument values without modifications.
// TODO: Remove this hack when Game.Layout takes floats instead of integers.
if outsideWidth < 1 {
outsideWidth = 1
}
if outsideHeight < 1 {
outsideHeight = 1
}
// TODO: Add a new Layout function taking float values (#2285).
sw, sh := g.game.Layout(int(outsideWidth), int(outsideHeight))
return float64(sw), float64(sh)
2019-12-15 18:10:58 +01:00
}
func (g *gameForUI) UpdateInputState(fn func(*ui.InputState)) {
theInputState.update(fn)
}
func (g *gameForUI) Update() error {
if err := g.game.Update(); err != nil {
return err
}
if err := g.imageDumper.update(); err != nil {
return err
}
return nil
}
func (g *gameForUI) DrawOffscreen() error {
2022-10-13 17:38:08 +02:00
g.game.Draw(g.offscreen)
if err := g.imageDumper.dump(g.offscreen, g.transparent); err != nil {
return err
}
return nil
2016-05-23 17:00:54 +02:00
}
func (g *gameForUI) DrawFinalScreen(scale, offsetX, offsetY float64) {
var geoM GeoM
geoM.Scale(scale, scale)
geoM.Translate(offsetX, offsetY)
if d, ok := g.game.(FinalScreenDrawer); ok {
d.DrawFinalScreen(g.screen, g.offscreen, geoM)
return
}
switch {
case !screenFilterEnabled.Load(), math.Floor(scale) == scale:
op := &DrawImageOptions{}
op.GeoM = geoM
g.screen.DrawImage(g.offscreen, op)
case scale < 1:
op := &DrawImageOptions{}
op.GeoM = geoM
op.Filter = FilterLinear
g.screen.DrawImage(g.offscreen, op)
default:
op := &DrawRectShaderOptions{}
op.Images[0] = g.offscreen
op.GeoM = geoM
w, h := g.offscreen.Bounds().Dx(), g.offscreen.Bounds().Dy()
g.screen.DrawRectShader(w, h, g.screenShader, op)
}
}