ebiten/internal/ui/ui_glfw.go

168 lines
3.2 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-01 17:20:20 +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-30 19:04:52 +01:00
"github.com/hajimehoshi/ebiten/internal/opengl"
2014-12-14 10:57:29 +01:00
"runtime"
"time"
2014-12-05 18:26:02 +01:00
)
2015-01-01 19:25:31 +01:00
var current *ui
2015-01-01 17:20:20 +01:00
2015-01-01 19:25:31 +01:00
func Use(f func(*opengl.Context)) {
ch := make(chan struct{})
current.funcs <- func() {
defer close(ch)
f(current.glContext)
}
<-ch
}
2015-01-11 17:54:18 +01:00
func DoEvents() error {
return current.doEvents()
2015-01-01 19:25:31 +01:00
}
func Terminate() {
current.terminate()
}
func IsClosed() bool {
return current.isClosed()
}
func SwapBuffers() {
current.swapBuffers()
2015-01-01 17:20:20 +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
}
2015-01-01 19:25:31 +01:00
u := &ui{
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()
2014-12-31 20:30:10 +01:00
u.glContext = opengl.NewContext()
glfw.SwapInterval(1)
2015-01-01 17:20:20 +01:00
for f := range u.funcs {
f()
}
}()
2015-01-01 18:44:00 +01:00
current = u
}
2015-01-01 19:25:31 +01:00
type ui struct {
2015-01-01 19:28:43 +01:00
window *glfw.Window
scale int
glContext *opengl.Context
funcs chan func()
}
2015-01-01 19:28:43 +01:00
func 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{})
2015-01-01 18:44:00 +01:00
ui := current
2014-12-31 20:30:10 +01:00
window := ui.window
window.SetFramebufferSizeCallback(func(w *glfw.Window, width, height int) {
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
}
}
ui.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
}
2015-01-11 17:54:18 +01:00
func (u *ui) pollEvents() error {
2014-12-06 14:56:57 +01:00
glfw.PollEvents()
2015-01-11 17:54:18 +01:00
return currentInput.update(u.window, u.scale)
2014-12-05 18:26:02 +01:00
}
2015-01-11 17:54:18 +01:00
func (u *ui) doEvents() error {
if err := u.pollEvents(); err != nil {
return err
}
for current.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
}
2015-01-01 19:25:31 +01:00
func (u *ui) terminate() {
2014-12-05 18:26:02 +01:00
glfw.Terminate()
}
2014-12-10 02:42:47 +01:00
2015-01-01 19:25:31 +01:00
func (u *ui) isClosed() bool {
2014-12-14 10:57:29 +01:00
return u.window.ShouldClose()
2014-12-10 02:42:47 +01:00
}
2015-01-01 19:25:31 +01:00
func (u *ui) swapBuffers() {
2015-01-01 17:20:20 +01:00
u.window.SwapBuffers()
2014-12-14 10:57:29 +01:00
}