2016-05-18 20:17:50 +02:00
|
|
|
// 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.
|
|
|
|
|
2017-01-25 17:32:33 +01:00
|
|
|
// +build android ios
|
2016-05-18 20:17:50 +02:00
|
|
|
|
|
|
|
package ui
|
|
|
|
|
|
|
|
import (
|
2016-05-19 16:37:58 +02:00
|
|
|
"errors"
|
2017-09-22 21:12:02 +02:00
|
|
|
"image"
|
2016-06-30 17:44:15 +02:00
|
|
|
"runtime"
|
2017-12-31 13:01:48 +01:00
|
|
|
"sync"
|
2016-06-09 18:21:46 +02:00
|
|
|
"time"
|
2016-05-19 16:37:58 +02:00
|
|
|
|
2018-04-06 19:14:23 +02:00
|
|
|
"golang.org/x/mobile/app"
|
|
|
|
"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"
|
|
|
|
|
2018-01-02 21:22:56 +01:00
|
|
|
"github.com/hajimehoshi/ebiten/internal/devicescale"
|
2019-03-30 14:26:27 +01:00
|
|
|
"github.com/hajimehoshi/ebiten/internal/driver"
|
2018-11-10 14:47:39 +01:00
|
|
|
"github.com/hajimehoshi/ebiten/internal/graphicsdriver/opengl"
|
2018-05-26 11:04:20 +02:00
|
|
|
"github.com/hajimehoshi/ebiten/internal/hooks"
|
2018-04-01 16:20:45 +02:00
|
|
|
"github.com/hajimehoshi/ebiten/internal/input"
|
2016-05-18 20:17:50 +02:00
|
|
|
)
|
|
|
|
|
2018-04-06 19:14:23 +02:00
|
|
|
var (
|
|
|
|
glContextCh = make(chan gl.Context)
|
|
|
|
renderCh = make(chan struct{})
|
|
|
|
renderChEnd = make(chan struct{})
|
|
|
|
currentUI = &userInterface{}
|
|
|
|
)
|
|
|
|
|
2016-05-19 16:37:58 +02:00
|
|
|
func Render(chError <-chan error) error {
|
2016-06-30 17:44:15 +02:00
|
|
|
runtime.LockOSThread()
|
|
|
|
defer runtime.UnlockOSThread()
|
|
|
|
|
2016-05-19 16:37:58 +02:00
|
|
|
if chError == nil {
|
|
|
|
return errors.New("ui: chError must not be nil")
|
|
|
|
}
|
|
|
|
// TODO: Check this is called on the rendering thread
|
2016-06-09 18:21:46 +02:00
|
|
|
select {
|
2019-01-28 04:32:46 +01:00
|
|
|
case err := <-chError:
|
|
|
|
return err
|
2018-04-06 19:14:23 +02:00
|
|
|
case renderCh <- struct{}{}:
|
2019-01-28 04:32:46 +01:00
|
|
|
return opengl.Get().DoWork(renderChEnd)
|
2016-06-09 18:21:46 +02:00
|
|
|
case <-time.After(500 * time.Millisecond):
|
2016-06-10 17:56:29 +02:00
|
|
|
// This function must not be blocked. We need to break for timeout.
|
2016-06-09 18:21:46 +02:00
|
|
|
return nil
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-05-19 17:07:04 +02:00
|
|
|
type userInterface struct {
|
2016-06-18 17:55:24 +02:00
|
|
|
width int
|
|
|
|
height int
|
2016-06-18 19:59:17 +02:00
|
|
|
scale float64
|
2016-06-18 17:55:24 +02:00
|
|
|
sizeChanged bool
|
2017-12-31 13:01:48 +01:00
|
|
|
|
2018-03-23 17:07:36 +01:00
|
|
|
// Used for gomobile-build
|
|
|
|
fullscreenScale float64
|
|
|
|
fullscreenWidthPx int
|
|
|
|
fullscreenHeightPx int
|
|
|
|
|
2017-12-31 13:01:48 +01:00
|
|
|
m sync.RWMutex
|
2016-05-18 20:17:50 +02:00
|
|
|
}
|
|
|
|
|
2018-10-01 20:51:13 +02:00
|
|
|
var (
|
|
|
|
deviceScaleVal float64
|
|
|
|
deviceScaleM sync.Mutex
|
|
|
|
)
|
|
|
|
|
2018-10-06 11:26:22 +02:00
|
|
|
func getDeviceScale() float64 {
|
2018-10-01 20:51:13 +02:00
|
|
|
deviceScaleM.Lock()
|
|
|
|
defer deviceScaleM.Unlock()
|
|
|
|
|
|
|
|
if deviceScaleVal == 0 {
|
2018-10-07 18:11:13 +02:00
|
|
|
deviceScaleVal = devicescale.GetAt(0, 0)
|
2018-10-01 20:51:13 +02:00
|
|
|
}
|
|
|
|
return deviceScaleVal
|
|
|
|
}
|
|
|
|
|
2018-04-06 19:14:23 +02:00
|
|
|
// appMain is the main routine for gomobile-build mode.
|
|
|
|
func appMain(a app.App) {
|
|
|
|
var glctx gl.Context
|
2019-03-31 11:55:46 +02:00
|
|
|
touches := map[touch.Sequence]*driver.Touch{}
|
2018-04-06 19:14:23 +02:00
|
|
|
for e := range a.Events() {
|
|
|
|
switch e := a.Filter(e).(type) {
|
|
|
|
case lifecycle.Event:
|
|
|
|
switch e.Crosses(lifecycle.StageVisible) {
|
|
|
|
case lifecycle.CrossOn:
|
|
|
|
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:
|
|
|
|
glctx = nil
|
|
|
|
}
|
|
|
|
case size.Event:
|
|
|
|
setFullscreen(e.WidthPx, e.HeightPx)
|
|
|
|
case paint.Event:
|
|
|
|
if glctx == nil || e.External {
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
renderCh <- struct{}{}
|
|
|
|
<-renderChEnd
|
|
|
|
a.Publish()
|
|
|
|
a.Send(paint.Event{})
|
|
|
|
case touch.Event:
|
|
|
|
switch e.Type {
|
|
|
|
case touch.TypeBegin, touch.TypeMove:
|
2018-10-06 11:26:22 +02:00
|
|
|
s := getDeviceScale()
|
2018-04-06 19:14:23 +02:00
|
|
|
x, y := float64(e.X)/s, float64(e.Y)/s
|
|
|
|
// TODO: Is it ok to cast from int64 to int here?
|
2019-03-31 11:55:46 +02:00
|
|
|
touches[e.Sequence] = &driver.Touch{
|
2019-03-30 17:08:04 +01:00
|
|
|
ID: int(e.Sequence),
|
|
|
|
X: int(x),
|
|
|
|
Y: int(y),
|
|
|
|
}
|
2018-04-06 19:14:23 +02:00
|
|
|
case touch.TypeEnd:
|
|
|
|
delete(touches, e.Sequence)
|
|
|
|
}
|
2019-03-31 11:55:46 +02:00
|
|
|
ts := []*driver.Touch{}
|
2018-04-06 19:14:23 +02:00
|
|
|
for _, t := range touches {
|
|
|
|
ts = append(ts, t)
|
|
|
|
}
|
2019-04-06 14:21:16 +02:00
|
|
|
type updater interface {
|
|
|
|
Update(touches []*driver.Touch)
|
|
|
|
}
|
|
|
|
input.Get().(updater).Update(ts)
|
2018-04-06 19:14:23 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2016-05-19 16:37:58 +02:00
|
|
|
|
2019-04-06 16:03:21 +02:00
|
|
|
func Run(width, height int, scale float64, title string, g GraphicsContext, mainloop bool, graphics driver.Graphics, input driver.Input) error {
|
|
|
|
if graphics != opengl.Get() {
|
|
|
|
panic("ui: graphics driver must be OpenGL")
|
|
|
|
}
|
|
|
|
|
2016-09-02 17:20:05 +02:00
|
|
|
u := currentUI
|
2017-12-31 13:01:48 +01:00
|
|
|
|
|
|
|
u.m.Lock()
|
2016-05-19 16:37:58 +02:00
|
|
|
u.width = width
|
|
|
|
u.height = height
|
|
|
|
u.scale = scale
|
2017-12-31 13:01:48 +01:00
|
|
|
u.sizeChanged = true
|
|
|
|
u.m.Unlock()
|
2016-05-19 16:37:58 +02:00
|
|
|
// title is ignored?
|
2018-03-23 17:07:36 +01:00
|
|
|
|
2018-04-06 19:14:23 +02:00
|
|
|
if mainloop {
|
|
|
|
ctx := <-glContextCh
|
2018-11-12 16:01:26 +01:00
|
|
|
opengl.Get().InitWithContext(ctx)
|
2018-04-06 19:14:23 +02:00
|
|
|
} else {
|
2018-11-12 16:01:26 +01:00
|
|
|
opengl.Get().Init()
|
2018-04-06 19:14:23 +02:00
|
|
|
}
|
2018-03-23 17:07:36 +01:00
|
|
|
|
2018-05-26 15:50:58 +02:00
|
|
|
// Force to set the screen size
|
|
|
|
u.updateGraphicsContext(g)
|
2016-08-31 19:38:47 +02:00
|
|
|
for {
|
2016-09-01 18:34:51 +02:00
|
|
|
if err := u.update(g); err != nil {
|
2016-08-31 19:38:47 +02:00
|
|
|
return err
|
|
|
|
}
|
2016-09-01 18:34:51 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-11-04 15:32:18 +01:00
|
|
|
// Loop runs the main routine for gomobile-build.
|
|
|
|
func Loop(ch <-chan error) error {
|
2018-04-06 20:33:20 +02:00
|
|
|
go func() {
|
2018-11-04 15:32:18 +01:00
|
|
|
// As mobile apps never ends, Loop can't return. Just panic here.
|
2018-04-06 20:33:20 +02:00
|
|
|
err := <-ch
|
|
|
|
panic(err)
|
|
|
|
}()
|
2018-04-06 19:14:23 +02:00
|
|
|
app.Main(appMain)
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2018-02-01 18:08:03 +01:00
|
|
|
func (u *userInterface) updateGraphicsContext(g GraphicsContext) {
|
2017-12-31 13:01:48 +01:00
|
|
|
width, height := 0, 0
|
|
|
|
actualScale := 0.0
|
|
|
|
|
|
|
|
u.m.Lock()
|
2018-05-11 19:29:39 +02:00
|
|
|
sizeChanged := u.sizeChanged
|
2017-12-31 13:01:48 +01:00
|
|
|
if sizeChanged {
|
|
|
|
width = u.width
|
|
|
|
height = u.height
|
2018-10-06 11:26:22 +02:00
|
|
|
actualScale = u.scaleImpl() * getDeviceScale()
|
2017-12-31 13:01:48 +01:00
|
|
|
}
|
|
|
|
u.sizeChanged = false
|
|
|
|
u.m.Unlock()
|
|
|
|
|
|
|
|
if sizeChanged {
|
2016-09-01 18:34:51 +02:00
|
|
|
// Sizing also calls GL functions
|
2017-12-31 13:01:48 +01:00
|
|
|
g.SetSize(width, height, actualScale)
|
2016-08-31 19:38:47 +02:00
|
|
|
}
|
2018-02-01 18:08:03 +01:00
|
|
|
}
|
|
|
|
|
2018-03-23 17:07:36 +01:00
|
|
|
func actualScale() float64 {
|
|
|
|
return currentUI.actualScale()
|
|
|
|
}
|
|
|
|
|
|
|
|
func (u *userInterface) actualScale() float64 {
|
|
|
|
u.m.Lock()
|
2018-10-06 11:26:22 +02:00
|
|
|
s := u.scaleImpl() * getDeviceScale()
|
2018-03-23 17:07:36 +01:00
|
|
|
u.m.Unlock()
|
|
|
|
return s
|
|
|
|
}
|
|
|
|
|
2018-04-02 18:19:47 +02:00
|
|
|
func (u *userInterface) scaleImpl() float64 {
|
2018-03-23 17:07:36 +01:00
|
|
|
scale := u.scale
|
|
|
|
if u.fullscreenScale != 0 {
|
|
|
|
scale = u.fullscreenScale
|
|
|
|
}
|
2018-04-02 18:19:47 +02:00
|
|
|
return scale
|
2018-03-23 17:07:36 +01:00
|
|
|
}
|
|
|
|
|
2018-02-01 18:08:03 +01:00
|
|
|
func (u *userInterface) update(g GraphicsContext) error {
|
2018-05-26 11:04:20 +02:00
|
|
|
render:
|
|
|
|
for {
|
|
|
|
select {
|
|
|
|
case <-renderCh:
|
|
|
|
break render
|
|
|
|
case <-time.After(500 * time.Millisecond):
|
|
|
|
hooks.SuspendAudio()
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
}
|
|
|
|
hooks.ResumeAudio()
|
|
|
|
|
2018-02-01 18:08:03 +01:00
|
|
|
defer func() {
|
2018-04-06 19:14:23 +02:00
|
|
|
renderChEnd <- struct{}{}
|
2018-02-01 18:08:03 +01:00
|
|
|
}()
|
|
|
|
|
|
|
|
if err := g.Update(func() {
|
|
|
|
u.updateGraphicsContext(g)
|
|
|
|
}); err != nil {
|
2016-09-01 18:34:51 +02:00
|
|
|
return err
|
|
|
|
}
|
|
|
|
return nil
|
2016-05-18 20:17:50 +02:00
|
|
|
}
|
|
|
|
|
2018-03-23 17:07:36 +01:00
|
|
|
func screenSize() (int, int) {
|
|
|
|
return currentUI.screenSize()
|
|
|
|
}
|
|
|
|
|
|
|
|
func (u *userInterface) screenSize() (int, int) {
|
|
|
|
u.m.Lock()
|
|
|
|
w, h := u.width, u.height
|
|
|
|
u.m.Unlock()
|
|
|
|
return w, h
|
|
|
|
}
|
|
|
|
|
2018-10-09 16:27:29 +02:00
|
|
|
func ScreenSizeInFullscreen() (int, int) {
|
2018-05-04 09:09:55 +02:00
|
|
|
// TODO: This function should return fullscreenWidthPx, fullscreenHeightPx,
|
|
|
|
// but these values are not initialized until the main loop starts.
|
|
|
|
return 0, 0
|
|
|
|
}
|
|
|
|
|
2017-03-03 02:58:29 +01:00
|
|
|
func SetScreenSize(width, height int) bool {
|
2017-12-31 13:01:48 +01:00
|
|
|
currentUI.setScreenSize(width, height)
|
|
|
|
return true
|
|
|
|
}
|
|
|
|
|
|
|
|
func (u *userInterface) setScreenSize(width, height int) {
|
|
|
|
u.m.Lock()
|
|
|
|
if u.width != width || u.height != height {
|
|
|
|
u.width = width
|
|
|
|
u.height = height
|
2018-03-23 17:07:36 +01:00
|
|
|
u.updateFullscreenScaleIfNeeded()
|
2017-12-31 13:01:48 +01:00
|
|
|
u.sizeChanged = true
|
|
|
|
}
|
|
|
|
u.m.Unlock()
|
2016-05-18 20:17:50 +02:00
|
|
|
}
|
|
|
|
|
2017-03-03 02:58:29 +01:00
|
|
|
func SetScreenScale(scale float64) bool {
|
2017-12-31 13:01:48 +01:00
|
|
|
currentUI.setScreenScale(scale)
|
2017-03-03 02:58:29 +01:00
|
|
|
return false
|
2016-05-18 20:17:50 +02:00
|
|
|
}
|
|
|
|
|
2017-12-31 13:01:48 +01:00
|
|
|
func (u *userInterface) setScreenScale(scale float64) {
|
|
|
|
u.m.Lock()
|
|
|
|
if u.scale != scale {
|
|
|
|
u.scale = scale
|
|
|
|
u.sizeChanged = true
|
|
|
|
}
|
|
|
|
u.m.Unlock()
|
|
|
|
}
|
|
|
|
|
2016-09-02 16:38:02 +02:00
|
|
|
func ScreenScale() float64 {
|
2017-12-31 13:01:48 +01:00
|
|
|
u := currentUI
|
|
|
|
u.m.RLock()
|
|
|
|
s := u.scale
|
|
|
|
u.m.RUnlock()
|
|
|
|
return s
|
2016-05-19 16:37:58 +02:00
|
|
|
}
|
|
|
|
|
2018-03-23 17:07:36 +01:00
|
|
|
func setFullscreen(widthPx, heightPx int) {
|
|
|
|
currentUI.setFullscreen(widthPx, heightPx)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (u *userInterface) setFullscreen(widthPx, heightPx int) {
|
|
|
|
u.m.Lock()
|
|
|
|
u.fullscreenWidthPx = widthPx
|
|
|
|
u.fullscreenHeightPx = heightPx
|
|
|
|
u.updateFullscreenScaleIfNeeded()
|
|
|
|
u.sizeChanged = true
|
|
|
|
u.m.Unlock()
|
|
|
|
}
|
|
|
|
|
|
|
|
func (u *userInterface) updateFullscreenScaleIfNeeded() {
|
|
|
|
if u.fullscreenWidthPx == 0 || u.fullscreenHeightPx == 0 {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
w, h := u.width, u.height
|
|
|
|
scaleX := float64(u.fullscreenWidthPx) / float64(w)
|
|
|
|
scaleY := float64(u.fullscreenHeightPx) / float64(h)
|
|
|
|
scale := scaleX
|
|
|
|
if scale > scaleY {
|
|
|
|
scale = scaleY
|
|
|
|
}
|
2018-10-06 11:26:22 +02:00
|
|
|
u.fullscreenScale = scale / getDeviceScale()
|
2018-05-11 19:11:37 +02:00
|
|
|
u.sizeChanged = true
|
2018-03-23 17:07:36 +01:00
|
|
|
}
|
|
|
|
|
2018-02-24 13:16:30 +01:00
|
|
|
func ScreenPadding() (x0, y0, x1, y1 float64) {
|
2018-03-23 17:07:36 +01:00
|
|
|
return currentUI.screenPadding()
|
|
|
|
}
|
|
|
|
|
|
|
|
func (u *userInterface) screenPadding() (x0, y0, x1, y1 float64) {
|
|
|
|
u.m.Lock()
|
|
|
|
x0, y0, x1, y1 = u.screenPaddingImpl()
|
|
|
|
u.m.Unlock()
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
func (u *userInterface) screenPaddingImpl() (x0, y0, x1, y1 float64) {
|
|
|
|
if u.fullscreenScale == 0 {
|
|
|
|
return 0, 0, 0, 0
|
|
|
|
}
|
2018-10-06 11:26:22 +02:00
|
|
|
s := u.fullscreenScale * getDeviceScale()
|
2018-03-23 17:07:36 +01:00
|
|
|
ox := (float64(u.fullscreenWidthPx) - float64(u.width)*s) / 2
|
|
|
|
oy := (float64(u.fullscreenHeightPx) - float64(u.height)*s) / 2
|
|
|
|
return ox, oy, ox, oy
|
2017-06-30 21:12:09 +02:00
|
|
|
}
|
|
|
|
|
2019-03-30 18:00:22 +01:00
|
|
|
func AdjustPosition(x, y int) (int, int) {
|
|
|
|
return currentUI.adjustPosition(x, y)
|
2018-04-01 18:53:10 +02:00
|
|
|
}
|
|
|
|
|
2018-04-02 18:19:47 +02:00
|
|
|
func (u *userInterface) adjustPosition(x, y int) (int, int) {
|
2018-03-23 17:07:36 +01:00
|
|
|
u.m.Lock()
|
|
|
|
ox, oy, _, _ := u.screenPaddingImpl()
|
2018-04-02 18:19:47 +02:00
|
|
|
s := u.scaleImpl()
|
2018-10-06 11:26:22 +02:00
|
|
|
as := s * getDeviceScale()
|
2018-03-23 17:07:36 +01:00
|
|
|
u.m.Unlock()
|
2018-04-02 18:19:47 +02:00
|
|
|
return int(float64(x)/s - ox/as), int(float64(y)/s - oy/as)
|
2017-06-30 21:27:38 +02:00
|
|
|
}
|
|
|
|
|
2017-08-12 08:39:41 +02:00
|
|
|
func IsCursorVisible() bool {
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
2018-01-08 18:01:33 +01:00
|
|
|
func SetCursorVisible(visible bool) {
|
2016-09-03 10:17:54 +02:00
|
|
|
// Do nothing
|
|
|
|
}
|
|
|
|
|
2017-09-13 20:37:38 +02:00
|
|
|
func IsFullscreen() bool {
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
2017-08-02 16:37:50 +02:00
|
|
|
func SetFullscreen(fullscreen bool) {
|
2017-06-29 17:35:34 +02:00
|
|
|
// Do nothing
|
|
|
|
}
|
|
|
|
|
2017-09-13 20:37:38 +02:00
|
|
|
func IsRunnableInBackground() bool {
|
2017-06-29 17:35:34 +02:00
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
2017-08-02 16:37:50 +02:00
|
|
|
func SetRunnableInBackground(runnableInBackground bool) {
|
|
|
|
// Do nothing
|
|
|
|
}
|
|
|
|
|
2018-05-02 12:09:03 +02:00
|
|
|
func SetWindowTitle(title string) {
|
|
|
|
// Do nothing
|
|
|
|
}
|
|
|
|
|
2017-09-13 20:37:38 +02:00
|
|
|
func SetWindowIcon(iconImages []image.Image) {
|
2017-08-02 16:37:50 +02:00
|
|
|
// Do nothing
|
2017-09-13 20:37:38 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
func IsWindowDecorated() bool {
|
2017-08-02 16:37:50 +02:00
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
2017-09-13 20:37:38 +02:00
|
|
|
func SetWindowDecorated(decorated bool) {
|
2017-09-22 21:12:02 +02:00
|
|
|
// Do nothing
|
|
|
|
}
|
|
|
|
|
2019-01-06 16:21:59 +01:00
|
|
|
func IsWindowResizable() bool {
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
|
|
|
func SetWindowResizable(decorated bool) {
|
|
|
|
// Do nothing
|
|
|
|
}
|
|
|
|
|
2018-07-14 13:50:09 +02:00
|
|
|
func IsVsyncEnabled() bool {
|
|
|
|
return true
|
|
|
|
}
|
|
|
|
|
|
|
|
func SetVsyncEnabled(enabled bool) {
|
|
|
|
// Do nothing
|
|
|
|
}
|
|
|
|
|
2018-10-07 18:24:19 +02:00
|
|
|
func DeviceScaleFactor() float64 {
|
|
|
|
return getDeviceScale()
|
|
|
|
}
|