146 строки
3.6 KiB
Go
146 строки
3.6 KiB
Go
// Copyright 2014 The Go Authors. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style
|
|
// license that can be found in the LICENSE file.
|
|
|
|
// +build darwin
|
|
|
|
package app
|
|
|
|
// Simple on-screen app debugging for OS X. Not an officially supported
|
|
// development target for apps, as screens with mice are very different
|
|
// than screens with touch panels.
|
|
|
|
/*
|
|
#cgo CFLAGS: -x objective-c
|
|
#cgo LDFLAGS: -framework Cocoa -framework OpenGL -framework QuartzCore
|
|
#import <Cocoa/Cocoa.h>
|
|
#import <OpenGL/gl.h>
|
|
#include <pthread.h>
|
|
|
|
void glGenVertexArrays(GLsizei n, GLuint* array);
|
|
void glBindVertexArray(GLuint array);
|
|
|
|
void runApp(void);
|
|
void lockContext(GLintptr);
|
|
void unlockContext(GLintptr);
|
|
double backingScaleFactor();
|
|
uint64 threadID();
|
|
|
|
*/
|
|
import "C"
|
|
import (
|
|
"log"
|
|
"runtime"
|
|
"sync"
|
|
|
|
"golang.org/x/mobile/event"
|
|
"golang.org/x/mobile/geom"
|
|
"golang.org/x/mobile/gl"
|
|
)
|
|
|
|
var initThreadID uint64
|
|
|
|
func init() {
|
|
// Lock the goroutine responsible for initialization to an OS thread.
|
|
// This means the goroutine running main (and calling the run function
|
|
// below) is locked to the OS thread that started the program. This is
|
|
// necessary for the correct delivery of Cocoa events to the process.
|
|
//
|
|
// A discussion on this topic:
|
|
// https://groups.google.com/forum/#!msg/golang-nuts/IiWZ2hUuLDA/SNKYYZBelsYJ
|
|
runtime.LockOSThread()
|
|
initThreadID = uint64(C.threadID())
|
|
}
|
|
|
|
func run(callbacks Callbacks) {
|
|
if tid := uint64(C.threadID()); tid != initThreadID {
|
|
log.Fatalf("app.Run called on thread %d, but app.init ran on %d", tid, initThreadID)
|
|
}
|
|
cb = callbacks
|
|
C.runApp()
|
|
}
|
|
|
|
//export setGeom
|
|
func setGeom(pixelsPerPt float32, width, height int) {
|
|
// Macs default to 72 DPI, so scales are equivalent.
|
|
geom.PixelsPerPt = pixelsPerPt
|
|
geom.Width = geom.Pt(float32(width) / pixelsPerPt)
|
|
geom.Height = geom.Pt(float32(height) / pixelsPerPt)
|
|
}
|
|
|
|
func initGL() {
|
|
// Using attribute arrays in OpenGL 3.3 requires the use of a VBA.
|
|
// But VBAs don't exist in ES 2. So we bind a default one.
|
|
var id C.GLuint
|
|
C.glGenVertexArrays(1, &id)
|
|
C.glBindVertexArray(id)
|
|
if cb.Start != nil {
|
|
cb.Start()
|
|
}
|
|
}
|
|
|
|
var cb Callbacks
|
|
var initGLOnce sync.Once
|
|
|
|
var events struct {
|
|
sync.Mutex
|
|
pending []event.Touch
|
|
}
|
|
|
|
func sendTouch(ty event.TouchType, x, y float32) {
|
|
events.Lock()
|
|
events.pending = append(events.pending, event.Touch{
|
|
Type: ty,
|
|
Loc: geom.Point{
|
|
X: geom.Pt(x / geom.PixelsPerPt),
|
|
Y: geom.Height - geom.Pt(y/geom.PixelsPerPt),
|
|
},
|
|
})
|
|
events.Unlock()
|
|
}
|
|
|
|
//export eventMouseDown
|
|
func eventMouseDown(x, y float32) { sendTouch(event.TouchStart, x, y) }
|
|
|
|
//export eventMouseDragged
|
|
func eventMouseDragged(x, y float32) { sendTouch(event.TouchMove, x, y) }
|
|
|
|
//export eventMouseEnd
|
|
func eventMouseEnd(x, y float32) { sendTouch(event.TouchEnd, x, y) }
|
|
|
|
//export drawgl
|
|
func drawgl(ctx C.GLintptr) {
|
|
// The call to lockContext loads the OpenGL context into
|
|
// thread-local storage for use by the underlying GL calls
|
|
// done in the user's Draw function. We need to stay on
|
|
// the same thread throughout Draw, so we LockOSThread.
|
|
runtime.LockOSThread()
|
|
C.lockContext(ctx)
|
|
|
|
initGLOnce.Do(initGL)
|
|
|
|
events.Lock()
|
|
pending := events.pending
|
|
events.pending = nil
|
|
events.Unlock()
|
|
for _, e := range pending {
|
|
if cb.Touch != nil {
|
|
cb.Touch(e)
|
|
}
|
|
}
|
|
|
|
// TODO: is the library or the app responsible for clearing the buffers?
|
|
gl.ClearColor(0, 0, 0, 1)
|
|
gl.Clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT)
|
|
if cb.Draw != nil {
|
|
cb.Draw()
|
|
}
|
|
|
|
C.unlockContext(ctx)
|
|
|
|
// This may unlock the original main thread, but that's OK,
|
|
// because by the time it does the thread has already entered
|
|
// C.runApp, which won't give the thread up.
|
|
runtime.UnlockOSThread()
|
|
}
|