ebiten/internal/ui/ui_glfw.go

170 lines
3.3 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 (
"fmt"
2014-12-05 18:26:02 +01:00
glfw "github.com/go-gl/glfw3"
2014-12-14 10:57:29 +01:00
"runtime"
"time"
2014-12-05 18:26:02 +01:00
)
var currentUI *userInterface
2015-01-01 17:20:20 +01:00
2015-01-27 14:02:23 +01:00
func Init() {
runtime.LockOSThread()
2014-12-05 18:26:02 +01:00
2014-12-17 09:10:38 +01:00
glfw.SetErrorCallback(func(err glfw.ErrorCode, desc string) {
panic(fmt.Sprintf("%v: %v\n", err, desc))
})
2014-12-05 18:26:02 +01:00
if !glfw.Init() {
panic("glfw.Init() fails")
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)
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
}
u := &userInterface{
2014-12-17 09:10:38 +01:00
window: window,
funcs: make(chan func()),
2014-12-07 20:22:50 +01:00
}
2015-01-01 17:20:20 +01:00
go func() {
runtime.LockOSThread()
u.window.MakeContextCurrent()
glfw.SwapInterval(1)
2015-01-01 17:20:20 +01:00
for f := range u.funcs {
f()
}
}()
2015-01-10 17:23:43 +01:00
currentUI = u
}
2015-01-27 14:02:23 +01:00
func ExecOnUIThread(f func()) {
ch := make(chan struct{})
currentUI.funcs <- func() {
defer close(ch)
f()
}
<-ch
}
func Start(width, height, scale int, title string) (actualScale int, err error) {
return currentUI.start(width, height, scale, title)
}
func Terminate() {
currentUI.terminate()
}
func DoEvents() error {
return currentUI.doEvents()
}
func IsClosed() bool {
return currentUI.isClosed()
}
func SwapBuffers() {
currentUI.swapBuffers()
}
type userInterface struct {
2015-01-27 14:02:23 +01:00
window *glfw.Window
scale int
funcs chan func()
}
func (u *userInterface) start(width, height, scale int, title string) (actualScale int, err error) {
monitor, err := glfw.GetPrimaryMonitor()
if err != nil {
2015-01-01 19:28:43 +01:00
return 0, err
}
videoMode, err := monitor.GetVideoMode()
if err != nil {
2015-01-01 19:28:43 +01:00
return 0, err
}
x := (videoMode.Width - width*scale) / 2
y := (videoMode.Height - height*scale) / 3
ch := make(chan struct{})
window := u.window
window.SetFramebufferSizeCallback(func(w *glfw.Window, width, height int) {
window.SetFramebufferSizeCallback(nil)
close(ch)
})
window.SetSize(width*scale, height*scale)
window.SetTitle(title)
window.SetPosition(x, y)
window.Show()
for {
done := false
glfw.PollEvents()
select {
case <-ch:
done = true
default:
}
if done {
break
}
}
u.scale = scale
2014-12-14 10:57:29 +01:00
// For retina displays, recalculate the scale with the framebuffer size.
windowWidth, _ := window.GetFramebufferSize()
2015-01-01 19:28:43 +01:00
actualScale = windowWidth / width
2015-01-01 17:20:20 +01:00
2015-01-01 19:28:43 +01:00
return actualScale, nil
2015-01-01 17:20:20 +01:00
}
func (u *userInterface) pollEvents() error {
2014-12-06 14:56:57 +01:00
glfw.PollEvents()
2015-01-27 14:02:23 +01:00
return updateInput(u.window, u.scale)
2014-12-05 18:26:02 +01:00
}
func (u *userInterface) doEvents() error {
2015-01-11 17:54:18 +01:00
if err := u.pollEvents(); err != nil {
return err
}
for u.window.GetAttribute(glfw.Focused) == 0 {
time.Sleep(time.Second / 60)
2015-01-11 17:54:18 +01:00
if err := u.pollEvents(); err != nil {
return err
}
}
2015-01-11 17:54:18 +01:00
return nil
}
func (u *userInterface) terminate() {
2014-12-05 18:26:02 +01:00
glfw.Terminate()
}
2014-12-10 02:42:47 +01:00
func (u *userInterface) isClosed() bool {
2014-12-14 10:57:29 +01:00
return u.window.ShouldClose()
2014-12-10 02:42:47 +01:00
}
func (u *userInterface) swapBuffers() {
2015-01-01 17:20:20 +01:00
u.window.SwapBuffers()
2014-12-14 10:57:29 +01:00
}