ebiten/internal/uidriver/mobile/ui.go

463 lines
10 KiB
Go
Raw Normal View History

// Copyright 2016 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.
//go:build android || ios
2017-01-25 17:32:33 +01:00
// +build android ios
package mobile
import (
"fmt"
"runtime/debug"
"sync"
2020-08-28 17:24:30 +02:00
"sync/atomic"
"unicode"
2016-05-19 16:37:58 +02:00
"golang.org/x/mobile/app"
"golang.org/x/mobile/event/key"
"golang.org/x/mobile/event/lifecycle"
"golang.org/x/mobile/event/paint"
"golang.org/x/mobile/event/size"
"golang.org/x/mobile/event/touch"
"golang.org/x/mobile/gl"
2020-10-03 19:35:13 +02:00
"github.com/hajimehoshi/ebiten/v2/internal/devicescale"
"github.com/hajimehoshi/ebiten/v2/internal/driver"
"github.com/hajimehoshi/ebiten/v2/internal/graphicscommand"
2020-10-03 19:35:13 +02:00
"github.com/hajimehoshi/ebiten/v2/internal/graphicsdriver/opengl"
"github.com/hajimehoshi/ebiten/v2/internal/hooks"
"github.com/hajimehoshi/ebiten/v2/internal/restorable"
"github.com/hajimehoshi/ebiten/v2/internal/thread"
)
var (
glContextCh = make(chan gl.Context, 1)
2019-05-30 18:44:01 +02:00
2019-07-31 18:07:19 +02:00
// renderCh receives when updating starts.
2019-05-30 18:44:01 +02:00
renderCh = make(chan struct{})
// renderEndCh receives when updating finishes.
renderEndCh = make(chan struct{})
theUI = &UserInterface{
2020-08-28 17:24:30 +02:00
foreground: 1,
errCh: make(chan error),
// Give a default outside size so that the game can start without initializing them.
outsideWidth: 640,
outsideHeight: 480,
sizeChanged: true,
}
)
2019-04-07 12:27:30 +02:00
func init() {
theUI.input.ui = theUI
}
func Get() *UserInterface {
return theUI
}
2020-02-11 05:43:58 +01:00
// Update is called from mobile/ebitenmobileview.
//
// Update must be called on the rendering thread.
func (u *UserInterface) Update() error {
select {
case err := <-u.errCh:
return err
default:
}
if !u.IsFocused() {
return nil
}
renderCh <- struct{}{}
go func() {
<-renderEndCh
u.t.Call(func() error {
return thread.BreakLoop
})
}()
u.t.Loop()
return nil
}
type UserInterface struct {
outsideWidth float64
outsideHeight float64
2019-12-16 02:57:57 +01:00
2016-06-18 17:55:24 +02:00
sizeChanged bool
2020-08-28 17:24:30 +02:00
foreground int32
errCh chan error
2018-03-23 17:07:36 +01:00
// Used for gomobile-build
gbuildWidthPx int
gbuildHeightPx int
setGBuildSizeCh chan struct{}
2020-01-08 04:50:57 +01:00
once sync.Once
2018-03-23 17:07:36 +01:00
context driver.UIContext
input Input
t *thread.OSThread
m sync.RWMutex
}
func deviceScale() float64 {
return devicescale.GetAt(0, 0)
2018-10-01 20:51:13 +02:00
}
// appMain is the main routine for gomobile-build mode.
2019-04-08 00:51:32 +02:00
func (u *UserInterface) appMain(a app.App) {
var glctx gl.Context
var sizeInited bool
2019-04-08 01:21:17 +02:00
touches := map[touch.Sequence]*Touch{}
keys := map[driver.Key]struct{}{}
for e := range a.Events() {
var updateInput bool
var runes []rune
switch e := a.Filter(e).(type) {
case lifecycle.Event:
switch e.Crosses(lifecycle.StageVisible) {
case lifecycle.CrossOn:
if err := u.SetForeground(true); err != nil {
// There are no other ways than panicking here.
panic(err)
}
restorable.OnContextLost()
glctx, _ = e.DrawContext.(gl.Context)
// Assume that glctx is always a same instance.
// Then, only once initializing should be enough.
if glContextCh != nil {
glContextCh <- glctx
glContextCh = nil
}
a.Send(paint.Event{})
case lifecycle.CrossOff:
if err := u.SetForeground(false); err != nil {
// There are no other ways than panicking here.
panic(err)
}
glctx = nil
}
case size.Event:
u.setGBuildSize(e.WidthPx, e.HeightPx)
sizeInited = true
case paint.Event:
if !sizeInited {
a.Send(paint.Event{})
continue
}
if glctx == nil || e.External {
continue
}
renderCh <- struct{}{}
2019-05-30 18:44:01 +02:00
<-renderEndCh
a.Publish()
a.Send(paint.Event{})
case touch.Event:
if !sizeInited {
continue
}
switch e.Type {
case touch.TypeBegin, touch.TypeMove:
s := deviceScale()
x, y := float64(e.X)/s, float64(e.Y)/s
// TODO: Is it ok to cast from int64 to int here?
2019-04-08 01:21:17 +02:00
touches[e.Sequence] = &Touch{
ID: driver.TouchID(e.Sequence),
X: int(x),
Y: int(y),
}
case touch.TypeEnd:
delete(touches, e.Sequence)
}
updateInput = true
case key.Event:
k, ok := gbuildKeyToDriverKey[e.Code]
if ok {
switch e.Direction {
case key.DirPress, key.DirNone:
keys[k] = struct{}{}
case key.DirRelease:
delete(keys, k)
}
}
switch e.Direction {
case key.DirPress, key.DirNone:
if e.Rune != -1 && unicode.IsPrint(e.Rune) {
runes = []rune{e.Rune}
}
}
updateInput = true
}
if updateInput {
2019-04-08 01:21:17 +02:00
ts := []*Touch{}
for _, t := range touches {
ts = append(ts, t)
}
u.input.update(keys, runes, ts, nil)
}
}
}
2016-05-19 16:37:58 +02:00
func (u *UserInterface) SetForeground(foreground bool) error {
2020-08-28 17:24:30 +02:00
var v int32
if foreground {
v = 1
}
atomic.StoreInt32(&u.foreground, v)
if foreground {
return hooks.ResumeAudio()
} else {
return hooks.SuspendAudio()
}
}
func (u *UserInterface) Run(context driver.UIContext) error {
u.setGBuildSizeCh = make(chan struct{})
go func() {
if err := u.run(context, true); err != nil {
// As mobile apps never ends, Loop can't return. Just panic here.
panic(err)
}
}()
app.Main(u.appMain)
return nil
}
func (u *UserInterface) RunWithoutMainLoop(context driver.UIContext) {
go func() {
if err := u.run(context, false); err != nil {
u.errCh <- err
}
}()
}
func (u *UserInterface) run(context driver.UIContext, mainloop bool) (err error) {
// Convert the panic to a regular error so that Java/Objective-C layer can treat this easily e.g., for
// Crashlytics. A panic is treated as SIGABRT, and there is no way to handle this on Java/Objective-C layer
// unfortunately.
// TODO: Panic on other goroutines cannot be handled here.
defer func() {
if r := recover(); r != nil {
err = fmt.Errorf("%v\n%s", r, string(debug.Stack()))
}
}()
u.m.Lock()
u.sizeChanged = true
u.m.Unlock()
2018-03-23 17:07:36 +01:00
2020-08-28 20:02:20 +02:00
u.context = context
if mainloop {
// When mainloop is true, gomobile-build is used. In this case, GL functions must be called via
// gl.Context so that they are called on the appropriate thread.
ctx := <-glContextCh
u.Graphics().(*opengl.Graphics).SetGomobileGLContext(ctx)
} else {
u.t = thread.NewOSThread()
graphicscommand.SetMainThread(u.t)
}
2018-03-23 17:07:36 +01:00
// If gomobile-build is used, wait for the outside size fixed.
if u.setGBuildSizeCh != nil {
<-u.setGBuildSizeCh
}
2018-05-26 15:50:58 +02:00
// Force to set the screen size
2020-08-28 19:43:04 +02:00
u.layoutIfNeeded()
for {
2020-04-02 17:06:42 +02:00
if err := u.update(); err != nil {
return err
}
2016-09-01 18:34:51 +02:00
}
}
2020-08-28 19:43:04 +02:00
// layoutIfNeeded must be called on the same goroutine as update().
func (u *UserInterface) layoutIfNeeded() {
var outsideWidth, outsideHeight float64
2020-08-28 20:02:20 +02:00
u.m.RLock()
2018-05-11 19:29:39 +02:00
sizeChanged := u.sizeChanged
if sizeChanged {
if u.gbuildWidthPx == 0 || u.gbuildHeightPx == 0 {
outsideWidth = u.outsideWidth
outsideHeight = u.outsideHeight
} else {
// gomobile build
d := deviceScale()
outsideWidth = float64(u.gbuildWidthPx) / d
outsideHeight = float64(u.gbuildHeightPx) / d
}
}
u.sizeChanged = false
2020-08-28 20:02:20 +02:00
u.m.RUnlock()
if sizeChanged {
2020-04-02 17:06:42 +02:00
u.context.Layout(outsideWidth, outsideHeight)
}
}
2020-04-02 17:06:42 +02:00
func (u *UserInterface) update() error {
<-renderCh
defer func() {
2019-05-30 18:44:01 +02:00
renderEndCh <- struct{}{}
}()
2020-04-02 17:06:42 +02:00
if err := u.context.Update(); err != nil {
2016-09-01 18:34:51 +02:00
return err
}
return nil
}
func (u *UserInterface) ScreenSizeInFullscreen() (int, int) {
// TODO: This function should return gbuildWidthPx, gbuildHeightPx,
2018-05-04 09:09:55 +02:00
// but these values are not initialized until the main loop starts.
return 0, 0
}
// SetOutsideSize is called from mobile/ebitenmobileview.
//
// SetOutsideSize is concurrent safe.
func (u *UserInterface) SetOutsideSize(outsideWidth, outsideHeight float64) {
u.m.Lock()
if u.outsideWidth != outsideWidth || u.outsideHeight != outsideHeight {
u.outsideWidth = outsideWidth
u.outsideHeight = outsideHeight
u.sizeChanged = true
}
u.m.Unlock()
}
func (u *UserInterface) setGBuildSize(widthPx, heightPx int) {
2018-03-23 17:07:36 +01:00
u.m.Lock()
u.gbuildWidthPx = widthPx
u.gbuildHeightPx = heightPx
2018-03-23 17:07:36 +01:00
u.sizeChanged = true
2020-08-28 19:43:04 +02:00
u.m.Unlock()
2020-01-08 04:50:57 +01:00
u.once.Do(func() {
close(u.setGBuildSizeCh)
})
2018-03-23 17:07:36 +01:00
}
func (u *UserInterface) adjustPosition(x, y int) (int, int) {
xf, yf := u.context.AdjustPosition(float64(x), float64(y), deviceScale())
return int(xf), int(yf)
}
func (u *UserInterface) CursorMode() driver.CursorMode {
return driver.CursorModeHidden
2017-08-12 08:39:41 +02:00
}
func (u *UserInterface) SetCursorMode(mode driver.CursorMode) {
2016-09-03 10:17:54 +02:00
// Do nothing
}
func (u *UserInterface) CursorShape() driver.CursorShape {
return driver.CursorShapeDefault
}
func (u *UserInterface) SetCursorShape(shape driver.CursorShape) {
// Do nothing
}
func (u *UserInterface) IsFullscreen() bool {
return false
}
func (u *UserInterface) SetFullscreen(fullscreen bool) {
// Do nothing
}
func (u *UserInterface) IsFocused() bool {
2020-08-28 17:24:30 +02:00
return atomic.LoadInt32(&u.foreground) != 0
}
func (u *UserInterface) IsRunnableOnUnfocused() bool {
return false
}
func (u *UserInterface) SetRunnableOnUnfocused(runnableOnUnfocused bool) {
// Do nothing
}
func (u *UserInterface) IsVsyncEnabled() bool {
return true
}
func (u *UserInterface) SetVsyncEnabled(enabled bool) {
// Do nothing
}
func (u *UserInterface) DeviceScaleFactor() float64 {
return deviceScale()
}
2019-04-07 11:28:50 +02:00
func (u *UserInterface) SetScreenTransparent(transparent bool) {
// Do nothing
}
func (u *UserInterface) IsScreenTransparent() bool {
return false
}
2020-04-02 17:06:42 +02:00
func (u *UserInterface) ResetForFrame() {
2020-08-28 19:43:04 +02:00
u.layoutIfNeeded()
2020-04-02 17:06:42 +02:00
u.input.resetForFrame()
}
2020-02-09 15:03:03 +01:00
func (u *UserInterface) SetInitFocused(focused bool) {
// Do nothing
}
2019-04-07 11:28:50 +02:00
func (u *UserInterface) Input() driver.Input {
return &u.input
}
2019-12-24 16:05:56 +01:00
func (u *UserInterface) Window() driver.Window {
return nil
}
2019-04-08 01:21:17 +02:00
type Touch struct {
ID driver.TouchID
2019-04-08 01:21:17 +02:00
X int
Y int
}
type Gamepad struct {
ID driver.GamepadID
SDLID string
Name string
Buttons [driver.GamepadButtonNum]bool
ButtonNum int
Axes [32]float32
AxisNum int
}
func (u *UserInterface) UpdateInput(keys map[driver.Key]struct{}, runes []rune, touches []*Touch, gamepads []Gamepad) {
u.input.update(keys, runes, touches, gamepads)
2019-04-07 11:28:50 +02:00
}