ebiten/internal/ui/ui_glfw.go

249 lines
5.6 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
2015-01-02 07:20:05 +01:00
// +build !js
2015-01-27 14:02:23 +01:00
package ui
2014-12-05 18:26:02 +01:00
import (
"errors"
"fmt"
2014-12-14 10:57:29 +01:00
"runtime"
2016-03-24 17:15:47 +01:00
"sync"
"time"
2015-06-20 18:33:28 +02:00
2016-02-21 09:12:00 +01:00
"github.com/go-gl/glfw/v3.1/glfw"
2016-02-19 03:43:16 +01:00
"github.com/hajimehoshi/ebiten/internal/graphics/opengl"
2014-12-05 18:26:02 +01:00
)
2015-02-15 11:30:29 +01:00
func Now() int64 {
return time.Now().UnixNano()
}
2016-03-24 16:38:30 +01:00
type UserInterface struct {
window *glfw.Window
width int
height int
scale int
deviceScale float64
framebufferScale int
context *opengl.Context
2016-03-24 17:15:47 +01:00
m sync.RWMutex
2016-03-24 16:38:30 +01:00
}
var currentUI *UserInterface
func CurrentUI() *UserInterface {
return currentUI
}
2015-01-01 17:20:20 +01:00
func Init() *opengl.Context {
runtime.LockOSThread()
2014-12-05 18:26:02 +01:00
2015-06-20 11:52:17 +02:00
err := glfw.Init()
if err != nil {
panic(fmt.Sprintf("glfw.Init() fails: %v", 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 {
panic(err)
2014-12-07 20:22:50 +01:00
}
2016-03-24 16:38:30 +01:00
u := &UserInterface{
2014-12-17 09:10:38 +01:00
window: window,
2014-12-07 20:22:50 +01:00
}
ch := make(chan struct{})
2016-02-19 03:43:16 +01:00
go func() {
runtime.LockOSThread()
u.window.MakeContextCurrent()
glfw.SwapInterval(1)
u.context = opengl.NewContext()
close(ch)
u.context.Loop()
2016-02-19 03:43:16 +01:00
}()
currentUI = u
<-ch
u.context.Init()
return u.context
}
2016-03-24 16:38:30 +01:00
func (u *UserInterface) SetScreenSize(width, height int) bool {
2016-03-26 09:24:40 +01:00
u.m.Lock()
defer u.m.Unlock()
2016-03-26 07:16:16 +01:00
return u.setScreenSize(width, height, u.scale)
2015-01-27 14:02:23 +01:00
}
2016-03-24 16:38:30 +01:00
func (u *UserInterface) SetScreenScale(scale int) bool {
2016-03-26 09:24:40 +01:00
u.m.Lock()
defer u.m.Unlock()
2016-03-26 07:16:16 +01:00
return u.setScreenSize(u.width, u.height, scale)
2015-01-27 14:02:23 +01:00
}
2016-03-24 16:38:30 +01:00
func (u *UserInterface) ScreenScale() int {
2016-03-26 09:24:40 +01:00
u.m.RLock()
defer u.m.RUnlock()
2016-03-24 16:38:30 +01:00
return u.scale
2015-01-27 14:02:23 +01:00
}
2016-03-24 16:38:30 +01:00
func (u *UserInterface) ActualScreenScale() int {
2016-03-26 09:24:40 +01:00
u.m.RLock()
defer u.m.RUnlock()
2016-03-24 16:38:30 +01:00
return u.actualScreenScale()
}
2016-03-24 16:38:30 +01:00
func (u *UserInterface) Start(width, height, scale int, title string) error {
2016-03-26 09:24:40 +01:00
u.m.Lock()
defer u.m.Unlock()
m := glfw.GetPrimaryMonitor()
v := m.GetVideoMode()
mw, _ := m.GetPhysicalSize()
2016-02-26 18:17:31 +01:00
u.deviceScale = 1
2016-02-26 17:44:01 +01:00
u.framebufferScale = 1
// mw can be 0 on some environment like Linux VM
if 0 < mw {
dpi := float64(v.Width) * 25.4 / float64(mw)
2016-02-26 18:17:31 +01:00
u.deviceScale = dpi / 96
if u.deviceScale < 1 {
u.deviceScale = 1
}
}
if !u.setScreenSize(width, height, scale) {
return errors.New("ui: Fail to set the screen size")
}
2015-02-09 02:25:00 +01:00
u.window.SetTitle(title)
u.window.Show()
2016-02-26 17:35:14 +01:00
x := (v.Width - width*u.windowScale()) / 2
y := (v.Height - height*u.windowScale()) / 3
u.window.SetPos(x, y)
2014-12-14 10:57:29 +01:00
2016-02-26 17:44:01 +01:00
return nil
}
2016-03-24 16:38:30 +01:00
func (u *UserInterface) windowScale() int {
2016-02-26 18:17:31 +01:00
return u.scale * int(u.deviceScale)
2016-02-26 17:35:14 +01:00
}
2016-03-24 16:38:30 +01:00
func (u *UserInterface) actualScreenScale() int {
2016-02-26 17:44:01 +01:00
return u.windowScale() * u.framebufferScale
2015-01-01 17:20:20 +01:00
}
2016-03-24 16:38:30 +01:00
func (u *UserInterface) pollEvents() error {
2014-12-06 14:56:57 +01:00
glfw.PollEvents()
return currentInput.update(u.window, u.windowScale())
2014-12-05 18:26:02 +01:00
}
2016-03-24 16:38:30 +01:00
func (u *UserInterface) DoEvents() error {
2016-03-26 09:24:40 +01:00
u.m.Lock()
defer u.m.Unlock()
2015-01-11 17:54:18 +01:00
if err := u.pollEvents(); err != nil {
return err
}
2015-06-20 11:52:17 +02:00
for u.window.GetAttrib(glfw.Focused) == 0 {
2016-03-12 20:48:13 +01:00
// Wait for an arbitrary period to avoid busy loop.
time.Sleep(time.Second / 60)
2015-01-11 17:54:18 +01:00
if err := u.pollEvents(); err != nil {
return err
}
2016-03-26 09:24:40 +01:00
if u.window.ShouldClose() {
return nil
}
}
2015-01-11 17:54:18 +01:00
return nil
}
2016-03-24 16:38:30 +01:00
func (u *UserInterface) Terminate() {
2016-03-26 09:24:40 +01:00
u.m.Lock()
defer u.m.Unlock()
2014-12-05 18:26:02 +01:00
glfw.Terminate()
}
2014-12-10 02:42:47 +01:00
2016-03-24 16:38:30 +01:00
func (u *UserInterface) IsClosed() bool {
2016-03-26 09:24:40 +01:00
u.m.RLock()
defer u.m.RUnlock()
2014-12-14 10:57:29 +01:00
return u.window.ShouldClose()
2014-12-10 02:42:47 +01:00
}
2016-03-24 16:38:30 +01:00
func (u *UserInterface) SwapBuffers() {
2016-03-26 09:24:40 +01:00
u.m.Lock()
defer u.m.Unlock()
u.swapBuffers()
}
func (u *UserInterface) swapBuffers() {
// The bound framebuffer must be the default one (0) before swapping buffers.
u.context.BindZeroFramebuffer()
// Call glFinish before glfwSwapBuffer to make sure
// all OpenGL tasks are executed.
u.context.Finish()
u.context.RunOnContextThread(func() {
u.window.SwapBuffers()
})
2014-12-14 10:57:29 +01:00
}
2015-02-09 02:25:00 +01:00
2016-03-24 16:38:30 +01:00
func (u *UserInterface) setScreenSize(width, height, scale int) bool {
2015-02-09 02:25:00 +01:00
if u.width == width && u.height == height && u.scale == scale {
return false
}
// u.scale should be set first since this affects windowScale().
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.
const minWindowWidth = 252
if width*u.actualScreenScale() < minWindowWidth {
u.scale = origScale
return false
}
2016-02-26 17:35:14 +01:00
u.width = width
u.height = height
2015-02-09 02:25:00 +01:00
// To make sure the current existing framebuffers are rendered,
// swap buffers here before SetSize is called.
2016-03-26 09:24:40 +01:00
u.swapBuffers()
2015-02-09 02:25:00 +01:00
ch := make(chan struct{})
window := u.window
window.SetFramebufferSizeCallback(func(_ *glfw.Window, width, height int) {
2015-02-09 02:25:00 +01:00
window.SetFramebufferSizeCallback(nil)
close(ch)
})
2016-02-26 17:35:14 +01:00
window.SetSize(width*u.windowScale(), height*u.windowScale())
2015-02-09 02:25:00 +01:00
2016-02-21 17:30:33 +01:00
event:
2015-02-09 02:25:00 +01:00
for {
glfw.PollEvents()
select {
case <-ch:
2016-02-21 17:30:33 +01:00
break event
2015-02-09 02:25:00 +01:00
default:
}
}
// This is usually 1, but sometimes more than 1 (e.g. Retina Mac)
fw, _ := window.GetFramebufferSize()
2016-02-26 17:44:01 +01:00
u.framebufferScale = fw / width / u.windowScale()
2015-02-09 02:25:00 +01:00
return true
}