diff options
author | 2021-08-10 20:28:56 +0200 | |
---|---|---|
committer | 2021-08-10 20:28:56 +0200 | |
commit | 1a6a018fc3b393e6f769d7db3aea397175aba459 (patch) | |
tree | 1fd0418f1044b221537c682e3e7f02a4a2a72af2 /3rdparty/bgfx/examples/common/entry/entry_html5.cpp | |
parent | 702c9b45cc3a0d3eaaf29cd595b7e3511316a348 (diff) |
Update bgfx to latest
Diffstat (limited to '3rdparty/bgfx/examples/common/entry/entry_html5.cpp')
-rw-r--r-- | 3rdparty/bgfx/examples/common/entry/entry_html5.cpp | 432 |
1 files changed, 432 insertions, 0 deletions
diff --git a/3rdparty/bgfx/examples/common/entry/entry_html5.cpp b/3rdparty/bgfx/examples/common/entry/entry_html5.cpp new file mode 100644 index 00000000000..6482942ff51 --- /dev/null +++ b/3rdparty/bgfx/examples/common/entry/entry_html5.cpp @@ -0,0 +1,432 @@ +/* + * Copyright 2011-2021 Branimir Karadzic. All rights reserved. + * License: https://github.com/bkaradzic/bgfx#license-bsd-2-clause + */ + +#include "entry_p.h" + +#if BX_PLATFORM_EMSCRIPTEN + +#include <bgfx/platform.h> + +#include <emscripten.h> +#include <emscripten/html5.h> + +extern "C" void entry_emscripten_yield() +{ +// emscripten_sleep(0); +} + +#define _EMSCRIPTEN_CHECK(_check, _call) \ + BX_MACRO_BLOCK_BEGIN \ + EMSCRIPTEN_RESULT __result__ = _call; \ + _check(EMSCRIPTEN_RESULT_SUCCESS == __result__, #_call " FAILED 0x%08x\n", (uint32_t)__result__); \ + BX_UNUSED(__result__); \ + BX_MACRO_BLOCK_END + +#define EMSCRIPTEN_CHECK(_call) _EMSCRIPTEN_CHECK(BX_ASSERT, _call) + +namespace entry +{ + static WindowHandle s_defaultWindow = { 0 }; + + static uint8_t s_translateKey[256]; + + struct Context + { + Context() + : m_scrollf(0.0f) + , m_mx(0) + , m_my(0) + , m_scroll(0) + { + bx::memSet(s_translateKey, 0, sizeof(s_translateKey)); + s_translateKey[27] = Key::Esc; + s_translateKey[uint8_t('\n')] = + s_translateKey[uint8_t('\r')] = Key::Return; + s_translateKey[uint8_t('\t')] = Key::Tab; + s_translateKey[127] = Key::Backspace; + s_translateKey[uint8_t(' ')] = Key::Space; + s_translateKey[38] = Key::Up; + s_translateKey[40] = Key::Down; + s_translateKey[37] = Key::Left; + s_translateKey[39] = Key::Right; + + s_translateKey[uint8_t('+')] = + s_translateKey[uint8_t('=')] = Key::Plus; + s_translateKey[uint8_t('_')] = + s_translateKey[uint8_t('-')] = Key::Minus; + + s_translateKey[uint8_t(':')] = + s_translateKey[uint8_t(';')] = Key::Semicolon; + s_translateKey[uint8_t('"')] = + s_translateKey[uint8_t('\'')] = Key::Quote; + + s_translateKey[uint8_t('{')] = + s_translateKey[uint8_t('[')] = Key::LeftBracket; + s_translateKey[uint8_t('}')] = + s_translateKey[uint8_t(']')] = Key::RightBracket; + + s_translateKey[uint8_t('<')] = + s_translateKey[uint8_t(',')] = Key::Comma; + s_translateKey[uint8_t('>')] = + s_translateKey[uint8_t('.')] = Key::Period; + s_translateKey[uint8_t('?')] = + s_translateKey[uint8_t('/')] = Key::Slash; + s_translateKey[uint8_t('|')] = + s_translateKey[uint8_t('\\')] = Key::Backslash; + + s_translateKey[uint8_t('~')] = + s_translateKey[uint8_t('`')] = Key::Tilde; + + s_translateKey[uint8_t('0')] = Key::Key0; + s_translateKey[uint8_t('1')] = Key::Key1; + s_translateKey[uint8_t('2')] = Key::Key2; + s_translateKey[uint8_t('3')] = Key::Key3; + s_translateKey[uint8_t('4')] = Key::Key4; + s_translateKey[uint8_t('5')] = Key::Key5; + s_translateKey[uint8_t('6')] = Key::Key6; + s_translateKey[uint8_t('7')] = Key::Key7; + s_translateKey[uint8_t('8')] = Key::Key8; + s_translateKey[uint8_t('9')] = Key::Key9; + + for (char ch = 'a'; ch <= 'z'; ++ch) + { + s_translateKey[uint8_t(ch)] = + s_translateKey[uint8_t(ch - ' ')] = Key::KeyA + (ch - 'a'); + } + } + + int32_t run(int _argc, const char* const* _argv) + { + static const char* canvas = "#canvas"; + + EMSCRIPTEN_CHECK(emscripten_set_mousedown_callback(canvas, this, true, mouseCb) ); + + EMSCRIPTEN_CHECK(emscripten_set_mousedown_callback(canvas, this, true, mouseCb) ); + EMSCRIPTEN_CHECK(emscripten_set_mouseup_callback(canvas, this, true, mouseCb) ); + EMSCRIPTEN_CHECK(emscripten_set_mousemove_callback(canvas, this, true, mouseCb) ); + + EMSCRIPTEN_CHECK(emscripten_set_wheel_callback(canvas, this, true, wheelCb) ); + + EMSCRIPTEN_CHECK(emscripten_set_keypress_callback(EMSCRIPTEN_EVENT_TARGET_DOCUMENT, this, true, keyCb) ); + EMSCRIPTEN_CHECK(emscripten_set_keydown_callback(EMSCRIPTEN_EVENT_TARGET_DOCUMENT, this, true, keyCb) ); + EMSCRIPTEN_CHECK(emscripten_set_keyup_callback(EMSCRIPTEN_EVENT_TARGET_DOCUMENT, this, true, keyCb) ); + + EMSCRIPTEN_CHECK(emscripten_set_resize_callback(EMSCRIPTEN_EVENT_TARGET_DOCUMENT, this, true, resizeCb) ); + + EmscriptenFullscreenStrategy fullscreenStrategy = {}; + fullscreenStrategy.scaleMode = EMSCRIPTEN_FULLSCREEN_SCALE_DEFAULT; + fullscreenStrategy.canvasResolutionScaleMode = EMSCRIPTEN_FULLSCREEN_CANVAS_SCALE_NONE; + fullscreenStrategy.filteringMode = EMSCRIPTEN_FULLSCREEN_FILTERING_DEFAULT; + fullscreenStrategy.canvasResizedCallback = canvasResizeCb; + fullscreenStrategy.canvasResizedCallbackUserData = this; + + EMSCRIPTEN_CHECK(emscripten_request_fullscreen_strategy(canvas, false, &fullscreenStrategy) ); + + EMSCRIPTEN_CHECK(emscripten_set_focus_callback(EMSCRIPTEN_EVENT_TARGET_DOCUMENT, this, true, focusCb) ); + EMSCRIPTEN_CHECK(emscripten_set_focusin_callback(EMSCRIPTEN_EVENT_TARGET_DOCUMENT, this, true, focusCb) ); + EMSCRIPTEN_CHECK(emscripten_set_focusout_callback(EMSCRIPTEN_EVENT_TARGET_DOCUMENT, this, true, focusCb) ); + + bgfx::PlatformData pd; + bx::memSet(&pd, 0, sizeof(pd) ); + pd.nwh = (void*)canvas; + bgfx::setPlatformData(pd); + + int32_t result = main(_argc, _argv); + return result; + } + + static EM_BOOL mouseCb(int eventType, const EmscriptenMouseEvent* event, void* userData); + static EM_BOOL wheelCb(int eventType, const EmscriptenWheelEvent* event, void* userData); + static EM_BOOL keyCb(int eventType, const EmscriptenKeyboardEvent* event, void* userData); + static EM_BOOL resizeCb(int eventType, const EmscriptenUiEvent* event, void* userData); + static EM_BOOL canvasResizeCb(int eventType, const void* reserved, void* userData); + static EM_BOOL focusCb(int eventType, const EmscriptenFocusEvent* event, void* userData); + + EventQueue m_eventQueue; + + float m_scrollf; + int32_t m_mx; + int32_t m_my; + int32_t m_scroll; + }; + + static Context s_ctx; + + EM_BOOL Context::mouseCb(int32_t _eventType, const EmscriptenMouseEvent* _event, void* _userData) + { + BX_UNUSED(_userData); + + if (_event) + { + switch (_eventType) + { + case EMSCRIPTEN_EVENT_MOUSEMOVE: + s_ctx.m_mx = _event->targetX; + s_ctx.m_my = _event->targetY; + s_ctx.m_eventQueue.postMouseEvent(s_defaultWindow, s_ctx.m_mx, s_ctx.m_my, s_ctx.m_scroll); + return true; + + case EMSCRIPTEN_EVENT_MOUSEDOWN: + case EMSCRIPTEN_EVENT_MOUSEUP: + case EMSCRIPTEN_EVENT_DBLCLICK: + s_ctx.m_mx = _event->targetX; + s_ctx.m_my = _event->targetY; + MouseButton::Enum mb = _event->button == 2 + ? MouseButton::Right : ( (_event->button == 1) + ? MouseButton::Middle : MouseButton::Left) + ; + s_ctx.m_eventQueue.postMouseEvent( + s_defaultWindow + , s_ctx.m_mx + , s_ctx.m_my + , s_ctx.m_scroll + , mb + , (_eventType != EMSCRIPTEN_EVENT_MOUSEUP) + ); + return true; + } + } + + return false; + } + + EM_BOOL Context::wheelCb(int32_t _eventType, const EmscriptenWheelEvent* _event, void* _userData) + { + BX_UNUSED(_userData); + + if (_event) + { + switch (_eventType) + { + case EMSCRIPTEN_EVENT_WHEEL: + { + s_ctx.m_scrollf += _event->deltaY; + + s_ctx.m_scroll = (int32_t)s_ctx.m_scrollf; + s_ctx.m_eventQueue.postMouseEvent(s_defaultWindow, s_ctx.m_mx, s_ctx.m_my, s_ctx.m_scroll); + return true; + } + } + } + + return false; + } + + uint8_t translateModifiers(const EmscriptenKeyboardEvent* _event) + { + uint8_t mask = 0; + + if (_event->shiftKey) + { + mask |= Modifier::LeftShift | Modifier::RightShift; + } + + if (_event->altKey) + { + mask |= Modifier::LeftAlt | Modifier::RightAlt; + } + + if (_event->ctrlKey) + { + mask |= Modifier::LeftCtrl | Modifier::RightCtrl; + } + + if (_event->metaKey) + { + mask |= Modifier::LeftMeta | Modifier::RightMeta; + } + + return mask; + } + + Key::Enum handleKeyEvent(const EmscriptenKeyboardEvent* _event, uint8_t* _specialKeys, uint8_t* _pressedChar) + { + *_pressedChar = uint8_t(_event->keyCode); + + int32_t keyCode = int32_t(_event->keyCode); + *_specialKeys = translateModifiers(_event); + + if (_event->charCode == 0) + { + switch (keyCode) + { + case 112: return Key::F1; + case 113: return Key::F2; + case 114: return Key::F3; + case 115: return Key::F4; + case 116: return Key::F5; + case 117: return Key::F6; + case 118: return Key::F7; + case 119: return Key::F8; + case 120: return Key::F9; + case 121: return Key::F10; + case 122: return Key::F11; + case 123: return Key::F12; + + case 37: return Key::Left; + case 39: return Key::Right; + case 38: return Key::Up; + case 40: return Key::Down; + } + } + + // if this is a unhandled key just return None + if (keyCode < 256) + { + return Key::Enum(s_translateKey[keyCode]); + } + + return Key::None; + } + + EM_BOOL Context::keyCb(int32_t _eventType, const EmscriptenKeyboardEvent* _event, void* _userData) + { + BX_UNUSED(_userData); + + if (_event) + { + uint8_t modifiers = 0; + uint8_t pressedChar[4]; + Key::Enum key = handleKeyEvent(_event, &modifiers, &pressedChar[0]); + + // Returning true means that we take care of the key (instead of the default behavior) + if (key != Key::None) + { + switch (_eventType) + { + case EMSCRIPTEN_EVENT_KEYPRESS: + case EMSCRIPTEN_EVENT_KEYDOWN: + if (key == Key::KeyQ && (modifiers & Modifier::RightMeta) ) + { + s_ctx.m_eventQueue.postExitEvent(); + } + else + { + enum { ShiftMask = Modifier::LeftShift|Modifier::RightShift }; + s_ctx.m_eventQueue.postCharEvent(s_defaultWindow, 1, pressedChar); + s_ctx.m_eventQueue.postKeyEvent(s_defaultWindow, key, modifiers, true); + return true; + } + break; + + case EMSCRIPTEN_EVENT_KEYUP: + s_ctx.m_eventQueue.postKeyEvent(s_defaultWindow, key, modifiers, false); + return true; + } + } + + } + return false; + } + + EM_BOOL Context::resizeCb(int32_t _eventType, const EmscriptenUiEvent* _event, void* _userData) + { + BX_UNUSED(_eventType, _event, _userData); + return false; + } + + EM_BOOL Context::canvasResizeCb(int32_t _eventType, const void* _reserved, void* _userData) + { + BX_UNUSED(_eventType, _reserved, _userData); + return false; + } + + EM_BOOL Context::focusCb(int32_t _eventType, const EmscriptenFocusEvent* _event, void* _userData) + { + BX_UNUSED(_event, _userData); + + if (_event) + { + switch (_eventType) + { + case EMSCRIPTEN_EVENT_BLUR: + s_ctx.m_eventQueue.postSuspendEvent(s_defaultWindow, Suspend::DidSuspend); + return true; + + case EMSCRIPTEN_EVENT_FOCUS: + s_ctx.m_eventQueue.postSuspendEvent(s_defaultWindow, Suspend::DidResume); + return true; + + case EMSCRIPTEN_EVENT_FOCUSIN: + s_ctx.m_eventQueue.postSuspendEvent(s_defaultWindow, Suspend::WillResume); + return true; + + case EMSCRIPTEN_EVENT_FOCUSOUT: + s_ctx.m_eventQueue.postSuspendEvent(s_defaultWindow, Suspend::WillSuspend); + return true; + } + } + + return false; + } + + const Event* poll() + { + entry_emscripten_yield(); + return s_ctx.m_eventQueue.poll(); + } + + const Event* poll(WindowHandle _handle) + { + entry_emscripten_yield(); + return s_ctx.m_eventQueue.poll(_handle); + } + + void release(const Event* _event) + { + s_ctx.m_eventQueue.release(_event); + } + + WindowHandle createWindow(int32_t _x, int32_t _y, uint32_t _width, uint32_t _height, uint32_t _flags, const char* _title) + { + BX_UNUSED(_x, _y, _width, _height, _flags, _title); + WindowHandle handle = { UINT16_MAX }; + + return handle; + } + + void destroyWindow(WindowHandle _handle) + { + BX_UNUSED(_handle); + } + + void setWindowPos(WindowHandle _handle, int32_t _x, int32_t _y) + { + BX_UNUSED(_handle, _x, _y); + } + + void setWindowSize(WindowHandle _handle, uint32_t _width, uint32_t _height) + { + BX_UNUSED(_handle, _width, _height); + } + + void setWindowTitle(WindowHandle _handle, const char* _title) + { + BX_UNUSED(_handle, _title); + } + + void setWindowFlags(WindowHandle _handle, uint32_t _flags, bool _enabled) + { + BX_UNUSED(_handle, _flags, _enabled); + } + + void toggleFullscreen(WindowHandle _handle) + { + BX_UNUSED(_handle); + } + + void setMouseLock(WindowHandle _handle, bool _lock) + { + BX_UNUSED(_handle, _lock); + } +} + +int main(int _argc, const char* const* _argv) +{ + using namespace entry; + return s_ctx.run(_argc, _argv); +} + +#endif // BX_PLATFORM_EMSCRIPTEN |