ebiten/internal/ui/ui_glfw.go

454 lines
9.9 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
2015-01-02 07:20:05 +01:00
// +build !js
// +build !android
2016-06-15 17:49:22 +02:00
// +build !ios
2015-01-02 07:20:05 +01:00
2015-01-27 14:02:23 +01:00
package ui
2014-12-05 18:26:02 +01:00
import (
"errors"
2014-12-14 10:57:29 +01:00
"runtime"
2016-09-03 14:14:06 +02:00
"sync"
"time"
2015-06-20 18:33:28 +02:00
2016-09-03 09:25:43 +02:00
"github.com/go-gl/glfw/v3.2/glfw"
"github.com/hajimehoshi/ebiten/internal/opengl"
2014-12-05 18:26:02 +01:00
)
type userInterface struct {
title string
2017-06-29 18:24:37 +02:00
window *glfw.Window
width int
height int
scale float64
deviceScale float64
glfwScale float64
fullscreen bool
fullscreenScale float64
funcs chan func()
running bool
sizeChanged bool
origPosX int
origPosY int
m sync.Mutex
2016-03-24 16:38:30 +01:00
}
var currentUI *userInterface
2016-03-24 16:38:30 +01:00
2016-07-23 13:25:52 +02:00
func init() {
if err := initialize(); err != nil {
panic(err)
}
}
func initialize() error {
runtime.LockOSThread()
2014-12-05 18:26:02 +01:00
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)
2014-12-05 18:26:02 +01:00
glfw.WindowHint(glfw.Resizable, glfw.False)
2016-02-21 09:27:26 +01:00
glfw.WindowHint(glfw.ContextVersionMajor, 2)
glfw.WindowHint(glfw.ContextVersionMinor, 1)
2015-02-09 02:25:00 +01:00
// As start, create an window with temporary size to create OpenGL context thread.
window, 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
}
hideConsoleWindowOnWindows()
u := &userInterface{
window: window,
funcs: make(chan func()),
sizeChanged: true,
origPosX: -1,
origPosY: -1,
2014-12-07 20:22:50 +01:00
}
u.window.MakeContextCurrent()
currentUI = u
2016-07-23 13:25:52 +02:00
return nil
}
2016-09-02 17:00:44 +02:00
func RunMainThreadLoop(ch <-chan error) error {
2016-05-06 05:23:48 +02:00
// TODO: Check this is done on the main thread.
2016-09-03 14:14:06 +02:00
currentUI.setRunning(true)
defer func() {
currentUI.setRunning(false)
}()
for {
select {
2016-09-02 16:38:02 +02:00
case f := <-currentUI.funcs:
f()
case err := <-ch:
// ch returns a value not only when an error occur but also it is closed.
return err
}
2016-05-06 05:23:48 +02:00
}
}
2016-09-03 14:14:06 +02:00
func (u *userInterface) isRunning() bool {
u.m.Lock()
defer u.m.Unlock()
return u.running
}
func (u *userInterface) setRunning(running bool) {
u.m.Lock()
defer u.m.Unlock()
u.running = running
}
2016-07-23 14:01:30 +02:00
func (u *userInterface) runOnMainThread(f func() error) error {
2016-05-06 05:23:48 +02:00
if u.funcs == nil {
// already closed
2016-07-23 14:01:30 +02:00
return nil
2016-05-06 05:23:48 +02:00
}
ch := make(chan struct{})
2016-07-23 14:01:30 +02:00
var err error
2016-05-06 05:23:48 +02:00
u.funcs <- func() {
2016-07-23 14:01:30 +02:00
err = f()
2016-05-06 05:23:48 +02:00
close(ch)
}
<-ch
2016-07-23 14:01:30 +02:00
return err
2016-05-06 05:23:48 +02:00
}
func SetScreenSize(width, height int) bool {
2016-09-02 16:38:02 +02:00
u := currentUI
2016-09-03 14:14:06 +02:00
if !u.isRunning() {
panic("ui: Run is not called yet")
2016-09-03 14:14:06 +02:00
}
2016-05-06 05:23:48 +02:00
r := false
_ = u.runOnMainThread(func() error {
r = u.setScreenSize(width, height, u.scale, u.fullscreen)
2016-07-23 14:01:30 +02:00
return nil
})
return r
2015-01-27 14:02:23 +01:00
}
func SetScreenScale(scale float64) bool {
2016-09-02 16:38:02 +02:00
u := currentUI
2016-09-03 14:14:06 +02:00
if !u.isRunning() {
panic("ui: Run is not called yet")
2016-09-03 14:14:06 +02:00
}
2016-05-06 05:23:48 +02:00
r := false
_ = u.runOnMainThread(func() error {
r = u.setScreenSize(u.width, u.height, scale, u.fullscreen)
return nil
})
return r
}
func SetFullscreen(fullscreen bool) bool {
u := currentUI
if !u.isRunning() {
panic("ui: Run is not called yet")
}
r := false
_ = u.runOnMainThread(func() error {
r = u.setScreenSize(u.width, u.height, u.scale, fullscreen)
2016-07-23 14:01:30 +02:00
return nil
})
return r
2015-01-27 14:02:23 +01:00
}
2016-09-02 16:38:02 +02:00
func ScreenScale() float64 {
u := currentUI
2016-09-03 14:14:06 +02:00
if !u.isRunning() {
return 0
}
2016-06-18 19:59:17 +02:00
s := 0.0
2016-08-03 16:44:54 +02:00
_ = u.runOnMainThread(func() error {
2016-05-06 05:23:48 +02:00
s = u.scale
2016-07-23 14:01:30 +02:00
return nil
2016-05-06 05:23:48 +02:00
})
return s
2015-01-27 14:02:23 +01:00
}
func IsFullscreen() bool {
u := currentUI
if !u.isRunning() {
return false
}
f := false
_ = u.runOnMainThread(func() error {
f = u.fullscreen
return nil
})
return f
}
func ScreenOffset() (float64, float64) {
u := currentUI
if !u.isRunning() {
return 0, 0
}
if !IsFullscreen() {
return 0, 0
}
ox := 0.0
oy := 0.0
m := glfw.GetPrimaryMonitor()
v := m.GetVideoMode()
_ = u.runOnMainThread(func() error {
ox = (float64(v.Width)*u.deviceScale/u.glfwScale - float64(u.width)*u.actualScreenScale()) / 2
oy = (float64(v.Height)*u.deviceScale/u.glfwScale - float64(u.height)*u.actualScreenScale()) / 2
return nil
})
return ox, oy
}
func adjustCursorPosition(x, y int) (int, int) {
u := currentUI
if !u.isRunning() {
return x, y
}
ox, oy := ScreenOffset()
s := 0.0
_ = currentUI.runOnMainThread(func() error {
s = currentUI.actualScreenScale()
return nil
})
return x - int(ox/s), y - int(oy/s)
}
2016-09-03 10:17:54 +02:00
func SetCursorVisibility(visible bool) {
// This can be called before Run: change the state asyncly.
go func() {
_ = currentUI.runOnMainThread(func() error {
c := glfw.CursorNormal
if !visible {
c = glfw.CursorHidden
}
currentUI.window.SetInputMode(glfw.CursorMode, c)
return nil
})
}()
}
2016-09-02 19:12:11 +02:00
func Run(width, height int, scale float64, title string, g GraphicsContext) error {
2016-09-02 17:20:05 +02:00
u := currentUI
2016-07-23 21:32:12 +02:00
// GLContext must be created before setting the screen size, which requires
2016-07-23 15:17:36 +02:00
// swapping buffers.
opengl.Init(currentUI.runOnMainThread)
2016-07-23 14:01:30 +02:00
if err := u.runOnMainThread(func() error {
2016-05-06 05:23:48 +02:00
m := glfw.GetPrimaryMonitor()
v := m.GetVideoMode()
if !u.setScreenSize(width, height, scale, false) {
2016-07-23 14:01:30 +02:00
return errors.New("ui: Fail to set the screen size")
2016-05-06 05:23:48 +02:00
}
u.title = title
2016-05-06 05:23:48 +02:00
u.window.SetTitle(title)
u.window.Show()
2014-12-14 10:57:29 +01:00
2016-07-04 04:37:34 +02:00
w, h := u.glfwSize()
x := (v.Width - w) / 2
y := (v.Height - h) / 3
x, y = adjustWindowPosition(x, y)
2016-05-06 05:23:48 +02:00
u.window.SetPos(x, y)
2016-07-23 14:01:30 +02:00
return nil
}); err != nil {
return err
}
2016-09-01 19:31:03 +02:00
return u.loop(g)
}
2016-07-04 04:37:34 +02:00
func (u *userInterface) glfwSize() (int, int) {
2017-06-04 17:06:40 +02:00
if u.glfwScale == 0 {
u.glfwScale = glfwScale()
}
return int(float64(u.width) * u.scale * u.glfwScale), int(float64(u.height) * u.scale * u.glfwScale)
2016-02-26 17:35:14 +01:00
}
func (u *userInterface) getScale() float64 {
if !u.fullscreen {
return u.scale
}
if u.fullscreenScale == 0 {
if u.glfwScale == 0 {
u.glfwScale = glfwScale()
}
m := glfw.GetPrimaryMonitor()
v := m.GetVideoMode()
sw := float64(v.Width) / u.glfwScale / float64(u.width)
sh := float64(v.Height) / u.glfwScale / float64(u.height)
s := sw
if s > sh {
s = sh
}
u.fullscreenScale = s
}
return u.fullscreenScale
}
2016-06-18 19:59:17 +02:00
func (u *userInterface) actualScreenScale() float64 {
if u.deviceScale == 0 {
u.deviceScale = deviceScale()
}
return u.getScale() * u.deviceScale
2015-01-01 17:20:20 +01:00
}
2017-03-03 03:15:07 +01:00
func (u *userInterface) pollEvents() {
2014-12-06 14:56:57 +01:00
glfw.PollEvents()
2017-06-04 17:06:40 +02:00
if u.glfwScale == 0 {
u.glfwScale = glfwScale()
}
currentInput.update(u.window, u.getScale()*u.glfwScale)
2014-12-05 18:26:02 +01:00
}
2016-09-01 17:53:05 +02:00
func (u *userInterface) update(g GraphicsContext) error {
2016-05-17 18:30:27 +02:00
shouldClose := false
2016-08-03 16:44:54 +02:00
_ = u.runOnMainThread(func() error {
2016-05-17 18:30:27 +02:00
shouldClose = u.window.ShouldClose()
2016-07-23 14:01:30 +02:00
return nil
2016-05-17 18:30:27 +02:00
})
if shouldClose {
2016-09-01 17:53:05 +02:00
return &RegularTermination{}
2016-05-17 18:30:27 +02:00
}
2016-09-01 17:53:05 +02:00
actualScale := 0.0
2017-06-30 04:07:19 +02:00
sizeChanged := false
2016-08-03 16:44:54 +02:00
_ = u.runOnMainThread(func() error {
if !u.sizeChanged {
2016-07-23 14:01:30 +02:00
return nil
}
u.sizeChanged = false
2016-09-01 17:53:05 +02:00
actualScale = u.actualScreenScale()
2017-06-30 04:07:19 +02:00
sizeChanged = true
2016-07-23 14:01:30 +02:00
return nil
})
2017-06-30 04:07:19 +02:00
if sizeChanged {
g.SetSize(u.width, u.height, actualScale)
}
2017-03-03 03:15:07 +01:00
_ = u.runOnMainThread(func() error {
u.pollEvents()
2016-05-06 05:23:48 +02:00
for u.window.GetAttrib(glfw.Focused) == 0 {
// Wait for an arbitrary period to avoid busy loop.
time.Sleep(time.Second / 60)
2017-03-03 03:15:07 +01:00
u.pollEvents()
2016-05-06 05:23:48 +02:00
if u.window.ShouldClose() {
2016-07-23 14:01:30 +02:00
return nil
2016-05-06 05:23:48 +02:00
}
}
2016-07-23 14:01:30 +02:00
return nil
2017-03-03 03:15:07 +01:00
})
2016-09-01 17:53:05 +02:00
if err := g.Update(); err != nil {
return err
}
return nil
}
2016-09-01 19:31:03 +02:00
func (u *userInterface) loop(g GraphicsContext) error {
2016-09-01 18:07:41 +02:00
defer func() {
_ = u.runOnMainThread(func() error {
glfw.Terminate()
return nil
})
}()
for {
2016-09-01 17:53:05 +02:00
if err := u.update(g); err != nil {
return err
}
// The bound framebuffer must be the default one (0) before swapping buffers.
if err := opengl.GetContext().BindScreenFramebuffer(); err != nil {
return err
}
_ = u.runOnMainThread(func() error {
u.swapBuffers()
return nil
})
2016-07-23 14:01:30 +02:00
}
2016-03-26 09:24:40 +01:00
}
func (u *userInterface) swapBuffers() {
u.window.SwapBuffers()
2014-12-14 10:57:29 +01:00
}
2015-02-09 02:25:00 +01:00
func (u *userInterface) setScreenSize(width, height int, scale float64, fullscreen bool) bool {
if u.width == width && u.height == height && u.scale == scale && u.fullscreen == fullscreen {
return false
2015-02-09 02:25:00 +01:00
}
origScale := u.scale
u.scale = scale
// 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.
// 252 is an arbitrary number and I guess this is small enough.
2016-11-25 18:35:55 +01:00
// TODO: The same check should be in ui_js.go
const minWindowWidth = 252
2016-06-18 19:59:17 +02:00
if int(float64(width)*u.actualScreenScale()) < minWindowWidth {
u.scale = origScale
return false
}
if u.width != width || u.height != height {
u.width = width
u.height = height
u.fullscreenScale = 0
}
2015-02-09 02:25:00 +01:00
// To make sure the current existing framebuffers are rendered,
// swap buffers here before SetSize is called.
u.swapBuffers()
u.fullscreen = fullscreen
2015-02-09 02:25:00 +01:00
if u.fullscreen {
if u.origPosX < 0 && u.origPosY < 0 {
2017-07-01 06:03:27 +02:00
u.origPosX, u.origPosY = u.window.GetPos()
}
m := glfw.GetPrimaryMonitor()
v := m.GetVideoMode()
2017-07-01 06:03:27 +02:00
u.window.SetMonitor(m, 0, 0, v.Width, v.Height, v.RefreshRate)
} else {
if u.origPosX >= 0 && u.origPosY >= 0 {
x := u.origPosX
y := u.origPosY
2017-07-01 06:03:27 +02:00
u.window.SetMonitor(nil, x, y, 16, 16, 0)
u.origPosX = -1
u.origPosY = -1
}
ch := make(chan struct{})
2017-07-01 06:03:27 +02:00
u.window.SetFramebufferSizeCallback(func(_ *glfw.Window, width, height int) {
u.window.SetFramebufferSizeCallback(nil)
close(ch)
})
w, h := u.glfwSize()
2017-07-01 06:03:27 +02:00
u.window.SetSize(w, h)
event:
for {
glfw.PollEvents()
select {
case <-ch:
break event
default:
}
2015-02-09 02:25:00 +01:00
}
// Window title might lost on macOS after coming back from fullscreen.
u.window.SetTitle(u.title)
2015-02-09 02:25:00 +01:00
}
// SwapInterval is affected by the current monitor of the window.
// This needs to be called at least after SetMonitor.
2017-07-01 06:03:27 +02:00
// Without SwapInterval after SetMonitor, vsynch doesn't work (#375).
glfw.SwapInterval(1)
// TODO: Rename this variable?
u.sizeChanged = true
return true
2015-02-09 02:25:00 +01:00
}