mirror of
https://github.com/hajimehoshi/ebiten.git
synced 2024-12-26 19:58:54 +01:00
447 lines
14 KiB
Go
447 lines
14 KiB
Go
// 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.
|
|
|
|
package ui
|
|
|
|
import (
|
|
"math"
|
|
"strings"
|
|
"syscall/js"
|
|
"unicode"
|
|
)
|
|
|
|
var (
|
|
stringAlt = js.ValueOf("Alt")
|
|
stringControl = js.ValueOf("Control")
|
|
stringMeta = js.ValueOf("Meta")
|
|
stringShift = js.ValueOf("Shift")
|
|
|
|
stringKeydown = js.ValueOf("keydown")
|
|
stringKeyup = js.ValueOf("keyup")
|
|
stringMousedown = js.ValueOf("mousedown")
|
|
stringMouseup = js.ValueOf("mouseup")
|
|
stringMousemove = js.ValueOf("mousemove")
|
|
stringWheel = js.ValueOf("wheel")
|
|
stringTouchstart = js.ValueOf("touchstart")
|
|
stringTouchend = js.ValueOf("touchend")
|
|
stringTouchmove = js.ValueOf("touchmove")
|
|
)
|
|
|
|
type touchInClient struct {
|
|
id TouchID
|
|
x float64
|
|
y float64
|
|
}
|
|
|
|
func jsCodeToID(code js.Value) Key {
|
|
// js.Value cannot be used as a map key.
|
|
// As the number of keys is around 100, just a dumb loop should work.
|
|
for uiKey, jsCode := range uiKeyToJSCode {
|
|
if jsCode.Equal(code) {
|
|
return uiKey
|
|
}
|
|
}
|
|
return -1
|
|
}
|
|
|
|
var codeToMouseButton = map[int]MouseButton{
|
|
0: MouseButton0, // Left
|
|
1: MouseButton1, // Middle
|
|
2: MouseButton2, // Right
|
|
3: MouseButton3,
|
|
4: MouseButton4,
|
|
}
|
|
|
|
func eventToKeys(e js.Value) (key0, key1 Key, fromKeyProperty bool) {
|
|
id := jsCodeToID(e.Get("code"))
|
|
|
|
// On mobile browsers, treat enter key as if this is from a `key` property.
|
|
if IsVirtualKeyboard() && id == KeyEnter {
|
|
return KeyEnter, -1, true
|
|
}
|
|
if id >= 0 {
|
|
return id, -1, false
|
|
}
|
|
|
|
// With a virtual keyboard on mobile devices, e.code is empty. Use a 'key' property instead (#2898).
|
|
key := e.Get("key")
|
|
|
|
// The key property doesn't distinghlish between left and right modifier keys.
|
|
// Let's assume both keys are pressed.
|
|
switch {
|
|
case key.Equal(stringAlt):
|
|
return KeyAltLeft, KeyAltRight, true
|
|
case key.Equal(stringControl):
|
|
return KeyControlLeft, KeyControlRight, true
|
|
case key.Equal(stringMeta):
|
|
return KeyMetaLeft, KeyMetaRight, true
|
|
case key.Equal(stringShift):
|
|
return KeyShiftLeft, KeyShiftRight, true
|
|
}
|
|
|
|
for uiKey, jsKey := range uiKeyToJSKey {
|
|
if key.Equal(jsKey) {
|
|
return uiKey, -1, true
|
|
}
|
|
}
|
|
|
|
return -1, -1, false
|
|
}
|
|
|
|
func (u *UserInterface) keyDown(event js.Value) {
|
|
key0, key1, fromKeyProperty := eventToKeys(event)
|
|
if key0 >= 0 {
|
|
// If the key value comes from a 'key' property, a 'keydown' and 'keyup' event might be fired too quickly.
|
|
// Record the key duration to prevent immediate resetting a key state by a 'keyup' event.
|
|
// Resetting a key state is delayed until the next tick. See updateInputState.
|
|
if fromKeyProperty && !u.inputState.KeyPressed[key0] {
|
|
if u.keyDurationsByKeyProperty == nil {
|
|
u.keyDurationsByKeyProperty = map[Key]int{}
|
|
}
|
|
u.keyDurationsByKeyProperty[key0] = 1
|
|
}
|
|
u.inputState.KeyPressed[key0] = true
|
|
}
|
|
if key1 >= 0 {
|
|
if fromKeyProperty && !u.inputState.KeyPressed[key1] {
|
|
if u.keyDurationsByKeyProperty == nil {
|
|
u.keyDurationsByKeyProperty = map[Key]int{}
|
|
}
|
|
u.keyDurationsByKeyProperty[key1] = 1
|
|
}
|
|
u.inputState.KeyPressed[key1] = true
|
|
}
|
|
}
|
|
|
|
func (u *UserInterface) keyUp(event js.Value) {
|
|
key0, key1, fromKeyProperty := eventToKeys(event)
|
|
if key0 >= 0 {
|
|
if !fromKeyProperty || u.keyDurationsByKeyProperty[key0] == 0 {
|
|
u.inputState.KeyPressed[key0] = false
|
|
}
|
|
}
|
|
if key1 >= 0 {
|
|
if !fromKeyProperty || u.keyDurationsByKeyProperty[key1] == 0 {
|
|
u.inputState.KeyPressed[key1] = false
|
|
}
|
|
}
|
|
}
|
|
|
|
func (u *UserInterface) mouseDown(code int) {
|
|
u.inputState.MouseButtonPressed[codeToMouseButton[code]] = true
|
|
}
|
|
|
|
func (u *UserInterface) mouseUp(code int) {
|
|
u.inputState.MouseButtonPressed[codeToMouseButton[code]] = false
|
|
}
|
|
|
|
func (u *UserInterface) updateInputFromEvent(e js.Value) error {
|
|
// Avoid using js.Value.String() as String creates a Uint8Array via a TextEncoder and causes a heavy
|
|
// overhead (#1437).
|
|
switch t := e.Get("type"); {
|
|
case t.Equal(stringKeydown):
|
|
if str := e.Get("key").String(); isKeyString(str) {
|
|
for _, r := range str {
|
|
u.inputState.appendRune(r)
|
|
}
|
|
}
|
|
u.keyDown(e)
|
|
case t.Equal(stringKeyup):
|
|
u.keyUp(e)
|
|
case t.Equal(stringMousedown):
|
|
u.mouseDown(e.Get("button").Int())
|
|
u.setMouseCursorFromEvent(e)
|
|
case t.Equal(stringMouseup):
|
|
u.mouseUp(e.Get("button").Int())
|
|
u.setMouseCursorFromEvent(e)
|
|
case t.Equal(stringMousemove):
|
|
u.setMouseCursorFromEvent(e)
|
|
case t.Equal(stringWheel):
|
|
// TODO: What if e.deltaMode is not DOM_DELTA_PIXEL?
|
|
u.inputState.WheelX = -e.Get("deltaX").Float()
|
|
u.inputState.WheelY = -e.Get("deltaY").Float()
|
|
case t.Equal(stringTouchstart) || t.Equal(stringTouchend) || t.Equal(stringTouchmove):
|
|
u.updateTouchesFromEvent(e)
|
|
}
|
|
|
|
u.forceUpdateOnMinimumFPSMode()
|
|
return nil
|
|
}
|
|
|
|
func (u *UserInterface) setMouseCursorFromEvent(e js.Value) {
|
|
if u.context == nil {
|
|
return
|
|
}
|
|
|
|
u.origCursorXInClient = e.Get("clientX").Float()
|
|
u.origCursorYInClient = e.Get("clientY").Float()
|
|
|
|
if u.cursorMode == CursorModeCaptured {
|
|
u.cursorXInClient += e.Get("movementX").Float()
|
|
u.cursorYInClient += e.Get("movementY").Float()
|
|
return
|
|
}
|
|
|
|
u.cursorXInClient = u.origCursorXInClient
|
|
u.cursorYInClient = u.origCursorYInClient
|
|
}
|
|
|
|
func (u *UserInterface) recoverCursorPosition() {
|
|
u.cursorXInClient = u.origCursorXInClient
|
|
u.cursorYInClient = u.origCursorYInClient
|
|
}
|
|
|
|
func (u *UserInterface) updateTouchesFromEvent(e js.Value) {
|
|
u.touchesInClient = u.touchesInClient[:0]
|
|
|
|
touches := e.Get("targetTouches")
|
|
for i := 0; i < touches.Length(); i++ {
|
|
t := touches.Call("item", i)
|
|
u.touchesInClient = append(u.touchesInClient, touchInClient{
|
|
id: TouchID(t.Get("identifier").Int()),
|
|
x: t.Get("clientX").Float(),
|
|
y: t.Get("clientY").Float(),
|
|
})
|
|
}
|
|
}
|
|
|
|
func isKeyString(str string) bool {
|
|
// From https://www.w3.org/TR/uievents-key/#keys-unicode,
|
|
//
|
|
// A key string is a string containing a 0 or 1 non-control characters
|
|
// ("base" characters) followed by 0 or more combining characters. The
|
|
// string MUST be in Normalized Form C (NFC) as described in
|
|
// [UnicodeNormalizationForms].
|
|
//
|
|
// A non-control character is any valid Unicode character except those
|
|
// that are part of the "Other, Control" ("Cc") General Category.
|
|
//
|
|
// A combining character is any valid Unicode character in the "Mark,
|
|
// Spacing Combining" ("Mc") General Category or with a non-zero
|
|
// Combining Class.
|
|
for i, r := range str {
|
|
if i == 0 {
|
|
if unicode.Is(unicode.Cc, r) {
|
|
return false
|
|
}
|
|
continue
|
|
}
|
|
if !unicode.Is(unicode.Mc, r) {
|
|
return false
|
|
}
|
|
}
|
|
return true
|
|
}
|
|
|
|
var (
|
|
jsKeyboard = js.Global().Get("navigator").Get("keyboard")
|
|
jsKeyboardGetLayoutMap js.Value
|
|
jsKeyboardGetLayoutMapCh chan js.Value
|
|
jsKeyboardGetLayoutMapCallback js.Func
|
|
)
|
|
|
|
func init() {
|
|
if !jsKeyboard.Truthy() {
|
|
return
|
|
}
|
|
|
|
jsKeyboardGetLayoutMap = jsKeyboard.Get("getLayoutMap").Call("bind", jsKeyboard)
|
|
jsKeyboardGetLayoutMapCh = make(chan js.Value, 1)
|
|
jsKeyboardGetLayoutMapCallback = js.FuncOf(func(this js.Value, args []js.Value) any {
|
|
jsKeyboardGetLayoutMapCh <- args[0]
|
|
return nil
|
|
})
|
|
}
|
|
|
|
func (u *UserInterface) KeyName(key Key) string {
|
|
if !u.isRunning() {
|
|
return ""
|
|
}
|
|
|
|
// keyboardLayoutMap is reset every tick.
|
|
if u.keyboardLayoutMap.IsUndefined() {
|
|
if !jsKeyboard.Truthy() {
|
|
return ""
|
|
}
|
|
|
|
// Invoke getLayoutMap every tick to detect the keyboard change.
|
|
// TODO: Calling this every tick might be inefficient. Is there a way to detect a keyboard change?
|
|
jsKeyboardGetLayoutMap.Invoke().Call("then", jsKeyboardGetLayoutMapCallback)
|
|
u.keyboardLayoutMap = <-jsKeyboardGetLayoutMapCh
|
|
}
|
|
|
|
n := u.keyboardLayoutMap.Call("get", uiKeyToJSCode[key])
|
|
if n.IsUndefined() {
|
|
return ""
|
|
}
|
|
return n.String()
|
|
}
|
|
|
|
func (u *UserInterface) UpdateInputFromEvent(e js.Value) {
|
|
u.updateInputFromEvent(e)
|
|
}
|
|
|
|
func (u *UserInterface) saveCursorPosition() {
|
|
u.savedCursorX = u.inputState.CursorX
|
|
u.savedCursorY = u.inputState.CursorY
|
|
w, h := u.outsideSize()
|
|
u.savedOutsideWidth = w
|
|
u.savedOutsideHeight = h
|
|
}
|
|
|
|
func (u *UserInterface) updateInputState() error {
|
|
// Reset the key state if a key is pressed by a 'key' property and the key's duration is big enough.
|
|
for key, duration := range u.keyDurationsByKeyProperty {
|
|
if duration >= 2 {
|
|
delete(u.keyDurationsByKeyProperty, key)
|
|
u.inputState.KeyPressed[key] = false
|
|
continue
|
|
}
|
|
u.keyDurationsByKeyProperty[key]++
|
|
}
|
|
|
|
s := theMonitor.DeviceScaleFactor()
|
|
|
|
if !math.IsNaN(u.savedCursorX) && !math.IsNaN(u.savedCursorY) {
|
|
// If savedCursorX and savedCursorY are valid values, the cursor is saved just before entering or exiting from fullscreen.
|
|
// Even after entering or exiting from fullscreening, the outside (body) size is not updated for a while.
|
|
// Wait for the outside size updated.
|
|
if w, h := u.outsideSize(); u.savedOutsideWidth != w || u.savedOutsideHeight != h {
|
|
u.inputState.CursorX = u.savedCursorX
|
|
u.inputState.CursorY = u.savedCursorY
|
|
cx, cy := u.context.logicalPositionToClientPosition(u.inputState.CursorX, u.inputState.CursorY, s)
|
|
u.cursorXInClient = cx
|
|
u.cursorYInClient = cy
|
|
u.savedCursorX = math.NaN()
|
|
u.savedCursorY = math.NaN()
|
|
u.savedOutsideWidth = 0
|
|
u.savedOutsideHeight = 0
|
|
u.outsideSizeUnchangedCount = 0
|
|
} else {
|
|
u.outsideSizeUnchangedCount++
|
|
|
|
// If the outside size is not changed for a while, probably the screen size is not actually changed.
|
|
// Reset the state.
|
|
if u.outsideSizeUnchangedCount > 60 {
|
|
u.savedCursorX = math.NaN()
|
|
u.savedCursorY = math.NaN()
|
|
u.savedOutsideWidth = 0
|
|
u.savedOutsideHeight = 0
|
|
u.outsideSizeUnchangedCount = 0
|
|
}
|
|
}
|
|
} else {
|
|
cx, cy := u.context.clientPositionToLogicalPosition(u.cursorXInClient, u.cursorYInClient, s)
|
|
u.inputState.CursorX = cx
|
|
u.inputState.CursorY = cy
|
|
}
|
|
|
|
u.inputState.Touches = u.inputState.Touches[:0]
|
|
for _, t := range u.touchesInClient {
|
|
x, y := u.context.clientPositionToLogicalPosition(t.x, t.y, s)
|
|
u.inputState.Touches = append(u.inputState.Touches, Touch{
|
|
ID: t.id,
|
|
X: int(x),
|
|
Y: int(y),
|
|
})
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// uiKeyToJSKey is a map from Key values to KeyboardEvent's key values.
|
|
// Note that js.Value cannot be a map key.
|
|
//
|
|
// Reference: https://developer.mozilla.org/en-US/docs/Web/API/UI_Events/Keyboard_event_key_values
|
|
var uiKeyToJSKey = map[Key]js.Value{
|
|
KeyCapsLock: js.ValueOf("CapsLock"),
|
|
KeyNumLock: js.ValueOf("NumLock"),
|
|
KeyScrollLock: js.ValueOf("ScrollLock"),
|
|
KeyEnter: js.ValueOf("Enter"),
|
|
KeyTab: js.ValueOf("Tab"),
|
|
KeySpace: js.ValueOf(" "),
|
|
KeyArrowDown: js.ValueOf("ArrowDown"),
|
|
KeyArrowLeft: js.ValueOf("ArrowLeft"),
|
|
KeyArrowRight: js.ValueOf("ArrowRight"),
|
|
KeyArrowUp: js.ValueOf("ArrowUp"),
|
|
KeyEnd: js.ValueOf("End"),
|
|
KeyHome: js.ValueOf("Home"),
|
|
KeyPageDown: js.ValueOf("PageDown"),
|
|
KeyPageUp: js.ValueOf("PageUp"),
|
|
KeyBackspace: js.ValueOf("Backspace"),
|
|
KeyDelete: js.ValueOf("Delete"),
|
|
KeyInsert: js.ValueOf("Insert"),
|
|
KeyContextMenu: js.ValueOf("ContextMenu"),
|
|
KeyEscape: js.ValueOf("Escape"),
|
|
KeyPause: js.ValueOf("Pause"),
|
|
KeyPrintScreen: js.ValueOf("PrintScreen"),
|
|
KeyF1: js.ValueOf("F1"),
|
|
KeyF2: js.ValueOf("F2"),
|
|
KeyF3: js.ValueOf("F3"),
|
|
KeyF4: js.ValueOf("F4"),
|
|
KeyF5: js.ValueOf("F5"),
|
|
KeyF6: js.ValueOf("F6"),
|
|
KeyF7: js.ValueOf("F7"),
|
|
KeyF8: js.ValueOf("F8"),
|
|
KeyF9: js.ValueOf("F9"),
|
|
KeyF10: js.ValueOf("F10"),
|
|
KeyF11: js.ValueOf("F11"),
|
|
KeyF12: js.ValueOf("F12"),
|
|
KeyF13: js.ValueOf("F13"),
|
|
KeyF14: js.ValueOf("F14"),
|
|
KeyF15: js.ValueOf("F15"),
|
|
KeyF16: js.ValueOf("F16"),
|
|
KeyF17: js.ValueOf("F17"),
|
|
KeyF18: js.ValueOf("F18"),
|
|
KeyF19: js.ValueOf("F19"),
|
|
KeyF20: js.ValueOf("F20"),
|
|
KeyNumpadDecimal: js.ValueOf("Decimal"),
|
|
KeyNumpadMultiply: js.ValueOf("Multiply"),
|
|
KeyNumpadAdd: js.ValueOf("Add"),
|
|
KeyNumpadDivide: js.ValueOf("Divide"),
|
|
KeyNumpadSubtract: js.ValueOf("Subtract"),
|
|
KeyNumpad0: js.ValueOf("0"),
|
|
KeyNumpad1: js.ValueOf("1"),
|
|
KeyNumpad2: js.ValueOf("2"),
|
|
KeyNumpad3: js.ValueOf("3"),
|
|
KeyNumpad4: js.ValueOf("4"),
|
|
KeyNumpad5: js.ValueOf("5"),
|
|
KeyNumpad6: js.ValueOf("6"),
|
|
KeyNumpad7: js.ValueOf("7"),
|
|
KeyNumpad8: js.ValueOf("8"),
|
|
KeyNumpad9: js.ValueOf("9"),
|
|
}
|
|
|
|
func (i *InputState) resetForBlur() {
|
|
for j := range i.KeyPressed {
|
|
i.KeyPressed[j] = false
|
|
}
|
|
for j := range i.MouseButtonPressed {
|
|
i.MouseButtonPressed[j] = false
|
|
}
|
|
i.Touches = i.Touches[:0]
|
|
}
|
|
|
|
func IsVirtualKeyboard() bool {
|
|
// Detect a virtual keyboard by the user agent.
|
|
// Note that this is not a correct way to detect a virtual keyboard.
|
|
// In the future, we should use the `navigator.virtualKeyboard` API.
|
|
// https://developer.mozilla.org/en-US/docs/Web/API/Navigator/virtualKeyboard
|
|
ua := js.Global().Get("navigator").Get("userAgent").String()
|
|
if strings.Contains(ua, "Android") || strings.Contains(ua, "iPhone") || strings.Contains(ua, "iPad") || strings.Contains(ua, "iPod") {
|
|
return true
|
|
}
|
|
return false
|
|
}
|