@kmamal/sdl 1.0.0-5 → 1.0.0-9

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (90) hide show
  1. package/CHANGELOG.md +12 -6
  2. package/README.md +2 -2
  3. package/binding.gyp +21 -4
  4. package/package.json +5 -12
  5. package/scripts/build.mjs +3 -1
  6. package/scripts/install.mjs +2 -0
  7. package/scripts/util/common.js +3 -2
  8. package/src/javascript/audio/audio-playback-stream.js +9 -10
  9. package/src/javascript/audio/audio-recording-stream.js +9 -8
  10. package/src/javascript/audio/audio-stream.js +101 -44
  11. package/src/javascript/audio/conversion.js +41 -0
  12. package/src/javascript/audio/devices.js +11 -0
  13. package/src/javascript/audio/events.js +65 -0
  14. package/src/javascript/audio/format-helpers.js +8 -4
  15. package/src/javascript/audio/index.js +25 -20
  16. package/src/javascript/audio/prevent-exit.js +13 -10
  17. package/src/javascript/audio/validate.js +9 -0
  18. package/src/javascript/cleanup.js +9 -6
  19. package/src/javascript/clipboard/index.js +8 -3
  20. package/src/javascript/device-instance.js +61 -0
  21. package/src/javascript/events/events-via-poll.js +32 -28
  22. package/src/javascript/events/index.js +85 -479
  23. package/src/javascript/events/try.js +25 -0
  24. package/src/javascript/gamepad/{device.js → devices.js} +4 -5
  25. package/src/javascript/gamepad/events.js +66 -0
  26. package/src/javascript/gamepad/gamepad-instance.js +12 -160
  27. package/src/javascript/gamepad/index.js +15 -16
  28. package/src/javascript/globals.js +10 -1
  29. package/src/javascript/index.js +2 -5
  30. package/src/javascript/joystick/devices.js +43 -0
  31. package/src/javascript/joystick/events.js +129 -0
  32. package/src/javascript/joystick/index.js +9 -18
  33. package/src/javascript/joystick/joystick-device-instance.js +176 -0
  34. package/src/javascript/joystick/joystick-instance.js +12 -158
  35. package/src/javascript/keyboard/index.js +20 -10
  36. package/src/javascript/keyboard/key-mapping.js +46 -27
  37. package/src/javascript/mouse/index.js +36 -29
  38. package/src/javascript/sensor/events.js +21 -0
  39. package/src/javascript/sensor/index.js +13 -2
  40. package/src/javascript/sensor/sensor-instance.js +7 -47
  41. package/src/javascript/subsystems.js +56 -0
  42. package/src/javascript/touch/index.js +9 -4
  43. package/src/javascript/validate.js +119 -0
  44. package/src/javascript/video/conversion.js +63 -0
  45. package/src/javascript/video/events.js +179 -0
  46. package/src/javascript/video/format-helpers.js +10 -8
  47. package/src/javascript/video/index.js +28 -14
  48. package/src/javascript/video/validate.js +45 -0
  49. package/src/javascript/video/window.js +196 -167
  50. package/src/native/audio.cpp +457 -153
  51. package/src/native/audio.h +25 -19
  52. package/src/native/clipboard.cpp +8 -37
  53. package/src/native/clipboard.h +2 -2
  54. package/src/native/enums.cpp +16 -1
  55. package/src/native/enums.h +1 -1
  56. package/src/native/events.cpp +351 -357
  57. package/src/native/events.h +70 -68
  58. package/src/native/gamepad.cpp +147 -103
  59. package/src/native/gamepad.h +10 -11
  60. package/src/native/global.cpp +183 -340
  61. package/src/native/global.h +51 -5
  62. package/src/native/joystick.cpp +204 -275
  63. package/src/native/joystick.h +21 -15
  64. package/src/native/keyboard.cpp +63 -25
  65. package/src/native/keyboard.h +5 -4
  66. package/src/native/module.cpp +23 -3
  67. package/src/native/mouse.cpp +28 -59
  68. package/src/native/mouse.h +9 -9
  69. package/src/native/packed.cpp +99 -0
  70. package/src/native/packed.h +86 -0
  71. package/src/native/power.cpp +13 -1
  72. package/src/native/power.h +3 -3
  73. package/src/native/sensor.cpp +78 -69
  74. package/src/native/sensor.h +7 -7
  75. package/src/native/testing.cpp +148 -0
  76. package/src/native/testing.h +17 -0
  77. package/src/native/threads.cpp +301 -0
  78. package/src/native/threads.h +36 -0
  79. package/src/native/touch.cpp +38 -44
  80. package/src/native/touch.h +3 -2
  81. package/src/native/video.cpp +211 -98
  82. package/src/native/video.h +7 -4
  83. package/src/native/window.cpp +201 -219
  84. package/src/native/window.h +24 -20
  85. package/src/types/index.d.ts +157 -70
  86. package/src/javascript/audio/device.js +0 -37
  87. package/src/javascript/joystick/device.js +0 -13
  88. package/src/javascript/joystick/shared.js +0 -90
  89. package/src/javascript/worker.js +0 -88
  90. package/src/types/worker.d.ts +0 -71
@@ -1,325 +1,126 @@
1
1
  #include "global.h"
2
2
  #include "events.h"
3
3
  #include "keyboard.h"
4
- #include "video.h"
5
- #include "touch.h"
6
- #include "joystick.h"
7
- #include "gamepad.h"
8
- #include "sensor.h"
9
4
  #include "audio.h"
10
- #include "power.h"
5
+ #include "threads.h"
11
6
  #include <SDL3/SDL.h>
12
7
  #include <string>
13
- #include <sstream>
14
8
  #include <vector>
15
9
  #include <atomic>
10
+ #include <condition_variable>
16
11
 
17
12
  #if defined(SDL_PLATFORM_MACOS)
18
13
  #include "cocoa-global.h"
19
14
  #endif
20
15
 
21
16
 
22
- static SDL_ThreadID mainThreadId;
17
+ static std::atomic<SDL_ThreadID> main_thread_id { 0 };
23
18
  static std::atomic<bool> ready { false };
24
-
25
- std::mutex &
26
- global::lock()
19
+ static std::atomic<bool> started { false };
20
+
21
+ struct InitRequest {
22
+ SDL_InitFlags flags;
23
+ bool done = false;
24
+ bool result = false;
25
+ std::string error;
26
+ };
27
+
28
+ static std::mutex request_mutex;
29
+ static std::condition_variable request_cv;
30
+ static std::vector<InitRequest *> pending_requests;
31
+
32
+ // Recursive because watchEvents holds this lock while dispatching window events to JS, and the handlers re-enter it through the wrappers.
33
+ std::recursive_mutex &
34
+ global::lock ()
27
35
  {
28
- static std::mutex mutex;
36
+ static std::recursive_mutex mutex;
29
37
  return mutex;
30
38
  }
31
39
 
32
- void
33
- global::assertReady(Napi::Env &env)
40
+ bool
41
+ global::isReady ()
34
42
  {
35
- if (!ready.load(std::memory_order_acquire)) {
36
- throw Napi::Error::New(env, "SDL is not initialized, import @kmamal/sdl in the main thread first");
37
- }
43
+ return ready.load(std::memory_order_acquire);
44
+ }
45
+
46
+ bool
47
+ global::isMainThread ()
48
+ {
49
+ return ready.load(std::memory_order_acquire) && SDL_GetCurrentThreadID() == main_thread_id.load(std::memory_order_acquire);
38
50
  }
39
51
 
40
52
  void
41
- global::registerEnv(Napi::Env env)
53
+ global::assertReady (Napi::Env &env)
42
54
  {
43
- env.AddCleanupHook([env]() { audio::closeEnvStreams(env); });
55
+ if (ready.load(std::memory_order_acquire)) { return; }
56
+
57
+ throw Napi::Error::New(env, started.load(std::memory_order_acquire)
58
+ ? "SDL has been shut down"
59
+ : "@kmamal/sdl must be imported on the main thread before it can be used in a worker");
44
60
  }
45
61
 
46
- bool watchEvents(void*, SDL_Event *event) {
62
+ // Delivers window move/resize/expose events synchronously so handlers run during the OS's modal move/resize loop.
63
+ static bool SDLCALL
64
+ watchEvents (void *, SDL_Event *event)
65
+ {
47
66
  if (true
48
- && SDL_GetCurrentThreadID() == mainThreadId
67
+ && SDL_GetCurrentThreadID() == main_thread_id.load(std::memory_order_acquire)
49
68
  && (false
50
69
  || event->type == SDL_EVENT_WINDOW_MOVED
51
70
  || event->type == SDL_EVENT_WINDOW_RESIZED
71
+ || (event->type == SDL_EVENT_WINDOW_EXPOSED && event->window.data1 == 1)
52
72
  )
53
73
  ) {
74
+ // SDL runs watchers with its watcher-list mutex held, and a worker holding global::lock() may be inside an SDL call that pushes an event and so waits for that same mutex.
75
+ // Waiting here would deadlock; try-lock instead and leave the event for the normal poll when a worker has the lock.
76
+ std::unique_lock<std::recursive_mutex> guard(global::lock(), std::try_to_lock);
77
+ if (!guard.owns_lock()) { return true; }
54
78
  events::dispatchEventFromWatch(*event);
55
79
  }
56
80
  return true;
57
81
  }
58
82
 
59
83
 
60
- Napi::Value
61
- global::initialize(const Napi::CallbackInfo &info)
84
+ static void
85
+ _start (Napi::Env &env)
62
86
  {
63
- Napi::Env env = info.Env();
64
-
65
- events::targets::APP = "app";
66
- events::targets::VIDEO = "video";
67
- events::targets::WINDOW = "window";
68
- events::targets::KEYBOARD = "keyboard";
69
- events::targets::JOYSTICK = "joystick";
70
- events::targets::GAMEPAD = "gamepad";
71
- events::targets::SENSOR = "sensor";
72
- events::targets::CLIPBOARD = "clipboard";
73
- events::targets::JOYSTICK_DEVICE = "joystickDevice";
74
- events::targets::GAMEPAD_DEVICE = "gamepadDevice";
75
- events::targets::AUDIO_DEVICE = "audioDevice";
76
-
77
- events::types::QUIT = "quit";
78
- events::types::DISPLAY_ADD = "displayAdd";
79
- events::types::DISPLAY_REMOVE = "displayRemove";
80
- events::types::DISPLAY_ORIENT = "displayOrient";
81
- events::types::DISPLAY_MOVE = "displayMove";
82
- events::types::DISPLAY_SCALE = "displayScaleChange";
83
- events::types::DISPLAY_MODE = "displayModeChange";
84
- events::types::DISPLAY_USABLE = "displayUsableChange";
85
- events::types::DISPLAY_CHANGE = "displayChange";
86
- events::types::SHOW = "show";
87
- events::types::HIDE = "hide";
88
- events::types::EXPOSE = "expose";
89
- events::types::MOVE = "move";
90
- events::types::RESIZE = "resize";
91
- events::types::MINIMIZE = "minimize";
92
- events::types::MAXIMIZE = "maximize";
93
- events::types::RESTORE = "restore";
94
- events::types::ENTER_FULLSCREEN = "enterFullscreen";
95
- events::types::LEAVE_FULLSCREEN = "leaveFullscreen";
96
- events::types::FOCUS = "focus";
97
- events::types::BLUR = "blur";
98
- events::types::HOVER = "hover";
99
- events::types::LEAVE = "leave";
100
- events::types::KEY_DOWN = "keyDown";
101
- events::types::KEY_UP = "keyUp";
102
- events::types::TEXT_INPUT = "textInput";
103
- events::types::MOUSE_MOVE = "mouseMove";
104
- events::types::MOUSE_BUTTON_DOWN = "mouseButtonDown";
105
- events::types::MOUSE_BUTTON_UP = "mouseButtonUp";
106
- events::types::MOUSE_WHEEL = "mouseWheel";
107
- events::types::DROP_BEGIN = "dropBegin";
108
- events::types::DROP_COMPLETE = "dropComplete";
109
- events::types::DROP_FILE = "dropFile";
110
- events::types::DROP_TEXT = "dropText";
111
- events::types::CLOSE = "close";
112
- events::types::RENDER_DEVICE_LOST = "renderDeviceLost";
113
- events::types::KEYMAP_CHANGE = "keymapChange";
114
- events::types::FINGER_DOWN = "fingerDown";
115
- events::types::FINGER_UP = "fingerUp";
116
- events::types::FINGER_MOVE = "fingerMove";
117
- events::types::FINGER_CANCEL = "fingerCancel";
118
- events::types::DEVICE_ADD = "deviceAdd";
119
- events::types::DEVICE_REMOVE = "deviceRemove";
120
- events::types::DEVICE_FORMAT_CHANGE = "deviceFormatChange";
121
- events::types::AXIS_MOTION = "axisMotion";
122
- events::types::BUTTON_DOWN = "buttonDown";
123
- events::types::BUTTON_UP = "buttonUp";
124
- events::types::BALL_MOTION = "ballMotion";
125
- events::types::HAT_MOTION = "hatMotion";
126
- events::types::POWER_UPDATE = "powerUpdate";
127
- events::types::STEAM_HANDLE_UPDATE = "steamHandleUpdate";
128
- events::types::REMAP = "remap";
129
- events::types::UPDATE = "update";
130
-
131
- // video::orientations[SDL_ORIENTATION_UNKNOWN] = nullptr;
132
- video::orientations[SDL_ORIENTATION_LANDSCAPE] = "landscape";
133
- video::orientations[SDL_ORIENTATION_LANDSCAPE_FLIPPED] = "landscapeFlipped";
134
- video::orientations[SDL_ORIENTATION_PORTRAIT] = "portrait";
135
- video::orientations[SDL_ORIENTATION_PORTRAIT_FLIPPED] = "portraitFlipped";
136
-
137
- video::formats[SDL_PIXELFORMAT_RGB332] = "rgb332";
138
- video::formats[SDL_PIXELFORMAT_XRGB4444] = "xrgb4444";
139
- video::formats[SDL_PIXELFORMAT_XBGR4444] = "xbgr4444";
140
- video::formats[SDL_PIXELFORMAT_XRGB1555] = "xrgb1555";
141
- video::formats[SDL_PIXELFORMAT_XBGR1555] = "xbgr1555";
142
- video::formats[SDL_PIXELFORMAT_ARGB4444] = "argb4444";
143
- video::formats[SDL_PIXELFORMAT_RGBA4444] = "rgba4444";
144
- video::formats[SDL_PIXELFORMAT_ABGR4444] = "abgr4444";
145
- video::formats[SDL_PIXELFORMAT_BGRA4444] = "bgra4444";
146
- video::formats[SDL_PIXELFORMAT_ARGB1555] = "argb1555";
147
- video::formats[SDL_PIXELFORMAT_RGBA5551] = "rgba5551";
148
- video::formats[SDL_PIXELFORMAT_ABGR1555] = "abgr1555";
149
- video::formats[SDL_PIXELFORMAT_BGRA5551] = "bgra5551";
150
- video::formats[SDL_PIXELFORMAT_RGB565] = "rgb565";
151
- video::formats[SDL_PIXELFORMAT_BGR565] = "bgr565";
152
- video::formats[SDL_PIXELFORMAT_RGB24] = "rgb24";
153
- video::formats[SDL_PIXELFORMAT_BGR24] = "bgr24";
154
- video::formats[SDL_PIXELFORMAT_XRGB8888] = "xrgb8888";
155
- video::formats[SDL_PIXELFORMAT_RGBX8888] = "rgbx8888";
156
- video::formats[SDL_PIXELFORMAT_XBGR8888] = "xbgr8888";
157
- video::formats[SDL_PIXELFORMAT_BGRX8888] = "bgrx8888";
158
- video::formats[SDL_PIXELFORMAT_ARGB8888] = "argb8888";
159
- video::formats[SDL_PIXELFORMAT_RGBA8888] = "rgba8888";
160
- video::formats[SDL_PIXELFORMAT_ABGR8888] = "abgr8888";
161
- video::formats[SDL_PIXELFORMAT_BGRA8888] = "bgra8888";
162
- video::formats[SDL_PIXELFORMAT_ARGB2101010] = "argb2101010";
163
- video::formats[SDL_PIXELFORMAT_XRGB2101010] = "xrgb2101010";
164
- video::formats[SDL_PIXELFORMAT_XBGR2101010] = "xbgr2101010";
165
- video::formats[SDL_PIXELFORMAT_ABGR2101010] = "abgr2101010";
166
- video::formats[SDL_PIXELFORMAT_RGB48] = "rgb48";
167
- video::formats[SDL_PIXELFORMAT_BGR48] = "bgr48";
168
- video::formats[SDL_PIXELFORMAT_RGBA64] = "rgba64";
169
- video::formats[SDL_PIXELFORMAT_ARGB64] = "argb64";
170
- video::formats[SDL_PIXELFORMAT_BGRA64] = "bgra64";
171
- video::formats[SDL_PIXELFORMAT_ABGR64] = "abgr64";
172
- video::formats[SDL_PIXELFORMAT_RGB48_FLOAT] = "rgb48f";
173
- video::formats[SDL_PIXELFORMAT_BGR48_FLOAT] = "bgr48f";
174
- video::formats[SDL_PIXELFORMAT_RGBA64_FLOAT] = "rgba64f";
175
- video::formats[SDL_PIXELFORMAT_ARGB64_FLOAT] = "argb64f";
176
- video::formats[SDL_PIXELFORMAT_BGRA64_FLOAT] = "bgra64f";
177
- video::formats[SDL_PIXELFORMAT_ABGR64_FLOAT] = "abgr64f";
178
- video::formats[SDL_PIXELFORMAT_RGB96_FLOAT] = "rgb96f";
179
- video::formats[SDL_PIXELFORMAT_BGR96_FLOAT] = "bgr96f";
180
- video::formats[SDL_PIXELFORMAT_RGBA128_FLOAT] = "rgba128f";
181
- video::formats[SDL_PIXELFORMAT_ARGB128_FLOAT] = "argb128f";
182
- video::formats[SDL_PIXELFORMAT_BGRA128_FLOAT] = "bgra128f";
183
- video::formats[SDL_PIXELFORMAT_ABGR128_FLOAT] = "abgr128f";
184
- video::formats[SDL_PIXELFORMAT_YV12] = "yv12";
185
- video::formats[SDL_PIXELFORMAT_IYUV] = "iyuv";
186
- video::formats[SDL_PIXELFORMAT_YUY2] = "yuy2";
187
- video::formats[SDL_PIXELFORMAT_UYVY] = "uyvy";
188
- video::formats[SDL_PIXELFORMAT_YVYU] = "yvyu";
189
- video::formats[SDL_PIXELFORMAT_NV12] = "nv12";
190
- video::formats[SDL_PIXELFORMAT_NV21] = "nv21";
191
- video::formats[SDL_PIXELFORMAT_P010] = "p010";
192
-
193
- // touch::device_types[SDL_TOUCH_DEVICE_INVALID] = nullptr;
194
- touch::device_types[SDL_TOUCH_DEVICE_DIRECT] = "direct";
195
- touch::device_types[SDL_TOUCH_DEVICE_INDIRECT_ABSOLUTE] = "indirectAbsolute";
196
- touch::device_types[SDL_TOUCH_DEVICE_INDIRECT_RELATIVE] = "indirectRelative";
197
-
198
- // joystick::types[SDL_JOYSTICK_TYPE_UNKNOWN] = nullptr;
199
- joystick::types[SDL_JOYSTICK_TYPE_GAMEPAD] = "gamepad";
200
- joystick::types[SDL_JOYSTICK_TYPE_WHEEL] = "wheel";
201
- joystick::types[SDL_JOYSTICK_TYPE_ARCADE_STICK] = "arcadeStick";
202
- joystick::types[SDL_JOYSTICK_TYPE_FLIGHT_STICK] = "flightStick";
203
- joystick::types[SDL_JOYSTICK_TYPE_DANCE_PAD] = "dancePad";
204
- joystick::types[SDL_JOYSTICK_TYPE_GUITAR] = "guitar";
205
- joystick::types[SDL_JOYSTICK_TYPE_DRUM_KIT] = "drumKit";
206
- joystick::types[SDL_JOYSTICK_TYPE_ARCADE_PAD] = "arcadePad";
207
- joystick::types[SDL_JOYSTICK_TYPE_THROTTLE] = "throttle";
208
-
209
- joystick::hat_positions[SDL_HAT_CENTERED] = "centered";
210
- joystick::hat_positions[SDL_HAT_UP] = "up";
211
- joystick::hat_positions[SDL_HAT_RIGHT] = "right";
212
- joystick::hat_positions[SDL_HAT_DOWN] = "down";
213
- joystick::hat_positions[SDL_HAT_LEFT] = "left";
214
- joystick::hat_positions[SDL_HAT_RIGHTUP] = "rightUp";
215
- joystick::hat_positions[SDL_HAT_RIGHTDOWN] = "rightDown";
216
- joystick::hat_positions[SDL_HAT_LEFTUP] = "leftUp";
217
- joystick::hat_positions[SDL_HAT_LEFTDOWN] = "leftDown";
218
-
219
- // gamepad::types[SDL_GAMEPAD_TYPE_UNKNOWN] = nullptr;
220
- gamepad::types[SDL_GAMEPAD_TYPE_STANDARD] = "standard";
221
- gamepad::types[SDL_GAMEPAD_TYPE_XBOX360] = "xbox360";
222
- gamepad::types[SDL_GAMEPAD_TYPE_XBOXONE] = "xboxOne";
223
- gamepad::types[SDL_GAMEPAD_TYPE_PS3] = "ps3";
224
- gamepad::types[SDL_GAMEPAD_TYPE_PS4] = "ps4";
225
- gamepad::types[SDL_GAMEPAD_TYPE_NINTENDO_SWITCH_PRO] = "nintendoSwitchPro";
226
- gamepad::types[SDL_GAMEPAD_TYPE_PS5] = "ps5";
227
- gamepad::types[SDL_GAMEPAD_TYPE_NINTENDO_SWITCH_JOYCON_LEFT] = "nintendoSwitchJoyconLeft";
228
- gamepad::types[SDL_GAMEPAD_TYPE_NINTENDO_SWITCH_JOYCON_RIGHT] = "nintendoSwitchJoyconRight";
229
- gamepad::types[SDL_GAMEPAD_TYPE_NINTENDO_SWITCH_JOYCON_PAIR] = "nintendoSwitchJoyconPair";
230
- gamepad::types[SDL_GAMEPAD_TYPE_GAMECUBE] = "gamecube";
231
-
232
- gamepad::axes[SDL_GAMEPAD_AXIS_LEFTX] = "leftStickX";
233
- gamepad::axes[SDL_GAMEPAD_AXIS_LEFTY] = "leftStickY";
234
- gamepad::axes[SDL_GAMEPAD_AXIS_RIGHTX] = "rightStickX";
235
- gamepad::axes[SDL_GAMEPAD_AXIS_RIGHTY] = "rightStickY";
236
- gamepad::axes[SDL_GAMEPAD_AXIS_LEFT_TRIGGER] = "leftTrigger";
237
- gamepad::axes[SDL_GAMEPAD_AXIS_RIGHT_TRIGGER] = "rightTrigger";
238
-
239
- gamepad::buttons[SDL_GAMEPAD_BUTTON_DPAD_LEFT] = "dpadLeft";
240
- gamepad::buttons[SDL_GAMEPAD_BUTTON_DPAD_RIGHT] = "dpadRight";
241
- gamepad::buttons[SDL_GAMEPAD_BUTTON_DPAD_UP] = "dpadUp";
242
- gamepad::buttons[SDL_GAMEPAD_BUTTON_DPAD_DOWN] = "dpadDown";
243
- gamepad::buttons[SDL_GAMEPAD_BUTTON_SOUTH] = "south";
244
- gamepad::buttons[SDL_GAMEPAD_BUTTON_EAST] = "east";
245
- gamepad::buttons[SDL_GAMEPAD_BUTTON_WEST] = "west";
246
- gamepad::buttons[SDL_GAMEPAD_BUTTON_NORTH] = "north";
247
- gamepad::buttons[SDL_GAMEPAD_BUTTON_GUIDE] = "guide";
248
- gamepad::buttons[SDL_GAMEPAD_BUTTON_BACK] = "back";
249
- gamepad::buttons[SDL_GAMEPAD_BUTTON_START] = "start";
250
- gamepad::buttons[SDL_GAMEPAD_BUTTON_LEFT_STICK] = "leftStick";
251
- gamepad::buttons[SDL_GAMEPAD_BUTTON_RIGHT_STICK] = "rightStick";
252
- gamepad::buttons[SDL_GAMEPAD_BUTTON_LEFT_SHOULDER] = "leftShoulder";
253
- gamepad::buttons[SDL_GAMEPAD_BUTTON_RIGHT_SHOULDER] = "rightShoulder";
254
- gamepad::buttons[SDL_GAMEPAD_BUTTON_RIGHT_PADDLE1] = "rightPaddle1";
255
- gamepad::buttons[SDL_GAMEPAD_BUTTON_LEFT_PADDLE1] = "leftPaddle1";
256
- gamepad::buttons[SDL_GAMEPAD_BUTTON_RIGHT_PADDLE2] = "rightPaddle2";
257
- gamepad::buttons[SDL_GAMEPAD_BUTTON_LEFT_PADDLE2] = "leftPaddle2";
258
- gamepad::buttons[SDL_GAMEPAD_BUTTON_MISC1] = "misc1";
259
- gamepad::buttons[SDL_GAMEPAD_BUTTON_MISC2] = "misc2";
260
- gamepad::buttons[SDL_GAMEPAD_BUTTON_MISC3] = "misc3";
261
- gamepad::buttons[SDL_GAMEPAD_BUTTON_MISC4] = "misc4";
262
- gamepad::buttons[SDL_GAMEPAD_BUTTON_MISC5] = "misc5";
263
- gamepad::buttons[SDL_GAMEPAD_BUTTON_MISC6] = "misc6";
264
- gamepad::buttons[SDL_GAMEPAD_BUTTON_TOUCHPAD] = "touchpad";
265
-
266
- // gamepad::button_labels[SDL_GAMEPAD_BUTTON_LABEL_UNKNOWN] = nullptr;
267
- gamepad::button_labels[SDL_GAMEPAD_BUTTON_LABEL_A] = "a";
268
- gamepad::button_labels[SDL_GAMEPAD_BUTTON_LABEL_B] = "b";
269
- gamepad::button_labels[SDL_GAMEPAD_BUTTON_LABEL_X] = "x";
270
- gamepad::button_labels[SDL_GAMEPAD_BUTTON_LABEL_Y] = "y";
271
- gamepad::button_labels[SDL_GAMEPAD_BUTTON_LABEL_CROSS] = "cross";
272
- gamepad::button_labels[SDL_GAMEPAD_BUTTON_LABEL_CIRCLE] = "circle";
273
- gamepad::button_labels[SDL_GAMEPAD_BUTTON_LABEL_SQUARE] = "square";
274
- gamepad::button_labels[SDL_GAMEPAD_BUTTON_LABEL_TRIANGLE] = "triangle";
275
-
276
- // sensor::types[SDL_SENSOR_UNKNOWN] = nullptr;
277
- sensor::types[SDL_SENSOR_ACCEL] = "accelerometer";
278
- sensor::types[SDL_SENSOR_GYRO] = "gyroscope";
279
- sensor::types[SDL_SENSOR_ACCEL_L] = "accelerometer";
280
- sensor::types[SDL_SENSOR_GYRO_L] = "gyroscope";
281
- sensor::types[SDL_SENSOR_ACCEL_R] = "accelerometer";
282
- sensor::types[SDL_SENSOR_GYRO_R] = "gyroscope";
283
-
284
- // sensor::sides[SDL_SENSOR_UNKNOWN] = nullptr;
285
- // sensor::sides[SDL_SENSOR_ACCEL] = nullptr;
286
- // sensor::sides[SDL_SENSOR_GYRO] = nullptr;
287
- sensor::sides[SDL_SENSOR_ACCEL_L] = "left";
288
- sensor::sides[SDL_SENSOR_GYRO_L] = "left";
289
- sensor::sides[SDL_SENSOR_ACCEL_R] = "right";
290
- sensor::sides[SDL_SENSOR_GYRO_R] = "right";
291
-
292
- audio::device_types[true] = "recording";
293
- audio::device_types[false] = "playback";
294
-
295
- audio::formats[SDL_AUDIO_S8] = "s8";
296
- audio::formats[SDL_AUDIO_U8] = "u8";
297
- audio::formats[SDL_AUDIO_S16LE] = "s16le";
298
- audio::formats[SDL_AUDIO_S16BE] = "s16be";
299
- audio::formats[SDL_AUDIO_S32LE] = "s32le";
300
- audio::formats[SDL_AUDIO_S32BE] = "s32be";
301
- audio::formats[SDL_AUDIO_F32LE] = "f32le";
302
- audio::formats[SDL_AUDIO_F32BE] = "f32be";
303
-
304
- // power::states[SDL_POWERSTATE_UNKNOWN] = nullptr;
305
- power::states[SDL_POWERSTATE_NO_BATTERY] = "noBattery";
306
- power::states[SDL_POWERSTATE_ON_BATTERY] = "battery";
307
- power::states[SDL_POWERSTATE_CHARGING] = "charging";
308
- power::states[SDL_POWERSTATE_CHARGED] = "charged";
309
-
310
-
311
- Napi::Object initialized = Napi::Object::New(env);
312
-
313
87
  SDL_SetHint(SDL_HINT_FRAMEBUFFER_ACCELERATION, "0");
314
88
  SDL_SetHint(SDL_HINT_QUIT_ON_LAST_WINDOW_CLOSE, "0");
315
89
 
316
90
  if (!SDL_InitSubSystem(SDL_INIT_EVENTS)) {
317
- std::ostringstream message;
318
- message << "SDL_Init() error: " << SDL_GetError();
319
- SDL_ClearError();
320
- throw Napi::Error::New(env, message.str());
91
+ throw global::sdlError(env, "SDL_InitSubSystem", "SDL_INIT_EVENTS");
321
92
  }
322
93
 
94
+ main_thread_id.store(SDL_GetCurrentThreadID(), std::memory_order_release);
95
+
96
+ if (!SDL_AddEventWatch(watchEvents, nullptr)) {
97
+ Napi::Error error = global::sdlError(env, "SDL_AddEventWatch");
98
+ SDL_Quit();
99
+ throw error;
100
+ }
101
+
102
+ keyboard::keys = SDL_GetKeyboardState(&keyboard::num_keys);
103
+
104
+ #if defined(SDL_PLATFORM_MACOS)
105
+ reenableInertialScrolling();
106
+ #endif
107
+
108
+ started.store(true, std::memory_order_release);
109
+ ready.store(true, std::memory_order_release);
110
+ }
111
+
112
+
113
+ Napi::Value
114
+ global::initialize (const Napi::CallbackInfo &info)
115
+ {
116
+ Napi::Env env = info.Env();
117
+
118
+ bool is_main = info[0].As<Napi::Boolean>().Value();
119
+
120
+ std::lock_guard<std::recursive_mutex> guard(global::lock());
121
+
122
+ if (is_main && !ready.load(std::memory_order_acquire)) { _start(env); }
123
+
323
124
  int sdl_compile_version = SDL_VERSION;
324
125
 
325
126
  Napi::Object compile_version = Napi::Object::New(env);
@@ -347,99 +148,141 @@ global::initialize(const Napi::CallbackInfo &info)
347
148
  platform = Napi::String::New(env, platform_name);
348
149
  }
349
150
 
350
- Napi::Array all_video_drivers = Napi::Array::New(env);
151
+ Napi::Object result = Napi::Object::New(env);
152
+ result.Set("version", versions);
153
+ result.Set("platform", platform);
351
154
 
352
- int num_video_drivers = SDL_GetNumVideoDrivers();
353
- for (int i = 0; i < num_video_drivers; i ++) {
354
- all_video_drivers.Set(i, SDL_GetVideoDriver(i));
355
- }
155
+ return result;
156
+ }
356
157
 
357
- Napi::Value current_video_driver;
358
- if (SDL_InitSubSystem(SDL_INIT_VIDEO)) {
359
- current_video_driver = Napi::String::New(env, SDL_GetCurrentVideoDriver());
360
- initialized.Set("video", true);
361
- }
362
- else {
363
- current_video_driver = env.Null();
364
- initialized.Set("video", false);
365
- }
366
158
 
367
- Napi::Object video_drivers = Napi::Object::New(env);
368
- video_drivers.Set("all", all_video_drivers);
369
- video_drivers.Set("current", current_video_driver);
159
+ // Only the main thread must initializes SDL and polls for events.
160
+ // On macOS the Cocoa backend refuses any other thread.
161
+ static bool
162
+ _initSubsystem (SDL_InitFlags flags, std::string &error)
163
+ {
164
+ if ((SDL_WasInit(flags) & flags) == flags) { return true; }
165
+
166
+ bool success = SDL_InitSubSystem(flags);
167
+ if (!success) { error = SDL_GetError(); }
168
+ SDL_ClearError();
169
+ return success;
170
+ }
370
171
 
371
- Napi::Array all_audio_drivers = Napi::Array::New(env);
172
+ static Napi::Value
173
+ _initResult (Napi::Env env, bool success, const std::string &error)
174
+ {
175
+ if (success) { return Napi::Boolean::New(env, true); }
176
+ return Napi::String::New(env, error);
177
+ }
372
178
 
373
- int num_audio_drivers = SDL_GetNumAudioDrivers();
374
- for (int i = 0; i < num_audio_drivers; i ++) {
375
- all_audio_drivers.Set(i, SDL_GetAudioDriver(i));
179
+ static void
180
+ _failInitRequests ()
181
+ {
182
+ std::lock_guard<std::mutex> guard(request_mutex);
183
+ for (InitRequest *request : pending_requests) {
184
+ request->done = true;
185
+ request->result = false;
186
+ request->error = "SDL has been shut down";
376
187
  }
188
+ pending_requests.clear();
189
+ request_cv.notify_all();
190
+ }
377
191
 
378
- Napi::Value current_audio_driver;
379
- if (SDL_InitSubSystem(SDL_INIT_AUDIO)) {
380
- current_audio_driver = Napi::String::New(env, SDL_GetCurrentAudioDriver());
381
- initialized.Set("audio", true);
192
+ void
193
+ global::processInitRequests ()
194
+ {
195
+ std::vector<InitRequest *> batch;
196
+ {
197
+ std::lock_guard<std::mutex> guard(request_mutex);
198
+ if (pending_requests.empty()) { return; }
199
+ batch.swap(pending_requests);
382
200
  }
383
- else {
384
- current_audio_driver = env.Null();
385
- initialized.Set("audio", false);
201
+
202
+ {
203
+ std::lock_guard<std::recursive_mutex> guard(global::lock());
204
+ for (InitRequest *request : batch) {
205
+ if (!ready.load(std::memory_order_acquire)) {
206
+ request->result = false;
207
+ request->error = "SDL has been shut down";
208
+ continue;
209
+ }
210
+ request->result = _initSubsystem(request->flags, request->error);
211
+ }
386
212
  }
387
213
 
388
- Napi::Object audio_drivers = Napi::Object::New(env);
389
- audio_drivers.Set("all", all_audio_drivers);
390
- audio_drivers.Set("current", current_audio_driver);
214
+ {
215
+ std::lock_guard<std::mutex> guard(request_mutex);
216
+ for (InitRequest *request : batch) { request->done = true; }
217
+ }
218
+ request_cv.notify_all();
219
+ }
391
220
 
392
- Napi::Object drivers = Napi::Object::New(env);
393
- drivers.Set("video", video_drivers);
394
- drivers.Set("audio", audio_drivers);
395
221
 
396
- initialized.Set("joystick", SDL_InitSubSystem(SDL_INIT_JOYSTICK));
397
- initialized.Set("gamepad", SDL_InitSubSystem(SDL_INIT_GAMEPAD));
398
- initialized.Set("haptic", SDL_InitSubSystem(SDL_INIT_HAPTIC));
399
- initialized.Set("sensor", SDL_InitSubSystem(SDL_INIT_SENSOR));
222
+ Napi::Value
223
+ global::initSubsystem (const Napi::CallbackInfo &info)
224
+ {
225
+ Napi::Env env = info.Env();
400
226
 
401
- // Drop errors from optional subsystems that failed to initialize
402
- SDL_ClearError();
227
+ std::string name = info[0].As<Napi::String>().Utf8Value();
403
228
 
404
- mainThreadId = SDL_GetCurrentThreadID();
405
- if (!SDL_AddEventWatch(watchEvents, nullptr)) {
229
+ SDL_InitFlags flags;
230
+ if (name == "video") { flags = SDL_INIT_VIDEO; }
231
+ else if (name == "audio") { flags = SDL_INIT_AUDIO; }
232
+ else if (name == "joystick") { flags = SDL_INIT_JOYSTICK; }
233
+ else if (name == "gamepad") { flags = SDL_INIT_GAMEPAD; }
234
+ else if (name == "sensor") { flags = SDL_INIT_SENSOR; }
235
+ else {
406
236
  std::ostringstream message;
407
- message << "SDL_AddEventWatch() error: " << SDL_GetError();
408
- SDL_ClearError();
237
+ message << "initSubsystem(" << name << ") error: invalid subsystem";
409
238
  throw Napi::Error::New(env, message.str());
410
239
  }
411
240
 
412
- keyboard::keys = SDL_GetKeyboardState(&keyboard::num_keys);
241
+ if (global::isMainThread()) {
242
+ std::lock_guard<std::recursive_mutex> guard(global::lock());
243
+ global::assertReady(env);
244
+ std::string error;
245
+ bool success = _initSubsystem(flags, error);
246
+ return _initResult(env, success, error);
247
+ }
413
248
 
414
- #if defined(SDL_PLATFORM_MACOS)
415
- reenableInertialScrolling();
416
- #endif
249
+ InitRequest request = { flags, false, false, std::string() };
250
+ {
251
+ std::lock_guard<std::mutex> guard(request_mutex);
252
+ global::assertReady(env);
253
+ pending_requests.push_back(&request);
254
+ }
255
+ threads::wakeMain();
417
256
 
257
+ {
258
+ std::unique_lock<std::mutex> guard(request_mutex);
259
+ request_cv.wait(guard, [&] { return request.done; });
260
+ }
418
261
 
419
- SDL_memset(&joystick::zero_guid, 0, sizeof(joystick::zero_guid));
262
+ return _initResult(env, request.result, request.error);
263
+ }
420
264
 
421
- ready.store(true, std::memory_order_release);
422
265
 
423
- Napi::Object result = Napi::Object::New(env);
424
- result.Set("version", versions);
425
- result.Set("platform", platform);
426
- result.Set("drivers", drivers);
427
- result.Set("initialized", initialized);
266
+ void
267
+ global::teardown ()
268
+ {
269
+ std::lock_guard<std::recursive_mutex> guard(global::lock());
428
270
 
429
- return result;
430
- }
271
+ if (!ready.load(std::memory_order_acquire)) { return; }
272
+ ready.store(false, std::memory_order_release);
431
273
 
274
+ audio::closeAllStreams();
275
+ threads::shutdown();
276
+ _failInitRequests();
277
+ SDL_Quit();
278
+ }
432
279
 
433
280
  Napi::Value
434
- global::cleanup(const Napi::CallbackInfo &info)
281
+ global::cleanup (const Napi::CallbackInfo &info)
435
282
  {
436
283
  Napi::Env env = info.Env();
437
284
 
438
- std::lock_guard<std::mutex> guard(global::lock());
439
-
440
- audio::closeAllStreams();
441
- ready.store(false, std::memory_order_release);
442
- SDL_Quit();
285
+ threads::leave(env);
443
286
 
444
287
  return env.Undefined();
445
288
  }
@@ -2,16 +2,62 @@
2
2
  #define _GLOBAL_H_
3
3
 
4
4
  #include <napi.h>
5
+ #include <SDL3/SDL.h>
5
6
  #include <mutex>
7
+ #include <memory>
8
+ #include <sstream>
9
+ #include <string>
6
10
 
7
11
  namespace global {
8
12
 
9
- std::mutex &lock();
10
- void assertReady(Napi::Env &env);
11
- void registerEnv(Napi::Env env);
13
+ namespace detail {
12
14
 
13
- Napi::Value initialize(const Napi::CallbackInfo &info);
14
- Napi::Value cleanup(const Napi::CallbackInfo &info);
15
+ inline void streamArgs (std::ostream &) {}
16
+
17
+ template <typename T, typename... Rest>
18
+ void streamArgs (std::ostream &out, const T &first, const Rest &...rest)
19
+ {
20
+ out << first;
21
+ ((out << ", " << rest), ...);
22
+ }
23
+
24
+ }; // namespace detail
25
+
26
+ template <typename... Args>
27
+ Napi::Error sdlError (Napi::Env &env, const char *call, const Args &...args)
28
+ {
29
+ std::ostringstream message;
30
+ message << call << '(';
31
+ detail::streamArgs(message, args...);
32
+ message << ") error: " << SDL_GetError();
33
+ SDL_ClearError();
34
+ return Napi::Error::New(env, message.str());
35
+ }
36
+
37
+ template <typename T>
38
+ T *fromIdOrThrow (Napi::Env &env, T *ptr, const char *call, const char *what, Uint32 id)
39
+ {
40
+ if (ptr != nullptr) { return ptr; }
41
+ std::ostringstream message;
42
+ message << call << '(' << id << ") error: invalid " << what << " id";
43
+ SDL_ClearError();
44
+ throw Napi::Error::New(env, message.str());
45
+ }
46
+
47
+ struct SdlFree { void operator() (void *ptr) const { SDL_free(ptr); } };
48
+ template <typename T> using SdlPtr = std::unique_ptr<T, SdlFree>;
49
+ template <typename T> using SdlArray = std::unique_ptr<T[], SdlFree>;
50
+
51
+ std::recursive_mutex &lock ();
52
+ void assertReady (Napi::Env &env);
53
+ bool isReady ();
54
+ bool isMainThread ();
55
+ void processInitRequests ();
56
+ void teardown ();
57
+
58
+ Napi::Value initialize (const Napi::CallbackInfo &info);
59
+ Napi::Value initSubsystem (const Napi::CallbackInfo &info);
60
+ Napi::Value cleanup (const Napi::CallbackInfo &info);
15
61
 
16
62
  }; // namespace global
17
63