/src/library_glfw.js

http://github.com/kripken/emscripten · JavaScript · 1794 lines · 1384 code · 309 blank · 101 comment · 214 complexity · 86c0dbbd592a612214c8f3f14e9ce62d MD5 · raw file 

    

  1. /**
    2. 

  2.  * @license
    3. 

  3.  * Copyright 2013 The Emscripten Authors
    4. 

  4.  * SPDX-License-Identifier: MIT
    5. 

  5.  */
    6. 

  6. 

  7. /*
    8. 

  8.  * EMSCRIPTEN GLFW 2.x-3.x emulation.
    9. 

  9.  * It tries to emulate the behavior described in
    10. 

  10.  * http://www.glfw.org/docs/latest/
    11. 

  11.  *
    12. 

  12.  * This also implements parts of GLFW 2.x on top of GLFW 3.x.
    13. 

  13.  *
    14. 

  14.  * What it does:
    15. 

  15.  * - Creates a GL context.
    16. 

  16.  * - Manage keyboard and mouse events.
    17. 

  17.  * - GL Extensions support.
    18. 

  18.  *
    19. 

  19.  * What it does not but should probably do:
    20. 

  20.  * - Transmit events when glfwPollEvents, glfwWaitEvents or glfwSwapBuffers is
    21. 

  21.  *    called. Events callbacks are called as soon as event are received.
    22. 

  22.  * - Input modes.
    23. 

  23.  * - Gamma ramps.
    24. 

  24.  * - Video modes.
    25. 

  25.  * - Monitors.
    26. 

  26.  * - Clipboard (not possible from javascript?).
    27. 

  27.  * - Multiple windows.
    28. 

  28.  * - Error codes && messages through callback.
    29. 

  29.  * - Thread emulation. (removed in GLFW3).
    30. 

  30.  * - Image/Texture I/O support (removed in GLFW 3).
    31. 

  31.  *
    32. 

  32.  * Authors:
    33. 

  33.  * - Jari Vetoniemi <mailroxas@gmail.com>
    34. 

  34.  * - Éloi Rivard <eloi.rivard@gmail.com>
    35. 

  35.  * - Thomas Borsos <thomasborsos@gmail.com>
    36. 

  36.  */
    37. 

  37. 

  38. var LibraryGLFW = {
    39. 

  39.   $GLFW_Window__docs: '/** @constructor */',
    40. 

  40.   $GLFW_Window: function(id, width, height, title, monitor, share) {
    41. 

  41.       this.id = id;
    42. 

  42.       this.x = 0;
    43. 

  43.       this.y = 0;
    44. 

  44.       this.fullscreen = false; // Used to determine if app in fullscreen mode
    45. 

  45.       this.storedX = 0; // Used to store X before fullscreen
    46. 

  46.       this.storedY = 0; // Used to store Y before fullscreen
    47. 

  47.       this.width = width;
    48. 

  48.       this.height = height;
    49. 

  49.       this.storedWidth = width; // Used to store width before fullscreen
    50. 

  50.       this.storedHeight = height; // Used to store height before fullscreen
    51. 

  51.       this.title = title;
    52. 

  52.       this.monitor = monitor;
    53. 

  53.       this.share = share;
    54. 

  54.       this.attributes = GLFW.hints;
    55. 

  55.       this.inputModes = {
    56. 

  56.         0x00033001:0x00034001, // GLFW_CURSOR (GLFW_CURSOR_NORMAL)
    57. 

  57.         0x00033002:0, // GLFW_STICKY_KEYS
    58. 

  58.         0x00033003:0, // GLFW_STICKY_MOUSE_BUTTONS
    59. 

  59.       };
    60. 

  60.       this.buttons = 0;
    61. 

  61.       this.keys = new Array();
    62. 

  62.       this.domKeys = new Array();
    63. 

  63.       this.shouldClose = 0;
    64. 

  64.       this.title = null;
    65. 

  65.       this.windowPosFunc = null; // GLFWwindowposfun
    66. 

  66.       this.windowSizeFunc = null; // GLFWwindowsizefun
    67. 

  67.       this.windowCloseFunc = null; // GLFWwindowclosefun
    68. 

  68.       this.windowRefreshFunc = null; // GLFWwindowrefreshfun
    69. 

  69.       this.windowFocusFunc = null; // GLFWwindowfocusfun
    70. 

  70.       this.windowIconifyFunc = null; // GLFWwindowiconifyfun
    71. 

  71.       this.framebufferSizeFunc = null; // GLFWframebuffersizefun
    72. 

  72.       this.mouseButtonFunc = null; // GLFWmousebuttonfun
    73. 

  73.       this.cursorPosFunc = null; // GLFWcursorposfun
    74. 

  74.       this.cursorEnterFunc = null; // GLFWcursorenterfun
    75. 

  75.       this.scrollFunc = null; // GLFWscrollfun
    76. 

  76.       this.dropFunc = null; // GLFWdropfun
    77. 

  77.       this.keyFunc = null; // GLFWkeyfun
    78. 

  78.       this.charFunc = null; // GLFWcharfun
    79. 

  79.       this.userptr = null;
    80. 

  80.     },
    81. 

  81. 

  82.   $GLFW__deps: ['emscripten_get_now', '$GL', '$Browser', '$GLFW_Window',
    83. 

  83. #if FILESYSTEM
    84. 

  84.     , '$FS'
    85. 

  85. #endif
    86. 

  86.   ],
    87. 

  87.   $GLFW: {
    88. 

  88.     WindowFromId: function(id) {
    89. 

  89.       if (id <= 0 || !GLFW.windows) return null;
    90. 

  90.       return GLFW.windows[id - 1];
    91. 

  91.     },
    92. 

  92. 

  93.     joystickFunc: null, // GLFWjoystickfun
    94. 

  94.     errorFunc: null, // GLFWerrorfun
    95. 

  95.     monitorFunc: null, // GLFWmonitorfun
    96. 

  96.     active: null, // active window
    97. 

  97.     windows: null,
    98. 

  98.     monitors: null,
    99. 

  99.     monitorString: null,
    100. 

  100.     versionString: null,
    101. 

  101.     initialTime: null,
    102. 

  102.     extensions: null,
    103. 

  103.     hints: null,
    104. 

  104.     defaultHints: {
    105. 

  105.       0x00020001:0, // GLFW_FOCUSED
    106. 

  106.       0x00020002:0, // GLFW_ICONIFIED
    107. 

  107.       0x00020003:1, // GLFW_RESIZABLE
    108. 

  108.       0x00020004:1, // GLFW_VISIBLE
    109. 

  109.       0x00020005:1, // GLFW_DECORATED
    110. 

  110. 

  111.       0x00021001:8, // GLFW_RED_BITS
    112. 

  112.       0x00021002:8, // GLFW_GREEN_BITS
    113. 

  113.       0x00021003:8, // GLFW_BLUE_BITS
    114. 

  114.       0x00021004:8, // GLFW_ALPHA_BITS
    115. 

  115.       0x00021005:24, // GLFW_DEPTH_BITS
    116. 

  116.       0x00021006:8, // GLFW_STENCIL_BITS
    117. 

  117.       0x00021007:0, // GLFW_ACCUM_RED_BITS
    118. 

  118.       0x00021008:0, // GLFW_ACCUM_GREEN_BITS
    119. 

  119.       0x00021009:0, // GLFW_ACCUM_BLUE_BITS
    120. 

  120.       0x0002100A:0, // GLFW_ACCUM_ALPHA_BITS
    121. 

  121.       0x0002100B:0, // GLFW_AUX_BUFFERS
    122. 

  122.       0x0002100C:0, // GLFW_STEREO
    123. 

  123.       0x0002100D:0, // GLFW_SAMPLES
    124. 

  124.       0x0002100E:0, // GLFW_SRGB_CAPABLE
    125. 

  125.       0x0002100F:0, // GLFW_REFRESH_RATE
    126. 

  126. 

  127.       0x00022001:0x00030001, // GLFW_CLIENT_API (GLFW_OPENGL_API)
    128. 

  128.       0x00022002:1, // GLFW_CONTEXT_VERSION_MAJOR
    129. 

  129.       0x00022003:0, // GLFW_CONTEXT_VERSION_MINOR
    130. 

  130.       0x00022004:0, // GLFW_CONTEXT_REVISION
    131. 

  131.       0x00022005:0, // GLFW_CONTEXT_ROBUSTNESS
    132. 

  132.       0x00022006:0, // GLFW_OPENGL_FORWARD_COMPAT
    133. 

  133.       0x00022007:0, // GLFW_OPENGL_DEBUG_CONTEXT
    134. 

  134.       0x00022008:0, // GLFW_OPENGL_PROFILE
    135. 

  135.     },
    136. 

  136. 

  137. /*******************************************************************************
    138. 

  138.  * DOM EVENT CALLBACKS
    139. 

  139.  ******************************************************************************/
    140. 

  140. 

  141.     /* https://developer.mozilla.org/en/Document_Object_Model_%28DOM%29/KeyboardEvent and GLFW/glfw3.h */
    142. 

  142.     DOMToGLFWKeyCode: function(keycode) {
    143. 

  143.       switch (keycode) {
    144. 

  144.         // these keycodes are only defined for GLFW3, assume they are the same for GLFW2
    145. 

  145.         case 0x20:return 32; // DOM_VK_SPACE -> GLFW_KEY_SPACE
    146. 

  146.         case 0xDE:return 39; // DOM_VK_QUOTE -> GLFW_KEY_APOSTROPHE
    147. 

  147.         case 0xBC:return 44; // DOM_VK_COMMA -> GLFW_KEY_COMMA
    148. 

  148.         case 0xAD:return 45; // DOM_VK_HYPHEN_MINUS -> GLFW_KEY_MINUS
    149. 

  149.         case 0xBD:return 45; // DOM_VK_MINUS -> GLFW_KEY_MINUS
    150. 

  150.         case 0xBE:return 46; // DOM_VK_PERIOD -> GLFW_KEY_PERIOD
    151. 

  151.         case 0xBF:return 47; // DOM_VK_SLASH -> GLFW_KEY_SLASH
    152. 

  152.         case 0x30:return 48; // DOM_VK_0 -> GLFW_KEY_0
    153. 

  153.         case 0x31:return 49; // DOM_VK_1 -> GLFW_KEY_1
    154. 

  154.         case 0x32:return 50; // DOM_VK_2 -> GLFW_KEY_2
    155. 

  155.         case 0x33:return 51; // DOM_VK_3 -> GLFW_KEY_3
    156. 

  156.         case 0x34:return 52; // DOM_VK_4 -> GLFW_KEY_4
    157. 

  157.         case 0x35:return 53; // DOM_VK_5 -> GLFW_KEY_5
    158. 

  158.         case 0x36:return 54; // DOM_VK_6 -> GLFW_KEY_6
    159. 

  159.         case 0x37:return 55; // DOM_VK_7 -> GLFW_KEY_7
    160. 

  160.         case 0x38:return 56; // DOM_VK_8 -> GLFW_KEY_8
    161. 

  161.         case 0x39:return 57; // DOM_VK_9 -> GLFW_KEY_9
    162. 

  162.         case 0x3B:return 59; // DOM_VK_SEMICOLON -> GLFW_KEY_SEMICOLON
    163. 

  163.         case 0x3D:return 61; // DOM_VK_EQUALS -> GLFW_KEY_EQUAL
    164. 

  164.         case 0xBB:return 61; // DOM_VK_EQUALS -> GLFW_KEY_EQUAL
    165. 

  165.         case 0x41:return 65; // DOM_VK_A -> GLFW_KEY_A
    166. 

  166.         case 0x42:return 66; // DOM_VK_B -> GLFW_KEY_B
    167. 

  167.         case 0x43:return 67; // DOM_VK_C -> GLFW_KEY_C
    168. 

  168.         case 0x44:return 68; // DOM_VK_D -> GLFW_KEY_D
    169. 

  169.         case 0x45:return 69; // DOM_VK_E -> GLFW_KEY_E
    170. 

  170.         case 0x46:return 70; // DOM_VK_F -> GLFW_KEY_F
    171. 

  171.         case 0x47:return 71; // DOM_VK_G -> GLFW_KEY_G
    172. 

  172.         case 0x48:return 72; // DOM_VK_H -> GLFW_KEY_H
    173. 

  173.         case 0x49:return 73; // DOM_VK_I -> GLFW_KEY_I
    174. 

  174.         case 0x4A:return 74; // DOM_VK_J -> GLFW_KEY_J
    175. 

  175.         case 0x4B:return 75; // DOM_VK_K -> GLFW_KEY_K
    176. 

  176.         case 0x4C:return 76; // DOM_VK_L -> GLFW_KEY_L
    177. 

  177.         case 0x4D:return 77; // DOM_VK_M -> GLFW_KEY_M
    178. 

  178.         case 0x4E:return 78; // DOM_VK_N -> GLFW_KEY_N
    179. 

  179.         case 0x4F:return 79; // DOM_VK_O -> GLFW_KEY_O
    180. 

  180.         case 0x50:return 80; // DOM_VK_P -> GLFW_KEY_P
    181. 

  181.         case 0x51:return 81; // DOM_VK_Q -> GLFW_KEY_Q
    182. 

  182.         case 0x52:return 82; // DOM_VK_R -> GLFW_KEY_R
    183. 

  183.         case 0x53:return 83; // DOM_VK_S -> GLFW_KEY_S
    184. 

  184.         case 0x54:return 84; // DOM_VK_T -> GLFW_KEY_T
    185. 

  185.         case 0x55:return 85; // DOM_VK_U -> GLFW_KEY_U
    186. 

  186.         case 0x56:return 86; // DOM_VK_V -> GLFW_KEY_V
    187. 

  187.         case 0x57:return 87; // DOM_VK_W -> GLFW_KEY_W
    188. 

  188.         case 0x58:return 88; // DOM_VK_X -> GLFW_KEY_X
    189. 

  189.         case 0x59:return 89; // DOM_VK_Y -> GLFW_KEY_Y
    190. 

  190.         case 0x5a:return 90; // DOM_VK_Z -> GLFW_KEY_Z
    191. 

  191.         case 0xDB:return 91; // DOM_VK_OPEN_BRACKET -> GLFW_KEY_LEFT_BRACKET
    192. 

  192.         case 0xDC:return 92; // DOM_VK_BACKSLASH -> GLFW_KEY_BACKSLASH
    193. 

  193.         case 0xDD:return 93; // DOM_VK_CLOSE_BRACKET -> GLFW_KEY_RIGHT_BRACKET
    194. 

  194.         case 0xC0:return 94; // DOM_VK_BACK_QUOTE -> GLFW_KEY_GRAVE_ACCENT
    195. 

  195. 

  196. #if USE_GLFW == 2
    197. 

  197.         //#define GLFW_KEY_SPECIAL      256
    198. 

  198.         case 0x1B:return (256+1); // DOM_VK_ESCAPE -> GLFW_KEY_ESC
    199. 

  199.         case 0x70:return (256+2); // DOM_VK_F1 -> GLFW_KEY_F1
    200. 

  200.         case 0x71:return (256+3); // DOM_VK_F2 -> GLFW_KEY_F2
    201. 

  201.         case 0x72:return (256+4); // DOM_VK_F3 -> GLFW_KEY_F3
    202. 

  202.         case 0x73:return (256+5); // DOM_VK_F4 -> GLFW_KEY_F4
    203. 

  203.         case 0x74:return (256+6); // DOM_VK_F5 -> GLFW_KEY_F5
    204. 

  204.         case 0x75:return (256+7); // DOM_VK_F6 -> GLFW_KEY_F6
    205. 

  205.         case 0x76:return (256+8); // DOM_VK_F7 -> GLFW_KEY_F7
    206. 

  206.         case 0x77:return (256+9); // DOM_VK_F8 -> GLFW_KEY_F8
    207. 

  207.         case 0x78:return (256+10); // DOM_VK_F9 -> GLFW_KEY_F9
    208. 

  208.         case 0x79:return (256+11); // DOM_VK_F10 -> GLFW_KEY_F10
    209. 

  209.         case 0x7A:return (256+12); // DOM_VK_F11 -> GLFW_KEY_F11
    210. 

  210.         case 0x7B:return (256+13); // DOM_VK_F12 -> GLFW_KEY_F12
    211. 

  211.         case 0x7C:return (256+14); // DOM_VK_F13 -> GLFW_KEY_F13
    212. 

  212.         case 0x7D:return (256+15); // DOM_VK_F14 -> GLFW_KEY_F14
    213. 

  213.         case 0x7E:return (256+16); // DOM_VK_F15 -> GLFW_KEY_F15
    214. 

  214.         case 0x7F:return (256+17); // DOM_VK_F16 -> GLFW_KEY_F16
    215. 

  215.         case 0x80:return (256+18); // DOM_VK_F17 -> GLFW_KEY_F17
    216. 

  216.         case 0x81:return (256+19); // DOM_VK_F18 -> GLFW_KEY_F18
    217. 

  217.         case 0x82:return (256+20); // DOM_VK_F19 -> GLFW_KEY_F19
    218. 

  218.         case 0x83:return (256+21); // DOM_VK_F20 -> GLFW_KEY_F20
    219. 

  219.         case 0x84:return (256+22); // DOM_VK_F21 -> GLFW_KEY_F21
    220. 

  220.         case 0x85:return (256+23); // DOM_VK_F22 -> GLFW_KEY_F22
    221. 

  221.         case 0x86:return (256+24); // DOM_VK_F23 -> GLFW_KEY_F23
    222. 

  222.         case 0x87:return (256+25); // DOM_VK_F24 -> GLFW_KEY_F24
    223. 

  223.         case 0x88:return (256+26); // 0x88 (not used?) -> GLFW_KEY_F25
    224. 

  224.         case 0x27:return (256+30); // DOM_VK_RIGHT -> GLFW_KEY_RIGHT
    225. 

  225.         case 0x25:return (256+29); // DOM_VK_LEFT -> GLFW_KEY_LEFT
    226. 

  226.         case 0x28:return (256+28); // DOM_VK_DOWN -> GLFW_KEY_DOWN
    227. 

  227.         case 0x26:return (256+27); // DOM_VK_UP -> GLFW_KEY_UP
    228. 

  228.         case 0x10:return (256+31); // DOM_VK_SHIFT -> GLFW_KEY_LSHIFT
    229. 

  229.         // #define GLFW_KEY_RSHIFT       (GLFW_KEY_SPECIAL+32)
    230. 

  230.         case 0x11:return (256+33); // DOM_VK_CONTROL -> GLFW_KEY_LCTRL
    231. 

  231.         // #define GLFW_KEY_RCTRL        (GLFW_KEY_SPECIAL+34)
    232. 

  232.         case 0x12:return (256+35); // DOM_VK_ALT -> GLFW_KEY_LALT
    233. 

  233.         // #define GLFW_KEY_RALT         (GLFW_KEY_SPECIAL+36)
    234. 

  234.         case 0x09:return (256+37); // DOM_VK_TAB -> GLFW_KEY_TAB
    235. 

  235.         case 0x0D:return (256+38); // DOM_VK_RETURN -> GLFW_KEY_ENTER
    236. 

  236.         case 0x08:return (256+39); // DOM_VK_BACK -> GLFW_KEY_BACKSPACE
    237. 

  237.         case 0x2D:return (256+40); // DOM_VK_INSERT -> GLFW_KEY_INSERT
    238. 

  238.         case 0x2E:return (256+41); // DOM_VK_DELETE -> GLFW_KEY_DEL
    239. 

  239.         case 0x21:return (256+42); // DOM_VK_PAGE_UP -> GLFW_KEY_PAGEUP
    240. 

  240.         case 0x22:return (256+43); // DOM_VK_PAGE_DOWN -> GLFW_KEY_PAGEDOWN
    241. 

  241.         case 0x24:return (256+44); // DOM_VK_HOME -> GLFW_KEY_HOME
    242. 

  242.         case 0x23:return (256+45); // DOM_VK_END -> GLFW_KEY_END
    243. 

  243.         case 0x60:return (256+46); // DOM_VK_NUMPAD0 -> GLFW_KEY_KP_0
    244. 

  244.         case 0x61:return (256+47); // DOM_VK_NUMPAD1 -> GLFW_KEY_KP_1
    245. 

  245.         case 0x62:return (256+48); // DOM_VK_NUMPAD2 -> GLFW_KEY_KP_2
    246. 

  246.         case 0x63:return (256+49); // DOM_VK_NUMPAD3 -> GLFW_KEY_KP_3
    247. 

  247.         case 0x64:return (256+50); // DOM_VK_NUMPAD4 -> GLFW_KEY_KP_4
    248. 

  248.         case 0x65:return (256+51); // DOM_VK_NUMPAD5 -> GLFW_KEY_KP_5
    249. 

  249.         case 0x66:return (256+52); // DOM_VK_NUMPAD6 -> GLFW_KEY_KP_6
    250. 

  250.         case 0x67:return (256+53); // DOM_VK_NUMPAD7 -> GLFW_KEY_KP_7
    251. 

  251.         case 0x68:return (256+54); // DOM_VK_NUMPAD8 -> GLFW_KEY_KP_8
    252. 

  252.         case 0x69:return (256+55); // DOM_VK_NUMPAD9 -> GLFW_KEY_KP_9
    253. 

  253.         case 0x6F:return (256+56); // DOM_VK_DIVIDE -> GLFW_KEY_KP_DIVIDE
    254. 

  254.         case 0x6A:return (256+57); // DOM_VK_MULTIPLY -> GLFW_KEY_KP_MULTIPLY
    255. 

  255.         case 0x6D:return (256+58); // DOM_VK_SUBTRACT -> GLFW_KEY_KP_SUBTRACT
    256. 

  256.         case 0x6B:return (256+59); // DOM_VK_ADD -> GLFW_KEY_KP_ADD
    257. 

  257.         case 0x6E:return (256+60); // DOM_VK_DECIMAL -> GLFW_KEY_KP_DECIMAL
    258. 

  258.         // #define GLFW_KEY_KP_EQUAL     (GLFW_KEY_SPECIAL+61)
    259. 

  259.         // #define GLFW_KEY_KP_ENTER     (GLFW_KEY_SPECIAL+62)
    260. 

  260.         case 0x90:return (256+63); // DOM_VK_NUM_LOCK -> GLFW_KEY_KP_NUM_LOCK
    261. 

  261.         case 0x14:return (256+64); // DOM_VK_CAPS_LOCK -> GLFW_KEY_CAPS_LOCK
    262. 

  262.         case 0x91:return (256+65); // DOM_VK_SCROLL_LOCK -> GLFW_KEY_SCROLL_LOCK
    263. 

  263.         case 0x13:return (256+66); // DOM_VK_PAUSE -> GLFW_KEY_PAUSE
    264. 

  264.         case 0x5B:return (256+67); // DOM_VK_WIN -> GLFW_KEY_LSUPER
    265. 

  265.         // #define GLFW_KEY_RSUPER       (GLFW_KEY_SPECIAL+68)
    266. 

  266.         case 0x5D:return (256+69); // DOM_VK_CONTEXT_MENU -> GLFW_KEY_MENU
    267. 

  267. #endif
    268. 

  268. 

  269. #if USE_GLFW == 3
    270. 

  270.         case 0x1B:return 256; // DOM_VK_ESCAPE -> GLFW_KEY_ESCAPE
    271. 

  271.         case 0x0D:return 257; // DOM_VK_RETURN -> GLFW_KEY_ENTER
    272. 

  272.         case 0x09:return 258; // DOM_VK_TAB -> GLFW_KEY_TAB
    273. 

  273.         case 0x08:return 259; // DOM_VK_BACK -> GLFW_KEY_BACKSPACE
    274. 

  274.         case 0x2D:return 260; // DOM_VK_INSERT -> GLFW_KEY_INSERT
    275. 

  275.         case 0x2E:return 261; // DOM_VK_DELETE -> GLFW_KEY_DELETE
    276. 

  276.         case 0x27:return 262; // DOM_VK_RIGHT -> GLFW_KEY_RIGHT
    277. 

  277.         case 0x25:return 263; // DOM_VK_LEFT -> GLFW_KEY_LEFT
    278. 

  278.         case 0x28:return 264; // DOM_VK_DOWN -> GLFW_KEY_DOWN
    279. 

  279.         case 0x26:return 265; // DOM_VK_UP -> GLFW_KEY_UP
    280. 

  280.         case 0x21:return 266; // DOM_VK_PAGE_UP -> GLFW_KEY_PAGE_UP
    281. 

  281.         case 0x22:return 267; // DOM_VK_PAGE_DOWN -> GLFW_KEY_PAGE_DOWN
    282. 

  282.         case 0x24:return 268; // DOM_VK_HOME -> GLFW_KEY_HOME
    283. 

  283.         case 0x23:return 269; // DOM_VK_END -> GLFW_KEY_END
    284. 

  284.         case 0x14:return 280; // DOM_VK_CAPS_LOCK -> GLFW_KEY_CAPS_LOCK
    285. 

  285.         case 0x91:return 281; // DOM_VK_SCROLL_LOCK -> GLFW_KEY_SCROLL_LOCK
    286. 

  286.         case 0x90:return 282; // DOM_VK_NUM_LOCK -> GLFW_KEY_NUM_LOCK
    287. 

  287.         case 0x2C:return 283; // DOM_VK_SNAPSHOT -> GLFW_KEY_PRINT_SCREEN
    288. 

  288.         case 0x13:return 284; // DOM_VK_PAUSE -> GLFW_KEY_PAUSE
    289. 

  289.         case 0x70:return 290; // DOM_VK_F1 -> GLFW_KEY_F1
    290. 

  290.         case 0x71:return 291; // DOM_VK_F2 -> GLFW_KEY_F2
    291. 

  291.         case 0x72:return 292; // DOM_VK_F3 -> GLFW_KEY_F3
    292. 

  292.         case 0x73:return 293; // DOM_VK_F4 -> GLFW_KEY_F4
    293. 

  293.         case 0x74:return 294; // DOM_VK_F5 -> GLFW_KEY_F5
    294. 

  294.         case 0x75:return 295; // DOM_VK_F6 -> GLFW_KEY_F6
    295. 

  295.         case 0x76:return 296; // DOM_VK_F7 -> GLFW_KEY_F7
    296. 

  296.         case 0x77:return 297; // DOM_VK_F8 -> GLFW_KEY_F8
    297. 

  297.         case 0x78:return 298; // DOM_VK_F9 -> GLFW_KEY_F9
    298. 

  298.         case 0x79:return 299; // DOM_VK_F10 -> GLFW_KEY_F10
    299. 

  299.         case 0x7A:return 300; // DOM_VK_F11 -> GLFW_KEY_F11
    300. 

  300.         case 0x7B:return 301; // DOM_VK_F12 -> GLFW_KEY_F12
    301. 

  301.         case 0x7C:return 302; // DOM_VK_F13 -> GLFW_KEY_F13
    302. 

  302.         case 0x7D:return 303; // DOM_VK_F14 -> GLFW_KEY_F14
    303. 

  303.         case 0x7E:return 304; // DOM_VK_F15 -> GLFW_KEY_F15
    304. 

  304.         case 0x7F:return 305; // DOM_VK_F16 -> GLFW_KEY_F16
    305. 

  305.         case 0x80:return 306; // DOM_VK_F17 -> GLFW_KEY_F17
    306. 

  306.         case 0x81:return 307; // DOM_VK_F18 -> GLFW_KEY_F18
    307. 

  307.         case 0x82:return 308; // DOM_VK_F19 -> GLFW_KEY_F19
    308. 

  308.         case 0x83:return 309; // DOM_VK_F20 -> GLFW_KEY_F20
    309. 

  309.         case 0x84:return 310; // DOM_VK_F21 -> GLFW_KEY_F21
    310. 

  310.         case 0x85:return 311; // DOM_VK_F22 -> GLFW_KEY_F22
    311. 

  311.         case 0x86:return 312; // DOM_VK_F23 -> GLFW_KEY_F23
    312. 

  312.         case 0x87:return 313; // DOM_VK_F24 -> GLFW_KEY_F24
    313. 

  313.         case 0x88:return 314; // 0x88 (not used?) -> GLFW_KEY_F25
    314. 

  314.         case 0x60:return 320; // DOM_VK_NUMPAD0 -> GLFW_KEY_KP_0
    315. 

  315.         case 0x61:return 321; // DOM_VK_NUMPAD1 -> GLFW_KEY_KP_1
    316. 

  316.         case 0x62:return 322; // DOM_VK_NUMPAD2 -> GLFW_KEY_KP_2
    317. 

  317.         case 0x63:return 323; // DOM_VK_NUMPAD3 -> GLFW_KEY_KP_3
    318. 

  318.         case 0x64:return 324; // DOM_VK_NUMPAD4 -> GLFW_KEY_KP_4
    319. 

  319.         case 0x65:return 325; // DOM_VK_NUMPAD5 -> GLFW_KEY_KP_5
    320. 

  320.         case 0x66:return 326; // DOM_VK_NUMPAD6 -> GLFW_KEY_KP_6
    321. 

  321.         case 0x67:return 327; // DOM_VK_NUMPAD7 -> GLFW_KEY_KP_7
    322. 

  322.         case 0x68:return 328; // DOM_VK_NUMPAD8 -> GLFW_KEY_KP_8
    323. 

  323.         case 0x69:return 329; // DOM_VK_NUMPAD9 -> GLFW_KEY_KP_9
    324. 

  324.         case 0x6E:return 330; // DOM_VK_DECIMAL -> GLFW_KEY_KP_DECIMAL
    325. 

  325.         case 0x6F:return 331; // DOM_VK_DIVIDE -> GLFW_KEY_KP_DIVIDE
    326. 

  326.         case 0x6A:return 332; // DOM_VK_MULTIPLY -> GLFW_KEY_KP_MULTIPLY
    327. 

  327.         case 0x6D:return 333; // DOM_VK_SUBTRACT -> GLFW_KEY_KP_SUBTRACT
    328. 

  328.         case 0x6B:return 334; // DOM_VK_ADD -> GLFW_KEY_KP_ADD
    329. 

  329.         // case 0x0D:return 335; // DOM_VK_RETURN -> GLFW_KEY_KP_ENTER (DOM_KEY_LOCATION_RIGHT)
    330. 

  330.         // case 0x61:return 336; // DOM_VK_EQUALS -> GLFW_KEY_KP_EQUAL (DOM_KEY_LOCATION_RIGHT)
    331. 

  331.         case 0x10:return 340; // DOM_VK_SHIFT -> GLFW_KEY_LEFT_SHIFT
    332. 

  332.         case 0x11:return 341; // DOM_VK_CONTROL -> GLFW_KEY_LEFT_CONTROL
    333. 

  333.         case 0x12:return 342; // DOM_VK_ALT -> GLFW_KEY_LEFT_ALT
    334. 

  334.         case 0x5B:return 343; // DOM_VK_WIN -> GLFW_KEY_LEFT_SUPER
    335. 

  335.         // case 0x10:return 344; // DOM_VK_SHIFT -> GLFW_KEY_RIGHT_SHIFT (DOM_KEY_LOCATION_RIGHT)
    336. 

  336.         // case 0x11:return 345; // DOM_VK_CONTROL -> GLFW_KEY_RIGHT_CONTROL (DOM_KEY_LOCATION_RIGHT)
    337. 

  337.         // case 0x12:return 346; // DOM_VK_ALT -> GLFW_KEY_RIGHT_ALT (DOM_KEY_LOCATION_RIGHT)
    338. 

  338.         // case 0x5B:return 347; // DOM_VK_WIN -> GLFW_KEY_RIGHT_SUPER (DOM_KEY_LOCATION_RIGHT)
    339. 

  339.         case 0x5D:return 348; // DOM_VK_CONTEXT_MENU -> GLFW_KEY_MENU
    340. 

  340.         // XXX: GLFW_KEY_WORLD_1, GLFW_KEY_WORLD_2 what are these?
    341. 

  341. #endif
    342. 

  342.         default:return -1; // GLFW_KEY_UNKNOWN
    343. 

  343.       };
    344. 

  344.     },
    345. 

  345. 

  346.     getModBits: function(win) {
    347. 

  347.       var mod = 0;
    348. 

  348.       if (win.keys[340]) mod |= 0x0001; // GLFW_MOD_SHIFT
    349. 

  349.       if (win.keys[341]) mod |= 0x0002; // GLFW_MOD_CONTROL
    350. 

  350.       if (win.keys[342]) mod |= 0x0004; // GLFW_MOD_ALT
    351. 

  351.       if (win.keys[343]) mod |= 0x0008; // GLFW_MOD_SUPER
    352. 

  352.       return mod;
    353. 

  353.     },
    354. 

  354. 

  355.     onKeyPress: function(event) {
    356. 

  356.       if (!GLFW.active || !GLFW.active.charFunc) return;
    357. 

  357.       if (event.ctrlKey || event.metaKey) return;
    358. 

  358. 

  359.       // correct unicode charCode is only available with onKeyPress event
    360. 

  360.       var charCode = event.charCode;
    361. 

  361.       if (charCode == 0 || (charCode >= 0x00 && charCode <= 0x1F)) return;
    362. 

  362. 

  363. #if USE_GLFW == 2
    364. 

  364.       {{{ makeDynCall('vii') }}}(GLFW.active.charFunc, charCode, 1);
    365. 

  365. #endif
    366. 

  366. 

  367. #if USE_GLFW == 3
    368. 

  368.       {{{ makeDynCall('vii') }}}(GLFW.active.charFunc, GLFW.active.id, charCode);
    369. 

  369. #endif
    370. 

  370.     },
    371. 

  371. 

  372.     onKeyChanged: function(keyCode, status) {
    373. 

  373.       if (!GLFW.active) return;
    374. 

  374. 

  375.       var key = GLFW.DOMToGLFWKeyCode(keyCode);
    376. 

  376.       if (key == -1) return;
    377. 

  377. 

  378. #if USE_GLFW == 3
    379. 

  379.       var repeat = status && GLFW.active.keys[key];
    380. 

  380. #endif
    381. 

  381.       GLFW.active.keys[key] = status;
    382. 

  382.       GLFW.active.domKeys[keyCode] = status;
    383. 

  383.       if (!GLFW.active.keyFunc) return;
    384. 

  384. 

  385. #if USE_GLFW == 2
    386. 

  386.       {{{ makeDynCall('vii') }}}(GLFW.active.keyFunc, key, status);
    387. 

  387. #endif
    388. 

  388. 

  389. #if USE_GLFW == 3
    390. 

  390.       if (repeat) status = 2; // GLFW_REPEAT
    391. 

  391.       {{{ makeDynCall('viiiii') }}}(GLFW.active.keyFunc, GLFW.active.id, key, keyCode, status, GLFW.getModBits(GLFW.active));
    392. 

  392. #endif
    393. 

  393.     },
    394. 

  394. 

  395.     onGamepadConnected: function(event) {
    396. 

  396.       GLFW.refreshJoysticks();
    397. 

  397.     },
    398. 

  398. 

  399.     onGamepadDisconnected: function(event) {
    400. 

  400.       GLFW.refreshJoysticks();
    401. 

  401.     },
    402. 

  402. 

  403.     onKeydown: function(event) {
    404. 

  404.       GLFW.onKeyChanged(event.keyCode, 1); // GLFW_PRESS or GLFW_REPEAT
    405. 

  405. 

  406.       // This logic comes directly from the sdl implementation. We cannot
    407. 

  407.       // call preventDefault on all keydown events otherwise onKeyPress will
    408. 

  408.       // not get called
    409. 

  409.       if (event.keyCode === 8 /* backspace */ || event.keyCode === 9 /* tab */) {
    410. 

  410.         event.preventDefault();
    411. 

  411.       }
    412. 

  412.     },
    413. 

  413. 

  414.     onKeyup: function(event) {
    415. 

  415.       GLFW.onKeyChanged(event.keyCode, 0); // GLFW_RELEASE
    416. 

  416.     },
    417. 

  417. 

  418.     onBlur: function(event) {
    419. 

  419.       if (!GLFW.active) return;
    420. 

  420. 

  421.       for (var i = 0; i < GLFW.active.domKeys.length; ++i) {
    422. 

  422.         if (GLFW.active.domKeys[i]) {
    423. 

  423.           GLFW.onKeyChanged(i, 0); // GLFW_RELEASE
    424. 

  424.         }
    425. 

  425.       }
    426. 

  426.     },
    427. 

  427. 

  428.     onMousemove: function(event) {
    429. 

  429.       if (!GLFW.active) return;
    430. 

  430. 

  431.       Browser.calculateMouseEvent(event);
    432. 

  432. 

  433.       if (event.target != Module["canvas"] || !GLFW.active.cursorPosFunc) return;
    434. 

  434. 

  435. #if USE_GLFW == 2
    436. 

  436.       {{{ makeDynCall('vii') }}}(GLFW.active.cursorPosFunc, Browser.mouseX, Browser.mouseY);
    437. 

  437. #endif
    438. 

  438. 

  439. #if USE_GLFW == 3
    440. 

  440.       {{{ makeDynCall('vidd') }}}(GLFW.active.cursorPosFunc, GLFW.active.id, Browser.mouseX, Browser.mouseY);
    441. 

  441. #endif
    442. 

  442.     },
    443. 

  443. 

  444.     DOMToGLFWMouseButton: function(event) {
    445. 

  445.       // DOM and glfw have different button codes.
    446. 

  446.       // See http://www.w3schools.com/jsref/event_button.asp.
    447. 

  447.       var eventButton = event['button'];
    448. 

  448.       if (eventButton > 0) {
    449. 

  449.         if (eventButton == 1) {
    450. 

  450.           eventButton = 2;
    451. 

  451.         } else {
    452. 

  452.           eventButton = 1;
    453. 

  453.         }
    454. 

  454.       }
    455. 

  455.       return eventButton;
    456. 

  456.     },
    457. 

  457. 

  458.     onMouseenter: function(event) {
    459. 

  459.       if (!GLFW.active) return;
    460. 

  460. 

  461.       if (event.target != Module["canvas"] || !GLFW.active.cursorEnterFunc) return;
    462. 

  462. 

  463. #if USE_GLFW == 3
    464. 

  464.       {{{ makeDynCall('vii') }}}(GLFW.active.cursorEnterFunc, GLFW.active.id, 1);
    465. 

  465. #endif
    466. 

  466.     },
    467. 

  467. 

  468.     onMouseleave: function(event) {
    469. 

  469.       if (!GLFW.active) return;
    470. 

  470. 

  471.       if (event.target != Module["canvas"] || !GLFW.active.cursorEnterFunc) return;
    472. 

  472. 

  473. #if USE_GLFW == 3
    474. 

  474.       {{{ makeDynCall('vii') }}}(GLFW.active.cursorEnterFunc, GLFW.active.id, 0);
    475. 

  475. #endif
    476. 

  476.     },
    477. 

  477. 

  478.     onMouseButtonChanged: function(event, status) {
    479. 

  479.       if (!GLFW.active) return;
    480. 

  480. 

  481.       Browser.calculateMouseEvent(event);
    482. 

  482. 

  483.       if (event.target != Module["canvas"]) return;
    484. 

  484. 

  485.       var eventButton = GLFW.DOMToGLFWMouseButton(event);
    486. 

  486. 

  487.       if (status == 1) { // GLFW_PRESS
    488. 

  488.         GLFW.active.buttons |= (1 << eventButton);
    489. 

  489.         try {
    490. 

  490.           event.target.setCapture();
    491. 

  491.         } catch (e) {}
    492. 

  492.       } else {  // GLFW_RELEASE
    493. 

  493.         GLFW.active.buttons &= ~(1 << eventButton);
    494. 

  494.       }
    495. 

  495. 

  496.       if (!GLFW.active.mouseButtonFunc) return;
    497. 

  497. 

  498. #if USE_GLFW == 2
    499. 

  499.       {{{ makeDynCall('vii') }}}(GLFW.active.mouseButtonFunc, eventButton, status);
    500. 

  500. #endif
    501. 

  501. 

  502. #if USE_GLFW == 3
    503. 

  503.       {{{ makeDynCall('viiii') }}}(GLFW.active.mouseButtonFunc, GLFW.active.id, eventButton, status, GLFW.getModBits(GLFW.active));
    504. 

  504. #endif
    505. 

  505.     },
    506. 

  506. 

  507.     onMouseButtonDown: function(event) {
    508. 

  508.       if (!GLFW.active) return;
    509. 

  509.       GLFW.onMouseButtonChanged(event, 1); // GLFW_PRESS
    510. 

  510.     },
    511. 

  511. 

  512.     onMouseButtonUp: function(event) {
    513. 

  513.       if (!GLFW.active) return;
    514. 

  514.       GLFW.onMouseButtonChanged(event, 0); // GLFW_RELEASE
    515. 

  515.     },
    516. 

  516. 

  517.     onMouseWheel: function(event) {
    518. 

  518.       // Note the minus sign that flips browser wheel direction (positive direction scrolls page down) to native wheel direction (positive direction is mouse wheel up)
    519. 

  519.       var delta = -Browser.getMouseWheelDelta(event);
    520. 

  520.       delta = (delta == 0) ? 0 : (delta > 0 ? Math.max(delta, 1) : Math.min(delta, -1)); // Quantize to integer so that minimum scroll is at least +/- 1.
    521. 

  521.       GLFW.wheelPos += delta;
    522. 

  522. 

  523.       if (!GLFW.active || !GLFW.active.scrollFunc || event.target != Module['canvas']) return;
    524. 

  524. 

  525. #if USE_GLFW == 2
    526. 

  526.       {{{ makeDynCall('vi') }}}(GLFW.active.scrollFunc, GLFW.wheelPos);
    527. 

  527. #endif
    528. 

  528. 

  529. #if USE_GLFW == 3
    530. 

  530.       var sx = 0;
    531. 

  531.       var sy = 0;
    532. 

  532.       if (event.type == 'mousewheel') {
    533. 

  533.         sx = event.wheelDeltaX;
    534. 

  534.         sy = event.wheelDeltaY;
    535. 

  535.       } else {
    536. 

  536.         sx = event.deltaX;
    537. 

  537.         sy = event.deltaY;
    538. 

  538.       }
    539. 

  539. 

  540.       {{{ makeDynCall('vidd') }}}(GLFW.active.scrollFunc, GLFW.active.id, sx, sy);
    541. 

  541. #endif
    542. 

  542. 

  543.       event.preventDefault();
    544. 

  544.     },
    545. 

  545. 

  546.     onCanvasResize: function(width, height) {
    547. 

  547.       if (!GLFW.active) return;
    548. 

  548. 

  549.       var resizeNeeded = true;
    550. 

  550. 

  551.       // If the client is requesting fullscreen mode
    552. 

  552.       if (document["fullscreen"] || document["fullScreen"] || document["mozFullScreen"] || document["webkitIsFullScreen"]) {
    553. 

  553.         GLFW.active.storedX = GLFW.active.x;
    554. 

  554.         GLFW.active.storedY = GLFW.active.y;
    555. 

  555.         GLFW.active.storedWidth = GLFW.active.width;
    556. 

  556.         GLFW.active.storedHeight = GLFW.active.height;
    557. 

  557.         GLFW.active.x = GLFW.active.y = 0;
    558. 

  558.         GLFW.active.width = screen.width;
    559. 

  559.         GLFW.active.height = screen.height;
    560. 

  560.         GLFW.active.fullscreen = true;
    561. 

  561. 

  562.       // If the client is reverting from fullscreen mode
    563. 

  563.       } else if (GLFW.active.fullscreen == true) {
    564. 

  564.         GLFW.active.x = GLFW.active.storedX;
    565. 

  565.         GLFW.active.y = GLFW.active.storedY;
    566. 

  566.         GLFW.active.width = GLFW.active.storedWidth;
    567. 

  567.         GLFW.active.height = GLFW.active.storedHeight;
    568. 

  568.         GLFW.active.fullscreen = false;
    569. 

  569. 

  570.       // If the width/height values do not match current active window sizes
    571. 

  571.       } else if (GLFW.active.width != width || GLFW.active.height != height) {
    572. 

  572.           GLFW.active.width = width;
    573. 

  573.           GLFW.active.height = height;
    574. 

  574.       } else {
    575. 

  575.         resizeNeeded = false;
    576. 

  576.       }
    577. 

  577. 

  578.       // If any of the above conditions were true, we need to resize the canvas
    579. 

  579.       if (resizeNeeded) {
    580. 

  580.         // resets the canvas size to counter the aspect preservation of Browser.updateCanvasDimensions
    581. 

  581.         Browser.setCanvasSize(GLFW.active.width, GLFW.active.height, true);
    582. 

  582.         // TODO: Client dimensions (clientWidth/clientHeight) vs pixel dimensions (width/height) of
    583. 

  583.         // the canvas should drive window and framebuffer size respectfully.
    584. 

  584.         GLFW.onWindowSizeChanged();
    585. 

  585.         GLFW.onFramebufferSizeChanged();
    586. 

  586.       }
    587. 

  587.     },
    588. 

  588. 

  589.     onWindowSizeChanged: function() {
    590. 

  590.       if (!GLFW.active) return;
    591. 

  591. 

  592.       if (!GLFW.active.windowSizeFunc) return;
    593. 

  593. 

  594. #if USE_GLFW == 2
    595. 

  595.       {{{ makeDynCall('vii') }}}(GLFW.active.windowSizeFunc, GLFW.active.width, GLFW.active.height);
    596. 

  596. #endif
    597. 

  597. 

  598. #if USE_GLFW == 3
    599. 

  599.       {{{ makeDynCall('viii') }}}(GLFW.active.windowSizeFunc, GLFW.active.id, GLFW.active.width, GLFW.active.height);
    600. 

  600. #endif
    601. 

  601.     },
    602. 

  602. 

  603.     onFramebufferSizeChanged: function() {
    604. 

  604.       if (!GLFW.active) return;
    605. 

  605. 

  606.       if (!GLFW.active.framebufferSizeFunc) return;
    607. 

  607. 

  608. #if USE_GLFW == 3
    609. 

  609.       {{{ makeDynCall('viii') }}}(GLFW.active.framebufferSizeFunc, GLFW.active.id, GLFW.active.width, GLFW.active.height);
    610. 

  610. #endif
    611. 

  611.     },
    612. 

  612. 

  613.     getTime: function() {
    614. 

  614.       return _emscripten_get_now() / 1000;
    615. 

  615.     },
    616. 

  616. 

  617.     /* GLFW2 wrapping */
    618. 

  618. 

  619.     setWindowTitle: function(winid, title) {
    620. 

  620.       var win = GLFW.WindowFromId(winid);
    621. 

  621.       if (!win) return;
    622. 

  622. 

  623.       win.title = UTF8ToString(title);
    624. 

  624.       if (GLFW.active.id == win.id) {
    625. 

  625.         document.title = win.title;
    626. 

  626.       }
    627. 

  627.     },
    628. 

  628. 

  629.     setJoystickCallback: function(cbfun) {
    630. 

  630.       GLFW.joystickFunc = cbfun;
    631. 

  631.       GLFW.refreshJoysticks();
    632. 

  632.     },
    633. 

  633. 

  634.     joys: {}, // glfw joystick data
    635. 

  635.     lastGamepadState: null,
    636. 

  636.     lastGamepadStateFrame: null, // The integer value of Browser.mainLoop.currentFrameNumber of when the last gamepad state was produced.
    637. 

  637. 

  638.     refreshJoysticks: function() {
    639. 

  639.       // Produce a new Gamepad API sample if we are ticking a new game frame, or if not using emscripten_set_main_loop() at all to drive animation.
    640. 

  640.       if (Browser.mainLoop.currentFrameNumber !== GLFW.lastGamepadStateFrame || !Browser.mainLoop.currentFrameNumber) {
    641. 

  641.         GLFW.lastGamepadState = navigator.getGamepads ? navigator.getGamepads() : (navigator.webkitGetGamepads ? navigator.webkitGetGamepads : null);
    642. 

  642.         GLFW.lastGamepadStateFrame = Browser.mainLoop.currentFrameNumber;
    643. 

  643. 

  644.         for (var joy = 0; joy < GLFW.lastGamepadState.length; ++joy) {
    645. 

  645.           var gamepad = GLFW.lastGamepadState[joy];
    646. 

  646. 

  647.           if (gamepad) {
    648. 

  648.             if (!GLFW.joys[joy]) {
    649. 

  649.               console.log('glfw joystick connected:',joy);
    650. 

  650.               GLFW.joys[joy] = {
    651. 

  651.                 id: allocate(intArrayFromString(gamepad.id), 'i8', ALLOC_NORMAL),
    652. 

  652.                 buttonsCount: gamepad.buttons.length,
    653. 

  653.                 axesCount: gamepad.axes.length,
    654. 

  654.                 buttons: allocate(new Array(gamepad.buttons.length), 'i8', ALLOC_NORMAL),
    655. 

  655.                 axes: allocate(new Array(gamepad.axes.length*4), 'float', ALLOC_NORMAL)
    656. 

  656.               };
    657. 

  657. 

  658.               if (GLFW.joystickFunc) {
    659. 

  659.                 {{{ makeDynCall('vii') }}}(GLFW.joystickFunc, joy, 0x00040001); // GLFW_CONNECTED
    660. 

  660.               }
    661. 

  661.             }
    662. 

  662. 

  663.             var data = GLFW.joys[joy];
    664. 

  664. 

  665.             for (var i = 0; i < gamepad.buttons.length;  ++i) {
    666. 

  666.               setValue(data.buttons + i, gamepad.buttons[i].pressed, 'i8');
    667. 

  667.             }
    668. 

  668. 

  669.             for (var i = 0; i < gamepad.axes.length; ++i) {
    670. 

  670.               setValue(data.axes + i*4, gamepad.axes[i], 'float');
    671. 

  671.             }
    672. 

  672.           } else {
    673. 

  673.             if (GLFW.joys[joy]) {
    674. 

  674.               console.log('glfw joystick disconnected',joy);
    675. 

  675. 

  676.               if (GLFW.joystickFunc) {
    677. 

  677.                 {{{ makeDynCall('vii') }}}(GLFW.joystickFunc, joy, 0x00040002); // GLFW_DISCONNECTED
    678. 

  678.               }
    679. 

  679. 

  680.               _free(GLFW.joys[joy].id);
    681. 

  681.               _free(GLFW.joys[joy].buttons);
    682. 

  682.               _free(GLFW.joys[joy].axes);
    683. 

  683. 

  684.               delete GLFW.joys[joy];
    685. 

  685.             }
    686. 

  686.           }
    687. 

  687.         }
    688. 

  688.       }
    689. 

  689.     },
    690. 

  690. 

  691.     setKeyCallback: function(winid, cbfun) {
    692. 

  692.       var win = GLFW.WindowFromId(winid);
    693. 

  693.       if (!win) return null;
    694. 

  694.       var prevcbfun = win.keyFunc;
    695. 

  695.       win.keyFunc = cbfun;
    696. 

  696.       return prevcbfun;
    697. 

  697.     },
    698. 

  698. 

  699.     setCharCallback: function(winid, cbfun) {
    700. 

  700.       var win = GLFW.WindowFromId(winid);
    701. 

  701.       if (!win) return null;
    702. 

  702.       var prevcbfun = win.charFunc;
    703. 

  703.       win.charFunc = cbfun;
    704. 

  704.       return prevcbfun;
    705. 

  705.     },
    706. 

  706. 

  707.     setMouseButtonCallback: function(winid, cbfun) {
    708. 

  708.       var win = GLFW.WindowFromId(winid);
    709. 

  709.       if (!win) return null;
    710. 

  710.       var prevcbfun = win.mouseButtonFunc;
    711. 

  711.       win.mouseButtonFunc = cbfun;
    712. 

  712.       return prevcbfun;
    713. 

  713.     },
    714. 

  714. 

  715.     setCursorPosCallback: function(winid, cbfun) {
    716. 

  716.       var win = GLFW.WindowFromId(winid);
    717. 

  717.       if (!win) return null;
    718. 

  718.       var prevcbfun = win.cursorPosFunc;
    719. 

  719.       win.cursorPosFunc = cbfun;
    720. 

  720.       return prevcbfun;
    721. 

  721.     },
    722. 

  722. 

  723.     setScrollCallback: function(winid, cbfun) {
    724. 

  724.       var win = GLFW.WindowFromId(winid);
    725. 

  725.       if (!win) return null;
    726. 

  726.       var prevcbfun = win.scrollFunc;
    727. 

  727.       win.scrollFunc = cbfun;
    728. 

  728.       return prevcbfun;
    729. 

  729.     },
    730. 

  730. 

  731.     setDropCallback: function(winid, cbfun) {
    732. 

  732.       var win = GLFW.WindowFromId(winid);
    733. 

  733.       if (!win) return null;
    734. 

  734.       var prevcbfun = win.dropFunc;
    735. 

  735.       win.dropFunc = cbfun;
    736. 

  736.       return prevcbfun;
    737. 

  737.     },
    738. 

  738. 

  739.     onDrop: function(event) {
    740. 

  740.       if (!GLFW.active || !GLFW.active.dropFunc) return;
    741. 

  741.       if (!event.dataTransfer || !event.dataTransfer.files || event.dataTransfer.files.length == 0) return;
    742. 

  742. 

  743.       event.preventDefault();
    744. 

  744. 

  745. #if FILESYSTEM
    746. 

  746.       var filenames = allocate(new Array(event.dataTransfer.files.length*4), 'i8*', ALLOC_NORMAL);
    747. 

  747.       var filenamesArray = [];
    748. 

  748.       var count = event.dataTransfer.files.length;
    749. 

  749. 

  750.       // Read and save the files to emscripten's FS
    751. 

  751.       var written = 0;
    752. 

  752.       var drop_dir = '.glfw_dropped_files';
    753. 

  753.       FS.createPath('/', drop_dir);
    754. 

  754. 

  755.       function save(file) {
    756. 

  756.         var path = '/' + drop_dir + '/' + file.name.replace(/\//g, '_');
    757. 

  757.         var reader = new FileReader();
    758. 

  758.         reader.onloadend = function(e) {
    759. 

  759.           if (reader.readyState != 2) { // not DONE
    760. 

  760.             ++written;
    761. 

  761.             console.log('failed to read dropped file: '+file.name+': '+reader.error);
    762. 

  762.             return;
    763. 

  763.           }
    764. 

  764. 

  765.           var data = e.target.result;
    766. 

  766.           FS.writeFile(path, new Uint8Array(data));
    767. 

  767.           if (++written === count) {
    768. 

  768.             {{{ makeDynCall('viii') }}}(GLFW.active.dropFunc, GLFW.active.id, count, filenames);
    769. 

  769. 

  770.             for (var i = 0; i < filenamesArray.length; ++i) {
    771. 

  771.               _free(filenamesArray[i]);
    772. 

  772.             }
    773. 

  773.             _free(filenames);
    774. 

  774.           }
    775. 

  775.         };
    776. 

  776.         reader.readAsArrayBuffer(file);
    777. 

  777. 

  778.         var filename = allocate(intArrayFromString(path), 'i8', ALLOC_NORMAL);
    779. 

  779.         filenamesArray.push(filename);
    780. 

  780.         setValue(filenames + i*4, filename, 'i8*');
    781. 

  781.       }
    782. 

  782. 

  783.       for (var i = 0; i < count; ++i) {
    784. 

  784.         save(event.dataTransfer.files[i]);
    785. 

  785.       }
    786. 

  786. #endif // FILESYSTEM
    787. 

  787. 

  788.       return false;
    789. 

  789.     },
    790. 

  790. 

  791.     onDragover: function(event) {
    792. 

  792.       if (!GLFW.active || !GLFW.active.dropFunc) return;
    793. 

  793. 

  794.       event.preventDefault();
    795. 

  795.       return false;
    796. 

  796.     },
    797. 

  797. 

  798.     setWindowSizeCallback: function(winid, cbfun) {
    799. 

  799.       var win = GLFW.WindowFromId(winid);
    800. 

  800.       if (!win) return null;
    801. 

  801.       var prevcbfun = win.windowSizeFunc;
    802. 

  802.       win.windowSizeFunc = cbfun;
    803. 

  803. 

  804. #if USE_GLFW == 2
    805. 

  805.       // As documented in GLFW2 API (http://www.glfw.org/GLFWReference27.pdf#page=22), when size
    806. 

  806.       // callback function is set, it will be called with the current window size before this
    807. 

  807.       // function returns.
    808. 

  808.       // GLFW3 on the over hand doesn't have this behavior (https://github.com/glfw/glfw/issues/62).
    809. 

  809.       if (!win.windowSizeFunc) return null;
    810. 

  810.       {{{ makeDynCall('vii') }}}(win.windowSizeFunc, win.width, win.height);
    811. 

  811. #endif
    812. 

  812. 

  813.       return prevcbfun;
    814. 

  814.     },
    815. 

  815. 

  816.     setWindowCloseCallback: function(winid, cbfun) {
    817. 

  817.       var win = GLFW.WindowFromId(winid);
    818. 

  818.       if (!win) return null;
    819. 

  819.       var prevcbfun = win.windowCloseFunc;
    820. 

  820.       win.windowCloseFunc = cbfun;
    821. 

  821.       return prevcbfun;
    822. 

  822.     },
    823. 

  823. 

  824.     setWindowRefreshCallback: function(winid, cbfun) {
    825. 

  825.       var win = GLFW.WindowFromId(winid);
    826. 

  826.       if (!win) return null;
    827. 

  827.       var prevcbfun = win.windowRefreshFunc;
    828. 

  828.       win.windowRefreshFunc = cbfun;
    829. 

  829.       return prevcbfun;
    830. 

  830.     },
    831. 

  831. 

  832.     onClickRequestPointerLock: function(e) {
    833. 

  833.       if (!Browser.pointerLock && Module['canvas'].requestPointerLock) {
    834. 

  834.         Module['canvas'].requestPointerLock();
    835. 

  835.         e.preventDefault();
    836. 

  836.       }
    837. 

  837.     },
    838. 

  838. 

  839.     setInputMode: function(winid, mode, value) {
    840. 

  840.       var win = GLFW.WindowFromId(winid);
    841. 

  841.       if (!win) return;
    842. 

  842. 

  843.       switch(mode) {
    844. 

  844.         case 0x00033001: { // GLFW_CURSOR
    845. 

  845.           switch(value) {
    846. 

  846.             case 0x00034001: { // GLFW_CURSOR_NORMAL
    847. 

  847.               win.inputModes[mode] = value;
    848. 

  848.               Module['canvas'].removeEventListener('click', GLFW.onClickRequestPointerLock, true);
    849. 

  849.               Module['canvas'].exitPointerLock();
    850. 

  850.               break;
    851. 

  851.             }
    852. 

  852.             case 0x00034002: { // GLFW_CURSOR_HIDDEN
    853. 

  853.               console.log("glfwSetInputMode called with GLFW_CURSOR_HIDDEN value not implemented.");
    854. 

  854.               break;
    855. 

  855.             }
    856. 

  856.             case 0x00034003: { // GLFW_CURSOR_DISABLED
    857. 

  857.               win.inputModes[mode] = value;
    858. 

  858.               Module['canvas'].addEventListener('click', GLFW.onClickRequestPointerLock, true);
    859. 

  859.               Module['canvas'].requestPointerLock();
    860. 

  860.               break;
    861. 

  861.             }
    862. 

  862.             default: {
    863. 

  863.               console.log("glfwSetInputMode called with unknown value parameter value: " + value + ".");
    864. 

  864.               break;
    865. 

  865.             }
    866. 

  866.           }
    867. 

  867.           break;
    868. 

  868.         }
    869. 

  869.         case 0x00033002: { // GLFW_STICKY_KEYS
    870. 

  870.           console.log("glfwSetInputMode called with GLFW_STICKY_KEYS mode not implemented.");
    871. 

  871.           break;
    872. 

  872.         }
    873. 

  873.         case 0x00033003: { // GLFW_STICKY_MOUSE_BUTTONS
    874. 

  874.           console.log("glfwSetInputMode called with GLFW_STICKY_MOUSE_BUTTONS mode not implemented.");
    875. 

  875.           break;
    876. 

  876.         }
    877. 

  877.         default: {
    878. 

  878.           console.log("glfwSetInputMode called with unknown mode parameter value: " + mode + ".");
    879. 

  879.           break;
    880. 

  880.         }
    881. 

  881.       }
    882. 

  882.     },
    883. 

  883. 

  884.     getKey: function(winid, key) {
    885. 

  885.       var win = GLFW.WindowFromId(winid);
    886. 

  886.       if (!win) return 0;
    887. 

  887.       return win.keys[key];
    888. 

  888.     },
    889. 

  889. 

  890.     getMouseButton: function(winid, button) {
    891. 

  891.       var win = GLFW.WindowFromId(winid);
    892. 

  892.       if (!win) return 0;
    893. 

  893.       return (win.buttons & (1 << button)) > 0;
    894. 

  894.     },
    895. 

  895. 

  896.     getCursorPos: function(winid, x, y) {
    897. 

  897.       setValue(x, Browser.mouseX, 'double');
    898. 

  898.       setValue(y, Browser.mouseY, 'double');
    899. 

  899.     },
    900. 

  900. 

  901.     getMousePos: function(winid, x, y) {
    902. 

  902.       setValue(x, Browser.mouseX, 'i32');
    903. 

  903.       setValue(y, Browser.mouseY, 'i32');
    904. 

  904.     },
    905. 

  905. 

  906.     setCursorPos: function(winid, x, y) {
    907. 

  907.     },
    908. 

  908. 

  909.     getWindowPos: function(winid, x, y) {
    910. 

  910.       var wx = 0;
    911. 

  911.       var wy = 0;
    912. 

  912. 

  913.       var win = GLFW.WindowFromId(winid);
    914. 

  914.       if (win) {
    915. 

  915.         wx = win.x;
    916. 

  916.         wy = win.y;
    917. 

  917.       }
    918. 

  918. 

  919.       setValue(x, wx, 'i32');
    920. 

  920.       setValue(y, wy, 'i32');
    921. 

  921.     },
    922. 

  922. 

  923.     setWindowPos: function(winid, x, y) {
    924. 

  924.       var win = GLFW.WindowFromId(winid);
    925. 

  925.       if (!win) return;
    926. 

  926.       win.x = x;
    927. 

  927.       win.y = y;
    928. 

  928.     },
    929. 

  929. 

  930.     getWindowSize: function(winid, width, height) {
    931. 

  931.       var ww = 0;
    932. 

  932.       var wh = 0;
    933. 

  933. 

  934.       var win = GLFW.WindowFromId(winid);
    935. 

  935.       if (win) {
    936. 

  936.         ww = win.width;
    937. 

  937.         wh = win.height;
    938. 

  938.       }
    939. 

  939. 

  940.       setValue(width, ww, 'i32');
    941. 

  941.       setValue(height, wh, 'i32');
    942. 

  942.     },
    943. 

  943. 

  944.     setWindowSize: function(winid, width, height) {
    945. 

  945.       var win = GLFW.WindowFromId(winid);
    946. 

  946.       if (!win) return;
    947. 

  947. 

  948.       if (GLFW.active.id == win.id) {
    949. 

  949.         if (width == screen.width && height == screen.height) {
    950. 

  950.           Browser.requestFullscreen();
    951. 

  951.         } else {
    952. 

  952.           Browser.exitFullscreen();
    953. 

  953.           Browser.setCanvasSize(width, height);
    954. 

  954.           win.width = width;
    955. 

  955.           win.height = height;
    956. 

  956.         }
    957. 

  957.       }
    958. 

  958. 

  959.       if (!win.windowSizeFunc) return;
    960. 

  960. 

  961. #if USE_GLFW == 2
    962. 

  962.       {{{ makeDynCall('vii') }}}(win.windowSizeFunc, width, height);
    963. 

  963. #endif
    964. 

  964. 

  965. #if USE_GLFW == 3
    966. 

  966.       {{{ makeDynCall('viii') }}}(win.windowSizeFunc, win.id, width, height);
    967. 

  967. #endif
    968. 

  968.     },
    969. 

  969. 

  970.     createWindow: function(width, height, title, monitor, share) {
    971. 

  971.       var i, id;
    972. 

  972.       for (i = 0; i < GLFW.windows.length && GLFW.windows[i] !== null; i++) {
    973. 

  973.         // no-op
    974. 

  974.       }
    975. 

  975.       if (i > 0) throw "glfwCreateWindow only supports one window at time currently";
    976. 

  976. 

  977.       // id for window
    978. 

  978.       id = i + 1;
    979. 

  979. 

  980.       // not valid
    981. 

  981.       if (width <= 0 || height <= 0) return 0;
    982. 

  982. 

  983.       if (monitor) {
    984. 

  984.         Browser.requestFullscreen();
    985. 

  985.       } else {
    986. 

  986.         Browser.setCanvasSize(width, height);
    987. 

  987.       }
    988. 

  988. 

  989.       // Create context when there are no existing alive windows
    990. 

  990.       for (i = 0; i < GLFW.windows.length && GLFW.windows[i] == null; i++) {
    991. 

  991.         // no-op
    992. 

  992.       }
    993. 

  993.       if (i == GLFW.windows.length) {
    994. 

  994.         var contextAttributes = {
    995. 

  995.           antialias: (GLFW.hints[0x0002100D] > 1), // GLFW_SAMPLES
    996. 

  996.           depth: (GLFW.hints[0x00021005] > 0),     // GLFW_DEPTH_BITS
    997. 

  997.           stencil: (GLFW.hints[0x00021006] > 0),   // GLFW_STENCIL_BITS
    998. 

  998.           alpha: (GLFW.hints[0x00021004] > 0)      // GLFW_ALPHA_BITS
    999. 

  999.         }
    1000. 

  1000. #if OFFSCREEN_FRAMEBUFFER
    1001. 

  1001.         // TODO: Make GLFW explicitly aware of whether it is being proxied or not, and set these to true only when proxying is being performed.
    1002. 

  1002.         GL.enableOffscreenFramebufferAttributes(contextAttributes);
    1003. 

  1003. #endif
    1004. 

  1004.         Module.ctx = Browser.createContext(Module['canvas'], true, true, contextAttributes);
    1005. 

  1005.       }
    1006. 

  1006. 

  1007.       // If context creation failed, do not return a valid window
    1008. 

  1008.       if (!Module.ctx) return 0;
    1009. 

  1009. 

  1010.       // Get non alive id
    1011. 

  1011.       var win = new GLFW_Window(id, width, height, title, monitor, share);
    1012. 

  1012. 

  1013.       // Set window to array
    1014. 

  1014.       if (id - 1 == GLFW.windows.length) {
    1015. 

  1015.         GLFW.windows.push(win);
    1016. 

  1016.       } else {
    1017. 

  1017.         GLFW.windows[id - 1] = win;
    1018. 

  1018.       }
    1019. 

  1019. 

  1020.       GLFW.active = win;
    1021. 

  1021.       return win.id;
    1022. 

  1022.     },
    1023. 

  1023. 

  1024.     destroyWindow: function(winid) {
    1025. 

  1025.       var win = GLFW.WindowFromId(winid);
    1026. 

  1026.       if (!win) return;
    1027. 

  1027. 

  1028. #if USE_GLFW == 3
    1029. 

  1029.       if (win.windowCloseFunc)
    1030. 

  1030.         {{{ makeDynCall('vi') }}}(win.windowCloseFunc, win.id);
    1031. 

  1031. #endif
    1032. 

  1032. 

  1033.       GLFW.windows[win.id - 1] = null;
    1034. 

  1034.       if (GLFW.active.id == win.id)
    1035. 

  1035.         GLFW.active = null;
    1036. 

  1036. 

  1037.       // Destroy context when no alive windows
    1038. 

  1038.       for (var i = 0; i < GLFW.windows.length; i++)
    1039. 

  1039.         if (GLFW.windows[i] !== null) return;
    1040. 

  1040. 

  1041.       Module.ctx = Browser.destroyContext(Module['canvas'], true, true);
    1042. 

  1042.     },
    1043. 

  1043. 

  1044.     swapBuffers: function(winid) {
    1045. 

  1045.     },
    1046. 

  1046. 

  1047.     GLFW2ParamToGLFW3Param: function(param) {
    1048. 

  1048.       var table = {
    1049. 

  1049.         0x00030001:0, // GLFW_MOUSE_CURSOR
    1050. 

  1050.         0x00030002:0, // GLFW_STICKY_KEYS
    1051. 

  1051.         0x00030003:0, // GLFW_STICKY_MOUSE_BUTTONS
    1052. 

  1052.         0x00030004:0, // GLFW_SYSTEM_KEYS
    1053. 

  1053.         0x00030005:0, // GLFW_KEY_REPEAT
    1054. 

  1054.         0x00030006:0, // GLFW_AUTO_POLL_EVENTS
    1055. 

  1055.         0x00020001:0, // GLFW_OPENED
    1056. 

  1056.         0x00020002:0, // GLFW_ACTIVE
    1057. 

  1057.         0x00020003:0, // GLFW_ICONIFIED
    1058. 

  1058.         0x00020004:0, // GLFW_ACCELERATED
    1059. 

  1059.         0x00020005:0x00021001, // GLFW_RED_BITS
    1060. 

  1060.         0x00020006:0x00021002, // GLFW_GREEN_BITS
    1061. 

  1061.         0x00020007:0x00021003, // GLFW_BLUE_BITS
    1062. 

  1062.         0x00020008:0x00021004, // GLFW_ALPHA_BITS
    1063. 

  1063.         0x00020009:0x00021005, // GLFW_DEPTH_BITS
    1064. 

  1064.         0x0002000A:0x00021006, // GLFW_STENCIL_BITS
    1065. 

  1065.         0x0002000B:0x0002100F, // GLFW_REFRESH_RATE
    1066. 

  1066.         0x0002000C:0x00021007, // GLFW_ACCUM_RED_BITS
    1067. 

  1067.         0x0002000D:0x00021008, // GLFW_ACCUM_GREEN_BITS
    1068. 

  1068.         0x0002000E:0x00021009, // GLFW_ACCUM_BLUE_BITS
    1069. 

  1069.         0x0002000F:0x0002100A, // GLFW_ACCUM_ALPHA_BITS
    1070. 

  1070.         0x00020010:0x0002100B, // GLFW_AUX_BUFFERS
    1071. 

  1071.         0x00020011:0x0002100C, // GLFW_STEREO
    1072. 

  1072.         0x00020012:0, // GLFW_WINDOW_NO_RESIZE
    1073. 

  1073.         0x00020013:0x0002100D, // GLFW_FSAA_SAMPLES
    1074. 

  1074.         0x00020014:0x00022002, // GLFW_OPENGL_VERSION_MAJOR
    1075. 

  1075.         0x00020015:0x00022003, // GLFW_OPENGL_VERSION_MINOR
    1076. 

  1076.         0x00020016:0x00022006, // GLFW_OPENGL_FORWARD_COMPAT
    1077. 

  1077.         0x00020017:0x00022007, // GLFW_OPENGL_DEBUG_CONTEXT
    1078. 

  1078.         0x00020018:0x00022008, // GLFW_OPENGL_PROFILE
    1079. 

  1079.       };
    1080. 

  1080.       return table[param];
    1081. 

  1081.     }
    1082. 

  1082.   },
    1083. 

  1083. 

  1084. /*******************************************************************************
    1085. 

  1085.  * GLFW FUNCTIONS
    1086. 

  1086.  ******************************************************************************/
    1087. 

  1087. 

  1088.   glfwInit: function() {
    1089. 

  1089.     if (GLFW.windows) return 1; // GL_TRUE
    1090. 

  1090. 

  1091.     GLFW.initialTime = GLFW.getTime();
    1092. 

  1092.     GLFW.hints = GLFW.defaultHints;
    1093. 

  1093.     GLFW.windows = new Array()
    1094. 

  1094.     GLFW.active = null;
    1095. 

  1095. 

  1096.     window.addEventListener("gamepadconnected", GLFW.onGamepadConnected, true);
    1097. 

  1097.     window.addEventListener("gamepaddisconnected", GLFW.onGamepadDisconnected, true);
    1098. 

  1098.     window.addEventListener("keydown", GLFW.onKeydown, true);
    1099. 

  1099.     window.addEventListener("keypress", GLFW.onKeyPress, true);
    1100. 

  1100.     window.addEventListener("keyup", GLFW.onKeyup, true);
    1101. 

  1101.     window.addEventListener("blur", GLFW.onBlur, true);
    1102. 

  1102.     Module["canvas"].addEventListener("touchmove", GLFW.onMousemove, true);
    1103. 

  1103.     Module["canvas"].addEventListener("touchstart", GLFW.onMouseButtonDown, true);
    1104. 

  1104.     Module["canvas"].addEventListener("touchcancel", GLFW.onMouseButtonUp, true);
    1105. 

  1105.     Module["canvas"].addEventListener("touchend", GLFW.onMouseButtonUp, true);
    1106. 

  1106.     Module["canvas"].addEventListener("mousemove", GLFW.onMousemove, true);
    1107. 

  1107.     Module["canvas"].addEventListener("mousedown", GLFW.onMouseButtonDown, true);
    1108. 

  1108.     Module["canvas"].addEventListener("mouseup", GLFW.onMouseButtonUp, true);
    1109. 

  1109.     Module["canvas"].addEventListener('wheel', GLFW.onMouseWheel, true);
    1110. 

  1110.     Module["canvas"].addEventListener('mousewheel', GLFW.onMouseWheel, true);
    1111. 

  1111.     Module["canvas"].addEventListener('mouseenter', GLFW.onMouseenter, true);
    1112. 

  1112.     Module["canvas"].addEventListener('mouseleave', GLFW.onMouseleave, true);
    1113. 

  1113.     Module["canvas"].addEventListener('drop', GLFW.onDrop, true);
    1114. 

  1114.     Module["canvas"].addEventListener('dragover', GLFW.onDragover, true);
    1115. 

  1115. 

  1116.     Browser.resizeListeners.push(function(width, height) {
    1117. 

  1117.        GLFW.onCanvasResize(width, height);
    1118. 

  1118.     });
    1119. 

  1119.     return 1; // GL_TRUE
    1120. 

  1120.   },
    1121. 

  1121. 

  1122.   glfwTerminate: function() {
    1123. 

  1123.     window.removeEventListener("gamepadconnected", GLFW.onGamepadConnected, true);
    1124. 

  1124.     window.removeEventListener("gamepaddisconnected", GLFW.onGamepadDisconnected, true);
    1125. 

  1125.     window.removeEventListener("keydown", GLFW.onKeydown, true);
    1126. 

  1126.     window.removeEventListener("keypress", GLFW.onKeyPress, true);
    1127. 

  1127.     window.removeEventListener("keyup", GLFW.onKeyup, true);
    1128. 

  1128.     window.removeEventListener("blur", GLFW.onBlur, true);
    1129. 

  1129.     Module["canvas"].removeEventListener("touchmove", GLFW.onMousemove, true);
    1130. 

  1130.     Module["canvas"].removeEventListener("touchstart", GLFW.onMouseButtonDown, true);
    1131. 

  1131.     Module["canvas"].removeEventListener("touchcancel", GLFW.onMouseButtonUp, true);
    1132. 

  1132.     Module["canvas"].removeEventListener("touchend", GLFW.onMouseButtonUp, true);
    1133. 

  1133.     Module["canvas"].removeEventListener("mousemove", GLFW.onMousemove, true);
    1134. 

  1134.     Module["canvas"].removeEventListener("mousedown", GLFW.onMouseButtonDown, true);
    1135. 

  1135.     Module["canvas"].removeEventListener("mouseup", GLFW.onMouseButtonUp, true);
    1136. 

  1136.     Module["canvas"].removeEventListener('wheel', GLFW.onMouseWheel, true);
    1137. 

  1137.     Module["canvas"].removeEventListener('mousewheel', GLFW.onMouseWheel, true);
    1138. 

  1138.     Module["canvas"].removeEventListener('mouseenter', GLFW.onMouseenter, true);
    1139. 

  1139.     Module["canvas"].removeEventListener('mouseleave', GLFW.onMouseleave, true);
    1140. 

  1140.     Module["canvas"].removeEventListener('drop', GLFW.onDrop, true);
    1141. 

  1141.     Module["canvas"].removeEventListener('dragover', GLFW.onDragover, true);
    1142. 

  1142. 

  1143. 

  1144.     Module["canvas"].width = Module["canvas"].height = 1;
    1145. 

  1145.     GLFW.windows = null;
    1146. 

  1146.     GLFW.active = null;
    1147. 

  1147.   },
    1148. 

  1148. 

  1149.   glfwGetVersion: function(major, minor, rev) {
    1150. 

  1150. #if USE_GLFW == 2
    1151. 

  1151.     setValue(major, 2, 'i32');
    1152. 

  1152.     setValue(minor, 7, 'i32');
    1153. 

  1153.     setValue(rev, 7, 'i32');
    1154. 

  1154. #endif
    1155. 

  1155. 

  1156. #if USE_GLFW == 3
    1157. 

  1157.     setValue(major, 3, 'i32');
    1158. 

  1158.     setValue(minor, 2, 'i32');
    1159. 

  1159.     setValue(rev, 1, 'i32');
    1160. 

  1160. #endif
    1161. 

  1161.   },
    1162. 

  1162. 

  1163.   glfwPollEvents: function() {},
    1164. 

  1164. 

  1165.   glfwWaitEvents: function() {},
    1166. 

  1166. 

  1167.   glfwGetTime: function() {
    1168. 

  1168.     return GLFW.getTime() - GLFW.initialTime;
    1169. 

  1169.   },
    1170. 

  1170. 

  1171.   glfwSetTime: function(time) {
    1172. 

  1172.     GLFW.initialTime = GLFW.getTime() - time;
    1173. 

  1173.   },
    1174. 

  1174. 

  1175.   glfwExtensionSupported__deps: ['glGetString'],
    1176. 

  1176.   glfwExtensionSupported: function(extension) {
    1177. 

  1177.     if (!GLFW.extensions) {
    1178. 

  1178.       GLFW.extensions = UTF8ToString(_glGetString(0x1F03)).split(' ');
    1179. 

  1179.     }
    1180. 

  1180. 

  1181.     if (GLFW.extensions.indexOf(extension) != -1) return 1;
    1182. 

  1182. 

  1183.     // extensions from GLEmulations do not come unprefixed
    1184. 

  1184.     // so, try with prefix
    1185. 

  1185.     return (GLFW.extensions.indexOf("GL_" + extension) != -1);
    1186. 

  1186.   },
    1187. 

  1187. 

  1188.   glfwGetProcAddress__deps: ['emscripten_GetProcAddress'],
    1189. 

  1189.   glfwGetProcAddress: function(procname) {
    1190. 

  1190.     return _emscripten_GetProcAddress(procname);
    1191. 

  1191.   },
    1192. 

  1192. 

  1193.   glfwSwapInterval__deps: ['emscripten_set_main_loop_timing'],
    1194. 

  1194.   glfwSwapInterval: function(interval) {
    1195. 

  1195.     interval = Math.abs(interval); // GLFW uses negative values to enable GLX_EXT_swap_control_tear, which we don't have, so just treat negative and positive the same.
    1196. 

  1196.     if (interval == 0) _emscripten_set_main_loop_timing(0/*EM_TIMING_SETTIMEOUT*/, 0);
    1197. 

  1197.     else _emscripten_set_main_loop_timing(1/*EM_TIMING_RAF*/, interval);
    1198. 

  1198.   },
    1199. 

  1199. 

  1200. #if USE_GLFW == 3
    1201. 

  1201.   glfwGetVersionString: function() {
    1202. 

  1202.     if (!GLFW.versionString) {
    1203. 

  1203.       GLFW.versionString = allocate(intArrayFromString("3.2.1 JS WebGL Emscripten"), 'i8', ALLOC_NORMAL);
    1204. 

  1204.     }
    1205. 

  1205.     return GLFW.versionString;
    1206. 

  1206.   },
    1207. 

  1207. 

  1208.   glfwSetErrorCallback: function(cbfun) {
    1209. 

  1209.     var prevcbfun = GLFW.errorFunc;
    1210. 

  1210.     GLFW.errorFunc = cbfun;
    1211. 

  1211.     return prevcbfun;
    1212. 

  1212.   },
    1213. 

  1213. 

  1214.   glfwWaitEventsTimeout: function(timeout) {},
    1215. 

  1215. 

  1216.   glfwPostEmptyEvent: function() {},
    1217. 

  1217. 

  1218.   glfwGetMonitors: function(count) {
    1219. 

  1219.     setValue(count, 1, 'i32');
    1220. 

  1220.     if (!GLFW.monitors) {
    1221. 

  1221.       GLFW.monitors = allocate([1, 0, 0, 0], 'i32', ALLOC_NORMAL);
    1222. 

  1222.     }
    1223. 

  1223.     return GLFW.monitors;
    1224. 

  1224.   },
    1225. 

  1225. 

  1226.   glfwGetPrimaryMonitor: function() {
    1227. 

  1227.     return 1;
    1228. 

  1228.   },
    1229. 

  1229. 

  1230.   glfwGetMonitorPos: function(monitor, x, y) {
    1231. 

  1231.     setValue(x, 0, 'i32');
    1232. 

  1232.     setValue(y, 0, 'i32');
    1233. 

  1233.   },
    1234. 

  1234. 

  1235.   glfwGetMonitorPhysicalSize: function(monitor, width, height) {
    1236. 

  1236.     // AFAIK there is no way to do this in javascript
    1237. 

  1237.     // Maybe with platform specific ccalls?
    1238. 

  1238.     //
    1239. 

  1239.     // Lets report 0 now which is wrong as it can get for end user.
    1240. 

  1240.     setValue(width, 0, 'i32');
    1241. 

  1241.     setValue(height, 0, 'i32');
    1242. 

  1242.   },
    1243. 

  1243. 

  1244.   glfwGetMonitorName: function(mon) {
    1245. 

  1245.     if (!GLFW.monitorString) {
    1246. 

  1246.       GLFW.monitorString = allocate(intArrayFromString("HTML5 WebGL Canvas"), 'i8', ALLOC_NORMAL);
    1247. 

  1247.     }
    1248. 

  1248.     return GLFW.monitorString;
    1249. 

  1249.   },
    1250. 

  1250. 

  1251.   glfwSetMonitorCallback: function(cbfun) {
    1252. 

  1252.     var prevcbfun = GLFW.monitorFunc;
    1253. 

  1253.     GLFW.monitorFunc = cbfun;
    1254. 

  1254.     return prevcbfun;
    1255. 

  1255.   },
    1256. 

  1256. 

  1257.   // TODO: implement
    1258. 

  1258.   glfwGetVideoModes: function(monitor, count) {
    1259. 

  1259.     setValue(count, 0, 'i32');
    1260. 

  1260.     return 0;
    1261. 

  1261.   },
    1262. 

  1262. 

  1263.   // TODO: implement
    1264. 

  1264.   glfwGetVideoMode: function(monitor) { return 0; },
    1265. 

  1265. 

  1266.   // TODO: implement
    1267. 

  1267.   glfwSetGamma: function(monitor, gamma) { },
    1268. 

  1268. 

  1269.   glfwGetGammaRamp: function(monitor) {
    1270. 

  1270.     throw "glfwGetGammaRamp not implemented.";
    1271. 

  1271.   },
    1272. 

  1272. 

  1273.   glfwSetGammaRamp: function(monitor, ramp) {
    1274. 

  1274.     throw "glfwSetGammaRamp not implemented.";
    1275. 

  1275.   },
    1276. 

  1276. 

  1277.   glfwDefaultWindowHints: function() {
    1278. 

  1278.     GLFW.hints = GLFW.defaultHints;
    1279. 

  1279.   },
    1280. 

  1280. 

  1281.   glfwWindowHint: function(target, hint) {
    1282. 

  1282.     GLFW.hints[target] = hint;
    1283. 

  1283.   },
    1284. 

  1284. 

  1285.   glfwCreateWindow: function(width, height, title, monitor, share) {
    1286. 

  1286.     return GLFW.createWindow(width, height, title, monitor, share);
    1287. 

  1287.   },
    1288. 

  1288. 

  1289.   glfwDestroyWindow: function(winid) {
    1290. 

  1290.     return GLFW.destroyWindow(winid);
    1291. 

  1291.   },
    1292. 

  1292. 

  1293.   glfwWindowShouldClose: function(winid) {
    1294. 

  1294.     var win = GLFW.WindowFromId(winid);
    1295. 

  1295.     if (!win) return 0;
    1296. 

  1296.     return win.shouldClose;
    1297. 

  1297.   },
    1298. 

  1298. 

  1299.   glfwSetWindowShouldClose: function(winid, value) {
    1300. 

  1300.     var win = GLFW.WindowFromId(winid);
    1301. 

  1301.     if (!win) return;
    1302. 

  1302.     win.shouldClose = value;
    1303. 

  1303.   },
    1304. 

  1304. 

  1305.   glfwSetWindowTitle: function(winid, title) {
    1306. 

  1306.     GLFW.setWindowTitle(winid, title);
    1307. 

  1307.   },
    1308. 

  1308. 

  1309.   glfwGetWindowPos: function(winid, x, y) {
    1310. 

  1310.     GLFW.getWindowPos(winid, x, y);
    1311. 

  1311.   },
    1312. 

  1312. 

  1313.   glfwSetWindowPos: function(winid, x, y) {
    1314. 

  1314.     GLFW.setWindowPos(winid, x, y);
    1315. 

  1315.   },
    1316. 

  1316. 

  1317.   glfwGetWindowSize: function(winid, width, height) {
    1318. 

  1318.     GLFW.getWindowSize(winid, width, height);
    1319. 

  1319.   },
    1320. 

  1320. 

  1321.   glfwSetWindowSize: function(winid, width, height) {
    1322. 

  1322.     GLFW.setWindowSize(winid, width, height);
    1323. 

  1323.   },
    1324. 

  1324. 

  1325.   glfwGetFramebufferSize: function(winid, width, height) {
    1326. 

  1326.     var ww = 0;
    1327. 

  1327.     var wh = 0;
    1328. 

  1328. 

  1329.     var win = GLFW.WindowFromId(winid);
    1330. 

  1330.     if (win) {
    1331. 

  1331.       ww = win.width;
    1332. 

  1332.       wh = win.height;
    1333. 

  1333.     }
    1334. 

  1334. 

  1335.     setValue(width, ww, 'i32');
    1336. 

  1336.     setValue(height, wh, 'i32');
    1337. 

  1337.   },
    1338. 

  1338. 

  1339.   glfwIconifyWindow: function(winid) {
    1340. 

  1340. #if ASSERTIONS
    1341. 

  1341.     warnOnce('glfwIconifyWindow is not implemented');
    1342. 

  1342. #endif
    1343. 

  1343.   },
    1344. 

  1344. 

  1345.   glfwRestoreWindow: function(winid) {
    1346. 

  1346. #if ASSERTIONS
    1347. 

  1347.     warnOnce('glfwRestoreWindow is not implemented');
    1348. 

  1348. #endif
    1349. 

  1349.   },
    1350. 

  1350. 

  1351.   glfwShowWindow: function(winid) {},
    1352. 

  1352. 

  1353.   glfwHideWindow: function(winid) {},
    1354. 

  1354. 

  1355.   glfwGetWindowMonitor: function(winid) {
    1356. 

  1356.     var win = GLFW.WindowFromId(winid);
    1357. 

  1357.     if (!win) return 0;
    1358. 

  1358.     return win.monitor;
    1359. 

  1359.   },
    1360. 

  1360. 

  1361.   glfwGetWindowAttrib: function(winid, attrib) {
    1362. 

  1362.     var win = GLFW.WindowFromId(winid);
    1363. 

  1363.     if (!win) return 0;
    1364. 

  1364.     return win.attributes[attrib];
    1365. 

  1365.   },
    1366. 

  1366. 

  1367.   glfwSetWindowUserPointer: function(winid, ptr) {
    1368. 

  1368.     var win = GLFW.WindowFromId(winid);
    1369. 

  1369.     if (!win) return;
    1370. 

  1370.     win.userptr = ptr;
    1371. 

  1371.   },
    1372. 

  1372. 

  1373.   glfwGetWindowUserPointer: function(winid) {
    1374. 

  1374.     var win = GLFW.WindowFromId(winid);
    1375. 

  1375.     if (!win) return 0;
    1376. 

  1376.     return win.userptr;
    1377. 

  1377.   },
    1378. 

  1378. 

  1379.   glfwSetWindowPosCallback: function(winid, cbfun) {
    1380. 

  1380.     var win = GLFW.WindowFromId(winid);
    1381. 

  1381.     if (!win) return null;
    1382. 

  1382.     var prevcbfun = win.windowPosFunc;
    1383. 

  1383.     win.windowPosFunc = cbfun;
    1384. 

  1384.     return prevcbfun;
    1385. 

  1385.   },
    1386. 

  1386. 

  1387.   glfwSetWindowSizeCallback: function(winid, cbfun) {
    1388. 

  1388.     return GLFW.setWindowSizeCallback(winid, cbfun);
    1389. 

  1389.   },
    1390. 

  1390. 

  1391.   glfwSetWindowCloseCallback: function(winid, cbfun) {
    1392. 

  1392.     return GLFW.setWindowCloseCallback(winid, cbfun);
    1393. 

  1393.   },
    1394. 

  1394. 

  1395.   glfwSetWindowRefreshCallback: function(winid, cbfun) {
    1396. 

  1396.     return GLFW.setWindowRefreshCallback(winid, cbfun);
    1397. 

  1397.   },
    1398. 

  1398. 

  1399.   glfwSetWindowFocusCallback: function(winid, cbfun) {
    1400. 

  1400.     var win = GLFW.WindowFromId(winid);
    1401. 

  1401.     if (!win) return null;
    1402. 

  1402.     var prevcbfun = win.windowFocusFunc;
    1403. 

  1403.     win.windowFocusFunc = cbfun;
    1404. 

  1404.     return prevcbfun;
    1405. 

  1405.   },
    1406. 

  1406. 

  1407.   glfwSetWindowIconifyCallback: function(winid, cbfun) {
    1408. 

  1408.     var win = GLFW.WindowFromId(winid);
    1409. 

  1409.     if (!win) return null;
    1410. 

  1410.     var prevcbfun = win.windowIconifyFunc;
    1411. 

  1411.     win.windowIconifyFunc = cbfun;
    1412. 

  1412.     return prevcbfun;
    1413. 

  1413.   },
    1414. 

  1414. 

  1415.   glfwSetWindowIcon: function(winid, count, images) {},
    1416. 

  1416. 

  1417.   glfwSetWindowSizeLimits: function(winid, minwidth, minheight, maxwidth, maxheight) {},
    1418. 

  1418. 

  1419.   glfwSetWindowAspectRatio: function(winid, numer, denom) {},
    1420. 

  1420. 

  1421.   glfwGetWindowFrameSize: function(winid, left, top, right, bottom) { throw "glfwGetWindowFrameSize not implemented."; },
    1422. 

  1422. 

  1423.   glfwMaximizeWindow: function(winid) {},
    1424. 

  1424. 

  1425.   glfwFocusWindow: function(winid) {},
    1426. 

  1426. 

  1427.   glfwSetWindowMonitor: function(winid, monitor, xpos, ypos, width, height, refreshRate) { throw "glfwSetWindowMonitor not implemented."; },
    1428. 

  1428. 

  1429.   glfwCreateCursor: function(image, xhot, yhot) {},
    1430. 

  1430. 

  1431.   glfwCreateStandardCursor: function(shape) {},
    1432. 

  1432. 

  1433.   glfwDestroyCursor: function(cursor) {},
    1434. 

  1434. 

  1435.   glfwSetCursor: function(winid, cursor) {},
    1436. 

  1436. 

  1437.   glfwSetFramebufferSizeCallback: function(winid, cbfun) {
    1438. 

  1438.     var win = GLFW.WindowFromId(winid);
    1439. 

  1439.     if (!win) return null;
    1440. 

  1440.     var prevcbfun = win.framebufferSizeFunc;
    1441. 

  1441.     win.framebufferSizeFunc = cbfun;
    1442. 

  1442.     return prevcbfun;
    1443. 

  1443.   },
    1444. 

  1444. 

  1445.   glfwGetInputMode: function(winid, mode) {
    1446. 

  1446.     var win = GLFW.WindowFromId(winid);
    1447. 

  1447.     if (!win) return;
    1448. 

  1448. 

  1449.     switch (mode) {
    1450. 

  1450.       case 0x00033001: { // GLFW_CURSOR
    1451. 

  1451.         if (Browser.pointerLock) {
    1452. 

  1452.           win.inputModes[mode] = 0x00034003; // GLFW_CURSOR_DISABLED
    1453. 

  1453.         } else {
    1454. 

  1454.           win.inputModes[mode] = 0x00034001; // GLFW_CURSOR_NORMAL
    1455. 

  1455.         }
    1456. 

  1456.       }
    1457. 

  1457.     }
    1458. 

  1458. 

  1459.     return win.inputModes[mode];
    1460. 

  1460.   },
    1461. 

  1461. 

  1462.   glfwSetInputMode: function(winid, mode, value) {
    1463. 

  1463.     GLFW.setInputMode(winid, mode, value);
    1464. 

  1464.   },
    1465. 

  1465. 

  1466.   glfwGetKey: function(winid, key) {
    1467. 

  1467.     return GLFW.getKey(winid, key);
    1468. 

  1468.   },
    1469. 

  1469. 

  1470.   glfwGetKeyName: function(key, scancode) { throw "glfwGetKeyName not implemented."; },
    1471. 

  1471. 

  1472.   glfwGetMouseButton: function(winid, button) {
    1473. 

  1473.     return GLFW.getMouseButton(winid, button);
    1474. 

  1474.   },
    1475. 

  1475. 

  1476.   glfwGetCursorPos: function(winid, x, y) {
    1477. 

  1477.     GLFW.getCursorPos(winid, x, y);
    1478. 

  1478.   },
    1479. 

  1479. 

  1480.   // I believe it is not possible to move the mouse with javascript
    1481. 

  1481.   glfwSetCursorPos: function(winid, x, y) {
    1482. 

  1482.     GLFW.setCursorPos(winid, x, y);
    1483. 

  1483.   },
    1484. 

  1484. 

  1485.   glfwSetKeyCallback: function(winid, cbfun) {
    1486. 

  1486.     return GLFW.setKeyCallback(winid, cbfun);
    1487. 

  1487.   },
    1488. 

  1488. 

  1489.   glfwSetCharCallback: function(winid, cbfun) {
    1490. 

  1490.     return GLFW.setCharCallback(winid, cbfun);
    1491. 

  1491.   },
    1492. 

  1492. 

  1493.   glfwSetCharModsCallback: function(winid, cbfun) { throw "glfwSetCharModsCallback not implemented."; },
    1494. 

  1494. 

  1495.   glfwSetMouseButtonCallback: function(winid, cbfun) {
    1496. 

  1496.     return GLFW.setMouseButtonCallback(winid, cbfun);
    1497. 

  1497.   },
    1498. 

  1498. 

  1499.   glfwSetCursorPosCallback: function(winid, cbfun) {
    1500. 

  1500.     return GLFW.setCursorPosCallback(winid, cbfun);
    1501. 

  1501.   },
    1502. 

  1502. 

  1503.   glfwSetCursorEnterCallback: function(winid, cbfun) {
    1504. 

  1504.     var win = GLFW.WindowFromId(winid);
    1505. 

  1505.     if (!win) return null;
    1506. 

  1506.     var prevcbfun = win.cursorEnterFunc;
    1507. 

  1507.     win.cursorEnterFunc = cbfun;
    1508. 

  1508.     return prevcbfun;
    1509. 

  1509.   },
    1510. 

  1510. 

  1511.   glfwSetScrollCallback: function(winid, cbfun) {
    1512. 

  1512.     return GLFW.setScrollCallback(winid, cbfun);
    1513. 

  1513.   },
    1514. 

  1514. 

  1515.   glfwVulkanSupported: function() {
    1516. 

  1516.     return 0;
    1517. 

  1517.   },
    1518. 

  1518. 

  1519.   glfwSetDropCallback: function(winid, cbfun) {
    1520. 

  1520.     return GLFW.setDropCallback(winid, cbfun);
    1521. 

  1521.   },
    1522. 

  1522. 

  1523.   glfwGetTimerValue: function() { throw "glfwGetTimerValue is not implemented."; },
    1524. 

  1524. 

  1525.   glfwGetTimerFrequency: function() { throw "glfwGetTimerFrequency is not implemented."; },
    1526. 

  1526. 

  1527.   glfwGetRequiredInstanceExtensions: function(count) { throw "glfwGetRequiredInstanceExtensions is not implemented."; },
    1528. 

  1528. 

  1529.   glfwGetInstanceProcAddress: function(instance, procname) { throw "glfwGetInstanceProcAddress is not implemented."; },
    1530. 

  1530. 

  1531.   glfwGetPhysicalDevicePresentationSupport: function(instance, device, queuefamily) { throw "glfwGetPhysicalDevicePresentationSupport is not implemented"; },
    1532. 

  1532. 

  1533.   glfwCreateWindowSurface: function(instance, winid, allocator, surface) { throw "glfwCreateWindowSurface is not implemented."; },
    1534. 

  1534. 

  1535.   glfwJoystickPresent: function(joy) {
    1536. 

  1536.     GLFW.refreshJoysticks();
    1537. 

  1537. 

  1538.     return GLFW.joys[joy] !== undefined;
    1539. 

  1539.   },
    1540. 

  1540. 

  1541.   glfwGetJoystickAxes: function(joy, count) {
    1542. 

  1542.     GLFW.refreshJoysticks();
    1543. 

  1543. 

  1544.     var state = GLFW.joys[joy];
    1545. 

  1545.     if (!state || !state.axes) {
    1546. 

  1546.       setValue(count, 0, 'i32');
    1547. 

  1547.       return;
    1548. 

  1548.     }
    1549. 

  1549. 

  1550.     setValue(count, state.axesCount, 'i32');
    1551. 

  1551.     return state.axes;
    1552. 

  1552.   },
    1553. 

  1553. 

  1554.   glfwGetJoystickButtons: function(joy, count) {
    1555. 

  1555.     GLFW.refreshJoysticks();
    1556. 

  1556. 

  1557.     var state = GLFW.joys[joy];
    1558. 

  1558.     if (!state || !state.buttons) {
    1559. 

  1559.       setValue(count, 0, 'i32');
    1560. 

  1560.       return;
    1561. 

  1561.     }
    1562. 

  1562. 

  1563.     setValue(count, state.buttonsCount, 'i32');
    1564. 

  1564.     return state.buttons;
    1565. 

  1565.   },
    1566. 

  1566. 

  1567.   glfwGetJoystickName: function(joy) {
    1568. 

  1568.     if (GLFW.joys[joy]) {
    1569. 

  1569.       return GLFW.joys[joy].id;
    1570. 

  1570.     } else {
    1571. 

  1571.       return 0;
    1572. 

  1572.     }
    1573. 

  1573.   },
    1574. 

  1574. 

  1575.   glfwSetJoystickCallback: function(cbfun) {
    1576. 

  1576.     GLFW.setJoystickCallback(cbfun);
    1577. 

  1577.   },
    1578. 

  1578. 

  1579.   glfwSetClipboardString: function(win, string) {},
    1580. 

  1580. 

  1581.   glfwGetClipboardString: function(win) {},
    1582. 

  1582. 

  1583.   glfwMakeContextCurrent: function(winid) {},
    1584. 

  1584. 

  1585.   glfwGetCurrentContext: function() {
    1586. 

  1586.     return GLFW.active ? GLFW.active.id : 0;
    1587. 

  1587.   },
    1588. 

  1588. 

  1589.   glfwSwapBuffers: function(winid) {
    1590. 

  1590.     GLFW.swapBuffers(winid);
    1591. 

  1591.   },
    1592. 

  1592. 

  1593. #endif // GLFW 3
    1594. 

  1594. 

  1595. #if USE_GLFW == 2
    1596. 

  1596.   glfwOpenWindow: function(width, height, redbits, greenbits, bluebits, alphabits, depthbits, stencilbits, mode) {
    1597. 

  1597.     GLFW.hints[0x00021001] = redbits;     // GLFW_RED_BITS
    1598. 

  1598.     GLFW.hints[0x00021002] = greenbits;   // GLFW_GREEN_BITS
    1599. 

  1599.     GLFW.hints[0x00021003] = bluebits;    // GLFW_BLUE_BITS
    1600. 

  1600.     GLFW.hints[0x00021004] = alphabits;   // GLFW_ALPHA_BITS
    1601. 

  1601.     GLFW.hints[0x00021005] = depthbits;   // GLFW_DEPTH_BITS
    1602. 

  1602.     GLFW.hints[0x00021006] = stencilbits; // GLFW_STENCIL_BITS
    1603. 

  1603.     GLFW.createWindow(width, height, "GLFW2 Window", 0, 0);
    1604. 

  1604.     return 1; // GL_TRUE
    1605. 

  1605.   },
    1606. 

  1606. 

  1607.   glfwCloseWindow: function() {
    1608. 

  1608.     GLFW.destroyWindow(GLFW.active.id);
    1609. 

  1609.   },
    1610. 

  1610. 

  1611.   glfwOpenWindowHint: function(target, hint) {
    1612. 

  1612.     target = GLFW.GLFW2ParamToGLFW3Param(target);
    1613. 

  1613.     GLFW.hints[target] = hint;
    1614. 

  1614.   },
    1615. 

  1615. 

  1616.   glfwGetWindowSize: function(width, height) {
    1617. 

  1617.     GLFW.getWindowSize(GLFW.active.id, width, height);
    1618. 

  1618.   },
    1619. 

  1619. 

  1620.   glfwSetWindowSize: function(width, height) {
    1621. 

  1621.     GLFW.setWindowSize(GLFW.active.id, width, height);
    1622. 

  1622.   },
    1623. 

  1623. 

  1624.   glfwGetWindowPos: function(x, y) {
    1625. 

  1625.     GLFW.getWindowPos(GLFW.active.id, x, y);
    1626. 

  1626.   },
    1627. 

  1627. 

  1628.   glfwSetWindowPos: function(x, y) {
    1629. 

  1629.     GLFW.setWindowPos(GLFW.active.id, x, y);
    1630. 

  1630.   },
    1631. 

  1631. 

  1632.   glfwSetWindowTitle: function(title) {
    1633. 

  1633.     GLFW.setWindowTitle(GLFW.active.id, title);
    1634. 

  1634.   },
    1635. 

  1635. 

  1636.   glfwIconifyWindow: function() {
    1637. 

  1637. #if ASSERTIONS
    1638. 

  1638.     warnOnce('glfwIconifyWindow is not implemented');
    1639. 

  1639. #endif
    1640. 

  1640.   },
    1641. 

  1641. 

  1642.   glfwRestoreWindow: function() {
    1643. 

  1643. #if ASSERTIONS
    1644. 

  1644.     warnOnce('glfwRestoreWindow is not implemented');
    1645. 

  1645. #endif
    1646. 

  1646.   },
    1647. 

  1647. 

  1648.   glfwSwapBuffers: function() {
    1649. 

  1649.     GLFW.swapBuffers(GLFW.active.id);
    1650. 

  1650.   },
    1651. 

  1651. 

  1652.   glfwGetWindowParam: function(param) {
    1653. 

  1653.     param = GLFW.GLFW2ParamToGLFW3Param(param);
    1654. 

  1654.     return GLFW.hints[param];
    1655. 

  1655.   },
    1656. 

  1656. 

  1657.   glfwSetWindowSizeCallback: function(cbfun) {
    1658. 

  1658.     GLFW.setWindowSizeCallback(GLFW.active.id, cbfun);
    1659. 

  1659.   },
    1660. 

  1660. 

  1661.   glfwSetWindowCloseCallback: function(cbfun) {
    1662. 

  1662.     GLFW.setWindowCloseCallback(GLFW.active.id, cbfun);
    1663. 

  1663.   },
    1664. 

  1664. 

  1665.   glfwSetWindowRefreshCallback: function(cbfun) {
    1666. 

  1666.     GLFW.setWindowRefreshCallback(GLFW.active.id, cbfun);
    1667. 

  1667.   },
    1668. 

  1668. 

  1669.   glfwGetKey: function(key) {
    1670. 

  1670.     return GLFW.getKey(GLFW.active.id, key);
    1671. 

  1671.   },
    1672. 

  1672. 

  1673.   glfwGetMouseButton: function(button) {
    1674. 

  1674.     return GLFW.getMouseButton(GLFW.active.id, button);
    1675. 

  1675.   },
    1676. 

  1676. 

  1677.   glfwGetMousePos: function(x, y) {
    1678. 

  1678.     GLFW.getMousePos(GLFW.active.id, x, y);
    1679. 

  1679.   },
    1680. 

  1680. 

  1681.   glfwSetMousePos: function(x, y) {
    1682. 

  1682.     GLFW.setCursorPos(GLFW.active.id, x, y);
    1683. 

  1683.   },
    1684. 

  1684. 

  1685.   glfwGetMouseWheel: function() {
    1686. 

  1686.     return 0;
    1687. 

  1687.   },
    1688. 

  1688. 

  1689.   glfwSetMouseWheel: function(pos) {
    1690. 

  1690.   },
    1691. 

  1691. 

  1692.   glfwSetKeyCallback: function(cbfun) {
    1693. 

  1693.     GLFW.setKeyCallback(GLFW.active.id, cbfun);
    1694. 

  1694.   },
    1695. 

  1695. 

  1696.   glfwSetCharCallback: function(cbfun) {
    1697. 

  1697.     GLFW.setCharCallback(GLFW.active.id, cbfun);
    1698. 

  1698.   },
    1699. 

  1699. 

  1700.   glfwSetMouseButtonCallback: function(cbfun) {
    1701. 

  1701.     GLFW.setMouseButtonCallback(GLFW.active.id, cbfun);
    1702. 

  1702.   },
    1703. 

  1703. 

  1704.   glfwSetMousePosCallback: function(cbfun) {
    1705. 

  1705.     GLFW.setCursorPosCallback(GLFW.active.id, cbfun);
    1706. 

  1706.   },
    1707. 

  1707. 

  1708.   glfwSetMouseWheelCallback: function(cbfun) {
    1709. 

  1709.     GLFW.setScrollCallback(GLFW.active.id, cbfun);
    1710. 

  1710.   },
    1711. 

  1711. 

  1712.   glfwGetDesktopMode: function(mode) {
    1713. 

  1713.     throw "glfwGetDesktopMode is not implemented.";
    1714. 

  1714.   },
    1715. 

  1715. 

  1716.   glfwSleep__deps: ['sleep'],
    1717. 

  1717.   glfwSleep: function(time) {
    1718. 

  1718.     _sleep(time);
    1719. 

  1719.   },
    1720. 

  1720. 

  1721.   glfwEnable: function(target) {
    1722. 

  1722.     target = GLFW.GLFW2ParamToGLFW3Param(target);
    1723. 

  1723.     GLFW.hints[target] = false;
    1724. 

  1724.   },
    1725. 

  1725. 

  1726.   glfwDisable: function(target) {
    1727. 

  1727.     target = GLFW.GLFW2ParamToGLFW3Param(target);
    1728. 

  1728.     GLFW.hints[target] = true;
    1729. 

  1729.   },
    1730. 

  1730. 

  1731.   glfwGetGLVersion: function(major, minor, rev) {
    1732. 

  1732.     setValue(major, 0, 'i32');
    1733. 

  1733.     setValue(minor, 0, 'i32');
    1734. 

  1734.     setValue(rev, 1, 'i32');
    1735. 

  1735.   },
    1736. 

  1736. 

  1737.   glfwCreateThread: function(fun, arg) {
    1738. 

  1738.     var str = 'v';
    1739. 

  1739.     for (var i in arg) {
    1740. 

  1740.       str += 'i';
    1741. 

  1741.     }
    1742. 

  1742.     dynCall(str, fun, arg);
    1743. 

  1743.     // One single thread
    1744. 

  1744.     return 0;
    1745. 

  1745.   },
    1746. 

  1746. 

  1747.   glfwDestroyThread: function(ID) {},
    1748. 

  1748. 

  1749.   glfwWaitThread: function(ID, waitmode) {},
    1750. 

  1750. 

  1751.   glfwGetThreadID: function() {
    1752. 

  1752.     // One single thread
    1753. 

  1753.     return 0;
    1754. 

  1754.   },
    1755. 

  1755. 

  1756.   glfwCreateMutex: function() { throw "glfwCreateMutex is not implemented."; },
    1757. 

  1757. 

  1758.   glfwDestroyMutex: function(mutex) { throw "glfwDestroyMutex is not implemented."; },
    1759. 

  1759. 

  1760.   glfwLockMutex: function(mutex) { throw "glfwLockMutex is not implemented."; },
    1761. 

  1761. 

  1762.   glfwUnlockMutex: function(mutex) { throw "glfwUnlockMutex is not implemented."; },
    1763. 

  1763. 

  1764.   glfwCreateCond: function() { throw "glfwCreateCond is not implemented."; },
    1765. 

  1765. 

  1766.   glfwDestroyCond: function(cond) { throw "glfwDestroyCond is not implemented."; },
    1767. 

  1767. 

  1768.   glfwWaitCond: function(cond, mutex, timeout) { throw "glfwWaitCond is not implemented."; },
    1769. 

  1769. 

  1770.   glfwSignalCond: function(cond) { throw "glfwSignalCond is not implemented."; },
    1771. 

  1771. 

  1772.   glfwBroadcastCond: function(cond) { throw "glfwBroadcastCond is not implemented."; },
    1773. 

  1773. 

  1774.   glfwGetNumberOfProcessors: function() {
    1775. 

  1775.     // Threads are disabled anyway…
    1776. 

  1776.     return 1;
    1777. 

  1777.   },
    1778. 

  1778. 

  1779.   glfwReadImage: function(name, img, flags) { throw "glfwReadImage is not implemented."; },
    1780. 

  1780. 

  1781.   glfwReadMemoryImage: function(data, size, img, flags) { throw "glfwReadMemoryImage is not implemented."; },
    1782. 

  1782. 

  1783.   glfwFreeImage: function(img) { throw "glfwFreeImage is not implemented."; },
    1784. 

  1784. 

  1785.   glfwLoadTexture2D: function(name, flags) { throw "glfwLoadTexture2D is not implemented."; },
    1786. 

  1786. 

  1787.   glfwLoadMemoryTexture2D: function(data, size, flags) { throw "glfwLoadMemoryTexture2D is not implemented."; },
    1788. 

  1788. 

  1789.   glfwLoadTextureImage2D: function(img, flags) { throw "glfwLoadTextureImage2D is not implemented."; },
    1790. 

  1790. #endif // GLFW2
    1791. 

  1791. };
    1792. 

  1792. 

  1793. autoAddDeps(LibraryGLFW, '$GLFW');
    1794. 

  1794. mergeInto(LibraryManager.library, LibraryGLFW);
    1795.