ebiten/internal/uidriver/glfw/ui.go

1522 lines
38 KiB
Go
Raw Normal View History

2015-01-01 17:20:20 +01:00
// Copyright 2015 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
2017-05-11 12:09:13 +02:00
// +build darwin freebsd linux windows
// +build !android
2016-06-15 17:49:22 +02:00
// +build !ios
2015-01-02 07:20:05 +01:00
package glfw
2014-12-05 18:26:02 +01:00
import (
"fmt"
2017-09-22 21:12:02 +02:00
"image"
"os"
2014-12-14 10:57:29 +01:00
"runtime"
2016-09-03 14:14:06 +02:00
"sync"
"sync/atomic"
"time"
2015-06-20 18:33:28 +02:00
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/glfw"
"github.com/hajimehoshi/ebiten/v2/internal/hooks"
"github.com/hajimehoshi/ebiten/v2/internal/thread"
2014-12-05 18:26:02 +01:00
)
2021-04-14 18:59:31 +02:00
func driverCursorModeToGLFWCursorMode(mode driver.CursorMode) int {
switch mode {
case driver.CursorModeVisible:
return glfw.CursorNormal
case driver.CursorModeHidden:
return glfw.CursorHidden
case driver.CursorModeCaptured:
return glfw.CursorDisabled
default:
panic(fmt.Sprintf("glfw: invalid driver.CursorMode: %d", mode))
}
}
type UserInterface struct {
2020-04-02 17:06:42 +02:00
context driver.UIContext
title string
window *glfw.Window
// windowWidth and windowHeight represents a window size.
// The units are device-dependent pixels.
windowWidth int
windowHeight int
// The units are device-independent pixels.
minWindowWidthInDP int
minWindowHeightInDP int
maxWindowWidthInDP int
maxWindowHeightInDP int
2018-01-02 16:23:18 +01:00
running uint32
toChangeSize bool
origPosX int
origPosY int
runnableOnUnfocused bool
vsync bool
iconImages []image.Image
cursorShape driver.CursorShape
2018-01-02 16:23:18 +01:00
// setSizeCallbackEnabled must be accessed from the main thread.
setSizeCallbackEnabled bool
// err must be accessed from the main thread.
err error
lastDeviceScaleFactor float64
2021-02-10 20:00:37 +01:00
// These values are not changed after initialized.
// TODO: the fullscreen size should be updated when the initial window position is changed?
initMonitor *glfw.Monitor
initFullscreenWidthInDP int
initFullscreenHeightInDP int
2021-02-10 20:00:37 +01:00
initTitle string
initVsync bool
initFullscreen bool
initCursorMode driver.CursorMode
initWindowDecorated bool
initWindowResizable bool
initWindowPositionXInDP int
initWindowPositionYInDP int
initWindowWidthInDP int
initWindowHeightInDP int
initWindowFloating bool
initWindowMaximized bool
initScreenTransparent bool
initFocused bool
2018-01-02 16:23:18 +01:00
vsyncInited bool
input Input
iwindow window
t thread.Thread
m sync.RWMutex
2016-03-24 16:38:30 +01:00
}
const (
maxInt = int(^uint(0) >> 1)
minInt = -maxInt - 1
invalidPos = minInt
)
2017-07-30 13:26:40 +02:00
var (
theUI = &UserInterface{
runnableOnUnfocused: true,
minWindowWidthInDP: glfw.DontCare,
minWindowHeightInDP: glfw.DontCare,
maxWindowWidthInDP: glfw.DontCare,
maxWindowHeightInDP: glfw.DontCare,
origPosX: invalidPos,
origPosY: invalidPos,
initVsync: true,
2019-12-21 09:34:58 +01:00
initCursorMode: driver.CursorModeVisible,
initWindowDecorated: true,
initWindowPositionXInDP: invalidPos,
initWindowPositionYInDP: invalidPos,
initWindowWidthInDP: 640,
initWindowHeightInDP: 480,
2020-02-09 15:03:03 +01:00
initFocused: true,
vsync: true,
2017-07-30 13:26:40 +02:00
}
)
2016-03-24 16:38:30 +01:00
2019-04-07 12:27:30 +02:00
func init() {
theUI.input.ui = theUI
2019-12-24 16:05:56 +01:00
theUI.iwindow.ui = theUI
2019-04-07 12:27:30 +02:00
}
func Get() *UserInterface {
return theUI
}
2016-07-23 13:25:52 +02:00
func init() {
hideConsoleWindowOnWindows()
2018-05-04 16:55:23 +02:00
if err := initialize(); err != nil {
panic(err)
}
2019-11-25 15:13:44 +01:00
glfw.SetMonitorCallback(func(monitor *glfw.Monitor, event glfw.PeripheralEvent) {
cacheMonitors()
})
cacheMonitors()
2016-07-23 13:25:52 +02:00
}
var glfwSystemCursors = map[driver.CursorShape]*glfw.Cursor{}
2016-07-23 13:25:52 +02:00
func initialize() error {
2016-05-07 15:27:10 +02:00
if err := glfw.Init(); err != nil {
2016-07-23 13:25:52 +02:00
return err
2014-12-05 18:26:02 +01:00
}
glfw.WindowHint(glfw.Visible, glfw.False)
glfw.WindowHint(glfw.ClientAPI, glfw.NoAPI)
// Create a window to set the initial monitor.
w, err := glfw.CreateWindow(16, 16, "", nil, nil)
2014-12-07 20:22:50 +01:00
if err != nil {
2016-07-23 13:25:52 +02:00
return err
2014-12-07 20:22:50 +01:00
}
if w == nil {
// This can happen on Windows Remote Desktop (#903).
panic("glfw: glfw.CreateWindow must not return nil")
}
defer w.Destroy()
m := currentMonitor(w)
theUI.initMonitor = m
v := m.GetVideoMode()
scale := devicescale.GetAt(currentMonitor(w).GetPos())
theUI.initFullscreenWidthInDP = int(fromGLFWMonitorPixel(float64(v.Width), scale))
theUI.initFullscreenHeightInDP = int(fromGLFWMonitorPixel(float64(v.Height), scale))
2017-08-12 08:39:41 +02:00
// Create system cursors. These cursors are destroyed at glfw.Terminate().
glfwSystemCursors[driver.CursorShapeDefault] = nil
glfwSystemCursors[driver.CursorShapeText] = glfw.CreateStandardCursor(glfw.IBeamCursor)
glfwSystemCursors[driver.CursorShapeCrosshair] = glfw.CreateStandardCursor(glfw.CrosshairCursor)
glfwSystemCursors[driver.CursorShapePointer] = glfw.CreateStandardCursor(glfw.HandCursor)
2016-07-23 13:25:52 +02:00
return nil
}
type cachedMonitor struct {
m *glfw.Monitor
vm *glfw.VidMode
// Pos of monitor in virtual coords
x int
y int
}
// monitors is the monitor list cache for desktop glfw compile targets.
// populated by 'cacheMonitors' which is called on init and every
// monitor config change event.
2018-11-14 17:08:36 +01:00
//
// monitors must be manipulated on the main thread.
var monitors []*cachedMonitor
func cacheMonitors() {
2018-11-14 17:08:36 +01:00
monitors = nil
ms := glfw.GetMonitors()
for _, m := range ms {
x, y := m.GetPos()
monitors = append(monitors, &cachedMonitor{
m: m,
vm: m.GetVideoMode(),
x: x,
y: y,
})
}
}
2020-08-23 20:05:38 +02:00
// getCachedMonitor returns a monitor for the given window x/y,
// or returns nil if monitor is not found.
2018-11-14 17:08:36 +01:00
//
// getCachedMonitor must be called on the main thread.
2020-08-23 20:05:38 +02:00
func getCachedMonitor(wx, wy int) *cachedMonitor {
for _, m := range monitors {
if m.x <= wx && wx < m.x+m.vm.Width && m.y <= wy && wy < m.y+m.vm.Height {
2020-08-23 20:05:38 +02:00
return m
}
}
2020-08-23 20:05:38 +02:00
return nil
}
func (u *UserInterface) isRunning() bool {
return atomic.LoadUint32(&u.running) != 0
2016-09-03 14:14:06 +02:00
}
func (u *UserInterface) setRunning(running bool) {
if running {
atomic.StoreUint32(&u.running, 1)
} else {
atomic.StoreUint32(&u.running, 0)
}
}
func (u *UserInterface) getWindowSizeLimits() (minw, minh, maxw, maxh int) {
u.m.RLock()
defer u.m.RUnlock()
minw, minh, maxw, maxh = -1, -1, -1, -1
if u.minWindowWidthInDP >= 0 {
minw = int(u.toGLFWPixel(float64(u.minWindowWidthInDP)))
}
if u.minWindowHeightInDP >= 0 {
minh = int(u.toGLFWPixel(float64(u.minWindowHeightInDP)))
}
if u.maxWindowWidthInDP >= 0 {
maxw = int(u.toGLFWPixel(float64(u.maxWindowWidthInDP)))
}
if u.maxWindowHeightInDP >= 0 {
maxh = int(u.toGLFWPixel(float64(u.maxWindowHeightInDP)))
}
return
}
func (u *UserInterface) getWindowSizeLimitsInDP() (minw, minh, maxw, maxh int) {
u.m.RLock()
defer u.m.RUnlock()
return u.minWindowWidthInDP, u.minWindowHeightInDP, u.maxWindowWidthInDP, u.maxWindowHeightInDP
}
func (u *UserInterface) setWindowSizeLimitsInDP(minw, minh, maxw, maxh int) bool {
u.m.RLock()
defer u.m.RUnlock()
if u.minWindowWidthInDP == minw && u.minWindowHeightInDP == minh && u.maxWindowWidthInDP == maxw && u.maxWindowHeightInDP == maxh {
return false
}
u.minWindowWidthInDP = minw
u.minWindowHeightInDP = minh
u.maxWindowWidthInDP = maxw
u.maxWindowHeightInDP = maxh
return true
}
func (u *UserInterface) getInitTitle() string {
u.m.RLock()
v := u.initTitle
u.m.RUnlock()
return v
}
func (u *UserInterface) setInitTitle(title string) {
u.m.RLock()
u.initTitle = title
u.m.RUnlock()
}
func (u *UserInterface) isInitVsyncEnabled() bool {
u.m.RLock()
v := u.initVsync
u.m.RUnlock()
return v
}
func (u *UserInterface) isInitFullscreen() bool {
u.m.RLock()
v := u.initFullscreen
u.m.RUnlock()
return v
}
func (u *UserInterface) setInitFullscreen(initFullscreen bool) {
u.m.Lock()
u.initFullscreen = initFullscreen
u.m.Unlock()
2016-09-03 14:14:06 +02:00
}
func (u *UserInterface) getInitCursorMode() driver.CursorMode {
u.m.RLock()
v := u.initCursorMode
u.m.RUnlock()
2017-08-12 08:39:41 +02:00
return v
}
func (u *UserInterface) setInitCursorMode(mode driver.CursorMode) {
2017-08-12 08:39:41 +02:00
u.m.Lock()
u.initCursorMode = mode
2017-08-12 08:39:41 +02:00
u.m.Unlock()
}
func (u *UserInterface) getCursorShape() driver.CursorShape {
u.m.RLock()
v := u.cursorShape
u.m.RUnlock()
return v
}
func (u *UserInterface) setCursorShape(shape driver.CursorShape) driver.CursorShape {
u.m.Lock()
old := u.cursorShape
u.cursorShape = shape
u.m.Unlock()
return old
}
func (u *UserInterface) isInitWindowDecorated() bool {
u.m.RLock()
v := u.initWindowDecorated
u.m.RUnlock()
return v
}
func (u *UserInterface) setInitWindowDecorated(decorated bool) {
u.m.Lock()
u.initWindowDecorated = decorated
u.m.Unlock()
}
func (u *UserInterface) isRunnableOnUnfocused() bool {
u.m.RLock()
v := u.runnableOnUnfocused
u.m.RUnlock()
return v
}
func (u *UserInterface) setRunnableOnUnfocused(runnableOnUnfocused bool) {
u.m.Lock()
u.runnableOnUnfocused = runnableOnUnfocused
u.m.Unlock()
}
func (u *UserInterface) isInitWindowResizable() bool {
u.m.RLock()
v := u.initWindowResizable
u.m.RUnlock()
return v
}
func (u *UserInterface) setInitWindowResizable(resizable bool) {
u.m.Lock()
u.initWindowResizable = resizable
u.m.Unlock()
}
func (u *UserInterface) isInitScreenTransparent() bool {
u.m.RLock()
v := u.initScreenTransparent
u.m.RUnlock()
return v
}
func (u *UserInterface) setInitScreenTransparent(transparent bool) {
u.m.RLock()
u.initScreenTransparent = transparent
u.m.RUnlock()
}
func (u *UserInterface) getIconImages() []image.Image {
u.m.RLock()
i := u.iconImages
u.m.RUnlock()
2017-09-22 21:12:02 +02:00
return i
}
func (u *UserInterface) setIconImages(iconImages []image.Image) {
2017-09-22 21:12:02 +02:00
u.m.Lock()
u.iconImages = iconImages
2017-09-22 21:12:02 +02:00
u.m.Unlock()
}
func (u *UserInterface) getInitWindowPosition() (int, int) {
u.m.RLock()
defer u.m.RUnlock()
if u.initWindowPositionXInDP != invalidPos && u.initWindowPositionYInDP != invalidPos {
2019-12-21 09:34:58 +01:00
return u.initWindowPositionXInDP, u.initWindowPositionYInDP
}
return invalidPos, invalidPos
}
func (u *UserInterface) setInitWindowPosition(x, y int) {
u.m.Lock()
defer u.m.Unlock()
2019-12-21 09:34:58 +01:00
u.initWindowPositionXInDP = x
u.initWindowPositionYInDP = y
}
func (u *UserInterface) getInitWindowSize() (int, int) {
u.m.Lock()
w, h := u.initWindowWidthInDP, u.initWindowHeightInDP
u.m.Unlock()
return w, h
}
func (u *UserInterface) setInitWindowSize(width, height int) {
u.m.Lock()
u.initWindowWidthInDP, u.initWindowHeightInDP = width, height
u.m.Unlock()
}
func (u *UserInterface) isInitWindowFloating() bool {
u.m.Lock()
f := u.initWindowFloating
u.m.Unlock()
return f
}
func (u *UserInterface) setInitWindowFloating(floating bool) {
u.m.Lock()
u.initWindowFloating = floating
u.m.Unlock()
}
func (u *UserInterface) isInitWindowMaximized() bool {
u.m.Lock()
f := u.initWindowMaximized
u.m.Unlock()
return f
}
func (u *UserInterface) setInitWindowMaximized(floating bool) {
u.m.Lock()
u.initWindowMaximized = floating
u.m.Unlock()
2020-02-09 15:03:03 +01:00
}
func (u *UserInterface) isInitFocused() bool {
u.m.Lock()
v := u.initFocused
u.m.Unlock()
return v
}
func (u *UserInterface) setInitFocused(focused bool) {
u.m.Lock()
u.initFocused = focused
u.m.Unlock()
}
func (u *UserInterface) ScreenSizeInFullscreen() (int, int) {
if !u.isRunning() {
return u.initFullscreenWidthInDP, u.initFullscreenHeightInDP
}
var w, h int
2019-06-05 17:19:12 +02:00
_ = u.t.Call(func() error {
v := currentMonitor(u.window).GetVideoMode()
s := u.deviceScaleFactor()
w = int(fromGLFWMonitorPixel(float64(v.Width), s))
h = int(fromGLFWMonitorPixel(float64(v.Height), s))
return nil
})
return w, h
2018-05-04 09:09:55 +02:00
}
2019-02-07 09:19:24 +01:00
// isFullscreen must be called from the main thread.
func (u *UserInterface) isFullscreen() bool {
if !u.isRunning() {
panic("glfw: isFullscreen can't be called before the main loop starts")
}
return u.window.GetMonitor() != nil
}
func (u *UserInterface) IsFullscreen() bool {
if !u.isRunning() {
return u.isInitFullscreen()
}
b := false
2019-06-05 17:19:12 +02:00
_ = u.t.Call(func() error {
2019-02-07 09:19:24 +01:00
b = u.isFullscreen()
return nil
})
return b
}
func (u *UserInterface) SetFullscreen(fullscreen bool) {
2017-08-02 18:07:04 +02:00
if !u.isRunning() {
u.setInitFullscreen(fullscreen)
return
}
var update bool
_ = u.t.Call(func() error {
update = u.isFullscreen() != fullscreen
return nil
})
if !update {
return
}
_ = u.t.Call(func() error {
if u.isNativeFullscreen() {
return nil
}
2020-10-16 21:21:07 +02:00
w, h := u.windowWidth, u.windowHeight
u.setWindowSize(w, h, fullscreen)
return nil
})
2017-08-02 18:07:04 +02:00
}
func (u *UserInterface) IsFocused() bool {
if !u.isRunning() {
return false
}
var focused bool
_ = u.t.Call(func() error {
focused = u.window.GetAttrib(glfw.Focused) == glfw.True
return nil
})
return focused
}
func (u *UserInterface) SetRunnableOnUnfocused(runnableOnUnfocused bool) {
u.setRunnableOnUnfocused(runnableOnUnfocused)
}
func (u *UserInterface) IsRunnableOnUnfocused() bool {
return u.isRunnableOnUnfocused()
}
func (u *UserInterface) SetVsyncEnabled(enabled bool) {
if !u.isRunning() {
// In general, m is used for locking init* values.
// m is not used for updating vsync in setWindowSize so far, but
// it should be OK since any goroutines can't reach here when
// the game already starts and setWindowSize can be called.
u.m.Lock()
u.initVsync = enabled
u.m.Unlock()
return
}
_ = u.t.Call(func() error {
if !u.vsyncInited {
u.m.Lock()
u.initVsync = enabled
u.m.Unlock()
return nil
}
u.vsync = enabled
u.updateVsync()
return nil
})
}
func (u *UserInterface) IsVsyncEnabled() bool {
if !u.isRunning() {
return u.isInitVsyncEnabled()
}
var v bool
_ = u.t.Call(func() error {
if !u.vsyncInited {
v = u.isInitVsyncEnabled()
return nil
}
v = u.vsync
return nil
})
return v
}
func (u *UserInterface) CursorMode() driver.CursorMode {
2017-08-12 08:39:41 +02:00
if !u.isRunning() {
return u.getInitCursorMode()
2017-08-12 08:39:41 +02:00
}
var v driver.CursorMode
2019-06-05 17:19:12 +02:00
_ = u.t.Call(func() error {
mode := u.window.GetInputMode(glfw.CursorMode)
switch mode {
case glfw.CursorNormal:
v = driver.CursorModeVisible
case glfw.CursorHidden:
v = driver.CursorModeHidden
case glfw.CursorDisabled:
v = driver.CursorModeCaptured
default:
2021-04-14 18:59:31 +02:00
panic(fmt.Sprintf("glfw: invalid GLFW cursor mode: %d", mode))
}
2017-08-12 08:39:41 +02:00
return nil
})
return v
}
func (u *UserInterface) SetCursorMode(mode driver.CursorMode) {
2017-08-12 08:39:41 +02:00
if !u.isRunning() {
u.setInitCursorMode(mode)
2017-08-12 08:39:41 +02:00
return
}
2019-06-05 17:19:12 +02:00
_ = u.t.Call(func() error {
2021-04-14 18:59:31 +02:00
u.window.SetInputMode(glfw.CursorMode, driverCursorModeToGLFWCursorMode(mode))
2017-08-12 08:39:41 +02:00
return nil
})
2016-09-03 10:17:54 +02:00
}
func (u *UserInterface) CursorShape() driver.CursorShape {
return u.getCursorShape()
}
func (u *UserInterface) SetCursorShape(shape driver.CursorShape) {
old := u.setCursorShape(shape)
if old == shape {
return
}
if !u.isRunning() {
return
}
_ = u.t.Call(func() error {
u.window.SetCursor(glfwSystemCursors[shape])
return nil
})
}
func (u *UserInterface) DeviceScaleFactor() float64 {
if !u.isRunning() {
// TODO: Use the initWindowPosition. This requires to convert the units correctly (#1575).
return devicescale.GetAt(u.initMonitor.GetPos())
}
f := 0.0
2019-06-05 17:19:12 +02:00
_ = u.t.Call(func() error {
f = u.deviceScaleFactor()
return nil
})
return f
}
// deviceScaleFactor must be called from the main thread.
func (u *UserInterface) deviceScaleFactor() float64 {
m := u.initMonitor
if u.window != nil {
m = currentMonitor(u.window)
}
return devicescale.GetAt(m.GetPos())
}
func init() {
// Lock the main thread.
runtime.LockOSThread()
}
func (u *UserInterface) RunWithoutMainLoop(context driver.UIContext) {
panic("glfw: RunWithoutMainLoop is not implemented")
}
// createWindow creates a GLFW window.
//
// createWindow must be called from the main thread.
//
// createWindow does not set the position or size so far.
func (u *UserInterface) createWindow() error {
if u.window != nil {
panic("glfw: u.window must not exist at createWindow")
}
// As a start, create a window with temporary size to create OpenGL context thread.
window, err := glfw.CreateWindow(16, 16, "", nil, nil)
if err != nil {
return err
}
u.window = window
if u.Graphics().IsGL() {
u.window.MakeContextCurrent()
}
u.window.SetInputMode(glfw.StickyMouseButtonsMode, glfw.True)
u.window.SetInputMode(glfw.StickyKeysMode, glfw.True)
2021-04-14 18:59:31 +02:00
u.window.SetInputMode(glfw.CursorMode, driverCursorModeToGLFWCursorMode(u.getInitCursorMode()))
u.window.SetCursor(glfwSystemCursors[u.getCursorShape()])
u.window.SetTitle(u.title)
// TODO: Set icons
u.registerWindowSetSizeCallback()
return nil
}
// registerWindowSetSizeCallback must be called from the main thread.
func (u *UserInterface) registerWindowSetSizeCallback() {
u.window.SetSizeCallback(func(_ *glfw.Window, width, height int) {
if !u.setSizeCallbackEnabled {
return
}
if u.window.GetAttrib(glfw.Resizable) == glfw.False {
return
}
if u.isFullscreen() {
return
}
if err := u.runOnAnotherThreadFromMainThread(func() error {
var outsideWidth, outsideHeight float64
var outsideSizeChanged bool
_ = u.t.Call(func() error {
if width != 0 || height != 0 {
u.setWindowSize(width, height, u.isFullscreen())
}
outsideWidth, outsideHeight, outsideSizeChanged = u.updateSize()
return nil
})
if outsideSizeChanged {
u.context.Layout(outsideWidth, outsideHeight)
}
if err := u.context.ForceUpdate(); err != nil {
return err
}
if u.Graphics().IsGL() {
_ = u.t.Call(func() error {
u.swapBuffers()
return nil
})
}
return nil
}); err != nil {
u.err = err
}
})
}
2020-10-16 21:21:07 +02:00
func (u *UserInterface) init() error {
if u.Graphics().IsGL() {
glfw.WindowHint(glfw.ClientAPI, glfw.OpenGLAPI)
glfw.WindowHint(glfw.ContextVersionMajor, 2)
glfw.WindowHint(glfw.ContextVersionMinor, 1)
} else {
glfw.WindowHint(glfw.ClientAPI, glfw.NoAPI)
}
2020-10-16 21:21:07 +02:00
decorated := glfw.False
if u.isInitWindowDecorated() {
decorated = glfw.True
}
glfw.WindowHint(glfw.Decorated, decorated)
2020-10-16 21:21:07 +02:00
transparent := glfw.False
if u.isInitScreenTransparent() {
transparent = glfw.True
}
glfw.WindowHint(glfw.TransparentFramebuffer, transparent)
u.Graphics().SetTransparent(u.isInitScreenTransparent())
2020-10-16 21:21:07 +02:00
resizable := glfw.False
if u.isInitWindowResizable() {
resizable = glfw.True
}
glfw.WindowHint(glfw.Resizable, resizable)
2020-10-16 21:21:07 +02:00
floating := glfw.False
if u.isInitWindowFloating() {
floating = glfw.True
}
glfw.WindowHint(glfw.Floating, floating)
2020-02-09 15:03:03 +01:00
2020-10-16 21:21:07 +02:00
focused := glfw.False
if u.isInitFocused() {
focused = glfw.True
}
glfw.WindowHint(glfw.FocusOnShow, focused)
2020-10-16 21:21:07 +02:00
// Set the window visible explicitly or the application freezes on Wayland (#974).
if os.Getenv("WAYLAND_DISPLAY") != "" {
glfw.WindowHint(glfw.Visible, glfw.True)
}
2020-10-16 21:21:07 +02:00
if err := u.createWindow(); err != nil {
return err
}
u.setSizeCallbackEnabled = true
setSize := func() {
ww, wh := u.getInitWindowSize()
ww = int(u.toGLFWPixel(float64(ww)))
wh = int(u.toGLFWPixel(float64(wh)))
u.setWindowSize(ww, wh, u.isFullscreen())
}
2020-03-28 17:33:23 +01:00
// Set the window size and the window position in this order on Linux or other UNIX using X (#1118),
2020-10-16 21:21:07 +02:00
// but this should be inverted on Windows. This is very tricky, but there is no obvious way to solve
// this. This doesn't matter on macOS.
if runtime.GOOS == "windows" {
u.setWindowPosition(u.getInitWindowPosition())
setSize()
} else {
setSize()
u.setWindowPosition(u.getInitWindowPosition())
}
u.updateWindowSizeLimits()
// Maximizing a window requires a proper size and position. Call Maximize here (#1117).
if u.isInitWindowMaximized() {
2020-10-16 21:21:07 +02:00
u.window.Maximize()
}
2020-10-16 21:21:07 +02:00
u.title = u.getInitTitle()
u.window.SetTitle(u.title)
u.window.Show()
2018-12-28 06:08:44 +01:00
if g, ok := u.Graphics().(interface{ SetWindow(uintptr) }); ok {
2020-10-16 21:21:07 +02:00
g.SetWindow(u.nativeWindow())
}
2020-10-16 21:21:07 +02:00
return nil
}
func (u *UserInterface) updateSize() (float64, float64, bool) {
ww, wh := u.windowWidth, u.windowHeight
u.setWindowSize(ww, wh, u.isFullscreen())
if !u.toChangeSize {
return 0, 0, false
}
u.toChangeSize = false
var w, h float64
if u.isFullscreen() {
v := currentMonitor(u.window).GetVideoMode()
ww, wh := v.Width, v.Height
s := u.deviceScaleFactor()
w = fromGLFWMonitorPixel(float64(ww), s)
h = fromGLFWMonitorPixel(float64(wh), s)
} else {
// Instead of u.windowWidth and u.windowHeight, use the actual window size here.
// On Windows, the specified size at SetSize and the actual window size might not
// match (#1163).
ww, wh := u.window.GetSize()
w = u.fromGLFWPixel(float64(ww))
h = u.fromGLFWPixel(float64(wh))
}
// On Linux/UNIX, further adjusting is required (#1307).
w = u.toFramebufferPixel(w)
h = u.toFramebufferPixel(h)
return w, h, true
}
// update must be called from the main thread.
func (u *UserInterface) update() (float64, float64, bool, error) {
if u.err != nil {
return 0, 0, false, u.err
}
2020-10-17 08:09:12 +02:00
if u.window.ShouldClose() {
return 0, 0, false, driver.RegularTermination
}
if u.isInitFullscreen() {
w, h := u.window.GetSize()
u.setWindowSize(w, h, true)
u.setInitFullscreen(false)
}
// Initialize vsync after SetMonitor is called. See the comment in updateVsync.
// Calling this inside setWindowSize didn't work (#1363).
if !u.vsyncInited {
u.vsync = u.isInitVsyncEnabled()
u.updateVsync()
u.vsyncInited = true
}
outsideWidth, outsideHeight, outsideSizeChanged := u.updateSize()
2020-10-17 10:45:29 +02:00
// TODO: Updating the input can be skipped when clock.Update returns 0 (#1367).
glfw.PollEvents()
u.input.update(u.window, u.context)
for !u.isRunnableOnUnfocused() && u.window.GetAttrib(glfw.Focused) == 0 && !u.window.ShouldClose() {
hooks.SuspendAudio()
// Wait for an arbitrary period to avoid busy loop.
time.Sleep(time.Second / 60)
2019-03-31 12:51:53 +02:00
glfw.PollEvents()
}
2020-10-17 10:45:29 +02:00
hooks.ResumeAudio()
return outsideWidth, outsideHeight, outsideSizeChanged, nil
}
2020-04-02 17:06:42 +02:00
func (u *UserInterface) loop() error {
2016-09-01 18:07:41 +02:00
defer func() {
2019-06-05 17:19:12 +02:00
_ = u.t.Call(func() error {
2016-09-01 18:07:41 +02:00
glfw.Terminate()
return nil
})
}()
for {
var unfocused bool
// On Windows, the focusing state might be always false (#987).
// On Windows, even if a window is in another workspace, vsync seems to work.
// Then let's assume the window is always 'focused' as a workaround.
if runtime.GOOS != "windows" {
unfocused = u.window.GetAttrib(glfw.Focused) == glfw.False
}
var t1, t2 time.Time
if unfocused {
t1 = time.Now()
}
var outsideWidth, outsideHeight float64
var outsideSizeChanged bool
if err := u.t.Call(func() error {
var err error
outsideWidth, outsideHeight, outsideSizeChanged, err = u.update()
return err
}); err != nil {
return err
}
if outsideSizeChanged {
u.context.Layout(outsideWidth, outsideHeight)
}
if err := u.context.Update(); err != nil {
return err
}
// Create icon images in a different goroutine (#1478).
2021-04-21 15:50:00 +02:00
// In the fullscreen mode, SetIcon fails (#1578).
if imgs := u.getIconImages(); imgs != nil && !u.isFullscreen() {
u.setIconImages(nil)
// Convert the icons in the different goroutine, as (*ebiten.Image).At cannot be invoked
// from this goroutine. At works only in between BeginFrame and EndFrame.
go func() {
newImgs := make([]image.Image, len(imgs))
for i, img := range imgs {
// TODO: If img is not *ebiten.Image, this converting is not necessary.
// However, this package cannot refer *ebiten.Image due to the package
// dependencies.
b := img.Bounds()
rgba := image.NewRGBA(b)
for j := b.Min.Y; j < b.Max.Y; j++ {
for i := b.Min.X; i < b.Max.X; i++ {
rgba.Set(i, j, img.At(i, j))
}
}
newImgs[i] = rgba
}
_ = u.t.Call(func() error {
2021-04-21 15:50:00 +02:00
// In the fullscreen mode, reset the icon images and try again later.
if u.isFullscreen() {
u.setIconImages(imgs)
return nil
}
u.window.SetIcon(newImgs)
return nil
})
}()
}
// swapBuffers also checks IsGL, so this condition is redundant.
// However, (*thread).Call is not good for performance due to channels.
// Let's avoid this whenever possible (#1367).
if u.Graphics().IsGL() {
_ = u.t.Call(func() error {
u.swapBuffers()
return nil
})
}
if unfocused {
t2 = time.Now()
}
// When a window is not focused, SwapBuffers might return immediately and CPU might be busy.
// Mitigate this by sleeping (#982).
if unfocused {
d := t2.Sub(t1)
const wait = time.Second / 60
if d < wait {
time.Sleep(wait - d)
}
}
2016-07-23 14:01:30 +02:00
}
2016-03-26 09:24:40 +01:00
}
2018-02-24 16:00:59 +01:00
// swapBuffers must be called from the main thread.
func (u *UserInterface) swapBuffers() {
if u.Graphics().IsGL() {
2018-11-12 16:00:10 +01:00
u.window.SwapBuffers()
}
2014-12-14 10:57:29 +01:00
}
2015-02-09 02:25:00 +01:00
// updateWindowSizeLimits must be called from the main thread.
func (u *UserInterface) updateWindowSizeLimits() {
minw, minh, maxw, maxh := u.getWindowSizeLimitsInDP()
if minw < 0 {
minw = glfw.DontCare
} else {
minw = int(u.toGLFWPixel(float64(minw)))
}
if minh < 0 {
minh = glfw.DontCare
} else {
minh = int(u.toGLFWPixel(float64(minh)))
}
if maxw < 0 {
maxw = glfw.DontCare
} else {
maxw = int(u.toGLFWPixel(float64(maxw)))
}
if maxh < 0 {
maxh = glfw.DontCare
} else {
maxh = int(u.toGLFWPixel(float64(maxh)))
}
u.window.SetSizeLimits(minw, minh, maxw, maxh)
}
// adjustWindowSizeBasedOnSizeLimitsInDP adjust the size based on the window size limits.
// width and height are in device-dependent pixels.
func (u *UserInterface) adjustWindowSizeBasedOnSizeLimits(width, height int) (int, int) {
minw, minh, maxw, maxh := u.getWindowSizeLimits()
if minw >= 0 && width < minw {
width = minw
}
if minh >= 0 && height < minh {
height = minh
}
if maxw >= 0 && width > maxw {
width = maxw
}
if maxh >= 0 && height > maxh {
height = maxh
}
return width, height
}
// adjustWindowSizeBasedOnSizeLimitsInDP adjust the size based on the window size limits.
// width and height are in device-independent pixels.
func (u *UserInterface) adjustWindowSizeBasedOnSizeLimitsInDP(width, height int) (int, int) {
minw, minh, maxw, maxh := u.getWindowSizeLimitsInDP()
if minw >= 0 && width < minw {
width = minw
}
if minh >= 0 && height < minh {
height = minh
}
if maxw >= 0 && width > maxw {
width = maxw
}
if maxh >= 0 && height > maxh {
height = maxh
}
return width, height
}
2020-10-16 21:21:07 +02:00
// setWindowSize must be called from the main thread.
func (u *UserInterface) setWindowSize(width, height int, fullscreen bool) {
width, height = u.adjustWindowSizeBasedOnSizeLimits(width, height)
2020-10-16 21:21:07 +02:00
if u.windowWidth == width && u.windowHeight == height && u.isFullscreen() == fullscreen && u.lastDeviceScaleFactor == u.deviceScaleFactor() {
return
}
2020-10-16 21:21:07 +02:00
if width < 1 {
width = 1
}
if height < 1 {
height = 1
}
2017-10-19 20:25:21 +02:00
2020-10-16 21:21:07 +02:00
u.lastDeviceScaleFactor = u.deviceScaleFactor()
2017-10-19 20:25:21 +02:00
2020-10-16 21:21:07 +02:00
// To make sure the current existing framebuffers are rendered,
// swap buffers here before SetSize is called.
u.swapBuffers()
// Disable the callback of SetSize. This callback can be invoked by SetMonitor or SetSize.
// ForceUpdate is called from the callback.
// While setWindowSize can be called from Update, calling ForceUpdate inside Update is illegal (#1505).
if u.setSizeCallbackEnabled {
u.setSizeCallbackEnabled = false
defer func() {
u.setSizeCallbackEnabled = true
}()
}
2020-10-16 21:21:07 +02:00
var windowRecreated bool
2020-10-16 21:21:07 +02:00
if fullscreen {
if u.origPosX == invalidPos || u.origPosY == invalidPos {
u.origPosX, u.origPosY = u.window.GetPos()
}
m := currentMonitor(u.window)
v := m.GetVideoMode()
u.window.SetMonitor(m, 0, 0, v.Width, v.Height, v.RefreshRate)
// Swapping buffer is necesary to prevent the image lag (#1004).
// TODO: This might not work when vsync is disabled.
if u.Graphics().IsGL() {
glfw.PollEvents()
u.swapBuffers()
}
} else {
// On Windows, giving a too small width doesn't call a callback (#165).
// To prevent hanging up, return asap if the width is too small.
// 126 is an arbitrary number and I guess this is small enough.
minWindowWidth := int(u.toGLFWPixel(126))
if u.window.GetAttrib(glfw.Decorated) == glfw.False {
minWindowWidth = 1
}
if width < minWindowWidth {
width = minWindowWidth
}
2020-10-16 21:21:07 +02:00
if u.window.GetMonitor() != nil {
if u.Graphics().IsGL() {
2020-10-16 21:21:07 +02:00
// When OpenGL is used, swapping buffer is enough to solve the image-lag
// issue (#1004). Rather, recreating window destroys GPU resources.
// TODO: This might not work when vsync is disabled.
u.window.SetMonitor(nil, 0, 0, width, height, 0)
2017-10-19 20:25:21 +02:00
glfw.PollEvents()
u.swapBuffers()
2020-10-16 21:21:07 +02:00
} else {
// Recreate the window since an image lag remains after coming back from
// fullscreen (#1004).
if u.window != nil {
u.window.Destroy()
u.window = nil
}
if err := u.createWindow(); err != nil {
// TODO: This should return an error.
panic(fmt.Sprintf("glfw: failed to recreate window: %v", err))
2017-10-19 20:25:21 +02:00
}
// Reset the size limits explicitly.
u.updateWindowSizeLimits()
2020-10-16 21:21:07 +02:00
u.window.Show()
windowRecreated = true
}
2020-10-16 21:21:07 +02:00
}
2020-10-16 21:21:07 +02:00
if u.origPosX != invalidPos && u.origPosY != invalidPos {
x := u.origPosX
y := u.origPosY
u.window.SetPos(x, y)
// Dirty hack for macOS (#703). Rendering doesn't work correctly with one SetPos, but
// work with two or more SetPos.
if runtime.GOOS == "darwin" {
u.window.SetPos(x+1, y)
u.window.SetPos(x, y)
}
2020-10-16 21:21:07 +02:00
u.origPosX = invalidPos
u.origPosY = invalidPos
}
2020-10-16 21:21:07 +02:00
// Set the window size after the position. The order matters.
// In the opposite order, the window size might not be correct when going back from fullscreen with multi monitors.
oldW, oldH := u.window.GetSize()
newW := width
newH := height
if oldW != newW || oldH != newH {
ch := make(chan struct{}, 1)
2020-10-16 21:21:07 +02:00
u.window.SetFramebufferSizeCallback(func(_ *glfw.Window, _, _ int) {
ch <- struct{}{}
2020-10-16 21:21:07 +02:00
})
u.window.SetSize(newW, newH)
if w, h := u.window.GetSize(); w != oldW || h != oldH {
event:
for {
glfw.PollEvents()
select {
case <-ch:
break event
default:
}
}
}
u.window.SetFramebufferSizeCallback(nil)
close(ch)
}
2020-10-16 21:21:07 +02:00
// Window title might be lost on macOS after coming back from fullscreen.
u.window.SetTitle(u.title)
}
2020-10-16 21:21:07 +02:00
// As width might be updated, update windowWidth/Height here.
u.windowWidth = width
u.windowHeight = height
u.toChangeSize = true
if windowRecreated {
if g, ok := u.Graphics().(interface{ SetWindow(uintptr) }); ok {
g.SetWindow(u.nativeWindow())
}
}
2015-02-09 02:25:00 +01:00
}
// updateVsync must be called on the main thread.
func (u *UserInterface) updateVsync() {
if u.Graphics().IsGL() {
// SwapInterval is affected by the current monitor of the window.
// This needs to be called at least after SetMonitor.
// Without SwapInterval after SetMonitor, vsynch doesn't work (#375).
//
// TODO: (#405) If triple buffering is needed, SwapInterval(0) should be called,
// but is this correct? If glfw.SwapInterval(0) and the driver doesn't support triple
// buffering, what will happen?
if u.vsync {
glfw.SwapInterval(1)
} else {
glfw.SwapInterval(0)
}
}
u.Graphics().SetVsyncEnabled(u.vsync)
}
// currentMonitor returns the current active monitor.
//
// The given window might or might not be used to detect the monitor.
//
// currentMonitor must be called on the main thread.
func currentMonitor(window *glfw.Window) *glfw.Monitor {
2021-04-21 15:50:00 +02:00
// GetMonitor is available only in fullscreen.
if m := window.GetMonitor(); m != nil {
return m
}
// Getting a monitor from a window position is not reliable in general (e.g., when a window is put across
2020-08-23 17:57:48 +02:00
// multiple monitors, or, before SetWindowPosition is called.).
// Get the monitor which the current window belongs to. This requires OS API.
if m := currentMonitorByOS(window); m != nil {
return m
}
// As the fallback, detect the monitor from the window.
if m := getCachedMonitor(window.GetPos()); m != nil {
return m.m
}
return glfw.GetPrimaryMonitor()
}
2019-04-07 11:28:50 +02:00
func (u *UserInterface) SetScreenTransparent(transparent bool) {
if !u.isRunning() {
u.setInitScreenTransparent(transparent)
return
}
panic("glfw: SetScreenTransparent can't be called after the main loop starts")
}
func (u *UserInterface) IsScreenTransparent() bool {
if !u.isRunning() {
return u.isInitScreenTransparent()
}
val := false
_ = u.t.Call(func() error {
val = u.window.GetAttrib(glfw.TransparentFramebuffer) == glfw.True
return nil
})
return val
}
2020-04-02 17:06:42 +02:00
func (u *UserInterface) ResetForFrame() {
// The offscreens must be updated every frame (#490).
var w, h float64
var changed bool
_ = u.t.Call(func() error {
w, h, changed = u.updateSize()
return nil
})
if changed {
u.context.Layout(w, h)
}
2020-04-02 17:06:42 +02:00
u.input.resetForFrame()
}
2020-02-09 15:03:03 +01:00
func (u *UserInterface) MonitorPosition() (int, int) {
if !u.isRunning() {
return u.monitorPosition()
}
var mx, my int
_ = u.t.Call(func() error {
mx, my = u.monitorPosition()
return nil
})
return mx, my
}
func (u *UserInterface) SetInitFocused(focused bool) {
if u.isRunning() {
panic("ui: SetInitFocused must be called before the main loop")
}
u.setInitFocused(focused)
}
func (u *UserInterface) monitorPosition() (int, int) {
// TODO: fromGLFWMonitorPixel might be required.
return currentMonitor(u.window).GetPos()
2020-02-09 15:03:03 +01:00
}
2019-04-07 11:28:50 +02:00
func (u *UserInterface) Input() driver.Input {
return &u.input
2019-04-07 11:28:50 +02:00
}
2019-12-24 16:05:56 +01:00
func (u *UserInterface) Window() driver.Window {
return &u.iwindow
}
// GLFW's functions to manipulate a window can invoke the SetSize callback (#1576, #1585, #1606).
// As the callback must not be called in the frame (between BeginFrame and EndFrame),
// disable the callback temporarily.
// maximizeWindow must be called from the main thread.
func (u *UserInterface) maximizeWindow() {
if u.setSizeCallbackEnabled {
u.setSizeCallbackEnabled = false
defer func() {
u.setSizeCallbackEnabled = true
}()
}
u.window.Maximize()
if !u.isFullscreen() {
// On Linux/UNIX, maximizing might not finish even though Maximize returns. Just wait for its finish.
2021-04-21 15:50:00 +02:00
// Do not check this in the fullscreen since apparently the condition can never be true.
for u.window.GetAttrib(glfw.Maximized) != glfw.True {
glfw.PollEvents()
}
// Call setWindowSize explicitly in order to update the rendering since the callback is disabled now.
2021-04-21 15:50:00 +02:00
// Do not call setWindowSize in the fullscreen mode since setWindowSize requires the window size
// before the fullscreen, while window.GetSize() returns the desktop screen size in the fullscreen mode.
w, h := u.window.GetSize()
u.setWindowSize(w, h, u.isFullscreen())
}
}
// iconifyWindow must be called from the main thread.
func (u *UserInterface) iconifyWindow() {
if u.setSizeCallbackEnabled {
u.setSizeCallbackEnabled = false
defer func() {
u.setSizeCallbackEnabled = true
}()
}
u.window.Iconify()
// On Linux/UNIX, iconifying might not finish even though Iconify returns. Just wait for its finish.
for u.window.GetAttrib(glfw.Iconified) != glfw.True {
glfw.PollEvents()
}
// After iconifiying, the window is invisible and setWindowSize doesn't have to be called.
// Rather, the window size might be (0, 0) and it might be impossible to call setWindowSize (#1585).
}
// restoreWindow must be called from the main thread.
func (u *UserInterface) restoreWindow() {
if u.setSizeCallbackEnabled {
u.setSizeCallbackEnabled = false
defer func() {
u.setSizeCallbackEnabled = true
}()
}
u.window.Restore()
// On Linux/UNIX, restoring might not finish even though Restore returns (#1608). Just wait for its finish.
// On macOS, the restoring state might be the same as the maximized state. Skip this.
if runtime.GOOS != "darwin" {
for u.window.GetAttrib(glfw.Maximized) == glfw.True || u.window.GetAttrib(glfw.Iconified) == glfw.True {
glfw.PollEvents()
}
}
// Call setWindowSize explicitly in order to update the rendering since the callback is disabled now.
2021-04-21 15:50:00 +02:00
// Do not call setWindowSize in the fullscreen mode since setWindowSize requires the window size
// before the fullscreen, while window.GetSize() returns the desktop screen size in the fullscreen mode.
if !u.isFullscreen() {
w, h := u.window.GetSize()
u.setWindowSize(w, h, u.isFullscreen())
}
}
// setWindowDecorated must be called from the main thread.
func (u *UserInterface) setWindowDecorated(decorated bool) {
if u.setSizeCallbackEnabled {
u.setSizeCallbackEnabled = false
defer func() {
u.setSizeCallbackEnabled = true
}()
}
v := glfw.False
if decorated {
v = glfw.True
}
u.window.SetAttrib(glfw.Decorated, v)
// The title can be lost when the decoration is gone. Recover this.
if decorated {
u.window.SetTitle(u.title)
}
}
// setWindowFloating must be called from the main thread.
func (u *UserInterface) setWindowFloating(floating bool) {
if u.setSizeCallbackEnabled {
u.setSizeCallbackEnabled = false
defer func() {
u.setSizeCallbackEnabled = true
}()
}
v := glfw.False
if floating {
v = glfw.True
}
u.window.SetAttrib(glfw.Floating, v)
}
// setWindowResizable must be called from the main thread.
func (u *UserInterface) setWindowResizable(resizable bool) {
if u.setSizeCallbackEnabled {
u.setSizeCallbackEnabled = false
defer func() {
u.setSizeCallbackEnabled = true
}()
}
v := glfw.False
if resizable {
v = glfw.True
}
u.window.SetAttrib(glfw.Resizable, v)
}
// setWindowPosition must be called from the main thread.
func (u *UserInterface) setWindowPosition(x, y int) {
if u.setSizeCallbackEnabled {
u.setSizeCallbackEnabled = false
defer func() {
u.setSizeCallbackEnabled = true
}()
}
mx, my := currentMonitor(u.window).GetPos()
xf := u.toGLFWPixel(float64(x))
yf := u.toGLFWPixel(float64(y))
if x, y := u.adjustWindowPosition(mx+int(xf), my+int(yf)); u.isFullscreen() {
u.origPosX, u.origPosY = x, y
} else {
u.window.SetPos(x, y)
}
// Call setWindowSize explicitly in order to update the rendering since the callback is disabled now.
//
// There are cases when setWindowSize should be called (#1606) and should not be called (#1609).
// For the former, macOS seems enough so far.
//
2021-04-21 15:50:00 +02:00
// Do not call setWindowSize in the fullscreen mode since setWindowSize requires the window size
// before the fullscreen, while window.GetSize() returns the desktop screen size in the fullscreen mode.
if !u.isFullscreen() && runtime.GOOS == "darwin" {
w, h := u.window.GetSize()
u.setWindowSize(w, h, u.isFullscreen())
}
}
// setWindowTitle must be called from the main thread.
func (u *UserInterface) setWindowTitle(title string) {
if u.setSizeCallbackEnabled {
u.setSizeCallbackEnabled = false
defer func() {
u.setSizeCallbackEnabled = true
}()
}
u.window.SetTitle(title)
}