@kmamal/sdl 0.9.5 → 0.9.6-1

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 (57) hide show
  1. package/README.md +111 -103
  2. package/binding.gyp +25 -5
  3. package/package.json +7 -4
  4. package/src/javascript/audio/audio-instance.js +9 -6
  5. package/src/javascript/cleanup.js +1 -1
  6. package/src/javascript/clipboard/index.js +2 -1
  7. package/src/javascript/controller/controller-instance.js +7 -4
  8. package/src/javascript/enums.js +1 -9
  9. package/src/javascript/events/index.js +293 -305
  10. package/src/javascript/index.js +1 -1
  11. package/src/javascript/joystick/device.js +0 -3
  12. package/src/javascript/joystick/joystick-instance.js +8 -6
  13. package/src/javascript/keyboard/index.js +3 -3
  14. package/src/javascript/keyboard/key-mapping.js +14 -6
  15. package/src/javascript/mouse/index.js +14 -13
  16. package/src/javascript/power/index.js +1 -8
  17. package/src/javascript/sensor/sensor-instance.js +1 -5
  18. package/src/javascript/video/index.js +0 -5
  19. package/src/javascript/video/window.js +17 -16
  20. package/src/native/audio.cpp +178 -0
  21. package/src/native/audio.h +21 -0
  22. package/src/native/clipboard.cpp +45 -0
  23. package/src/native/clipboard.h +13 -0
  24. package/src/native/cocoa-global.h +8 -0
  25. package/src/native/cocoa-global.mm +8 -0
  26. package/src/native/cocoa-window.h +9 -4
  27. package/src/native/cocoa-window.mm +6 -9
  28. package/src/native/controller.cpp +160 -0
  29. package/src/native/controller.h +22 -0
  30. package/src/native/enums.cpp +339 -0
  31. package/src/native/enums.h +12 -0
  32. package/src/native/events.cpp +391 -0
  33. package/src/native/events.h +70 -0
  34. package/src/native/global.cpp +361 -0
  35. package/src/native/global.h +15 -0
  36. package/src/native/joystick.cpp +394 -0
  37. package/src/native/joystick.h +29 -0
  38. package/src/native/keyboard.cpp +51 -0
  39. package/src/native/keyboard.h +18 -0
  40. package/src/native/module.cpp +98 -0
  41. package/src/native/mouse.cpp +186 -0
  42. package/src/native/mouse.h +21 -0
  43. package/src/native/power.cpp +23 -0
  44. package/src/native/power.h +17 -0
  45. package/src/native/sensor.cpp +124 -0
  46. package/src/native/sensor.h +21 -0
  47. package/src/native/video.cpp +95 -0
  48. package/src/native/video.h +16 -0
  49. package/src/native/window.cpp +755 -0
  50. package/src/native/window.h +29 -0
  51. package/src/types/index.d.ts +91 -49
  52. package/scripts/test.mjs +0 -12
  53. package/src/native/asprintf.c +0 -47
  54. package/src/native/asprintf.h +0 -37
  55. package/src/native/binding.cpp +0 -1680
  56. package/src/native/sdl-helpers.cpp +0 -2617
  57. package/src/native/sdl-helpers.h +0 -182
@@ -1,1680 +0,0 @@
1
- #include <node_api.h>
2
- #include <cstdlib>
3
- #include <cstdio>
4
- #include <cstdarg>
5
- #include <cstring>
6
- #include "sdl-helpers.h"
7
-
8
- #if defined(_WIN32)
9
- #include "asprintf.h"
10
- #endif
11
-
12
- #define CALL_SDL_HELPER(fn, ...) do { \
13
- SdlHelpers::ErrorMessage * error = SdlHelpers::fn(__VA_ARGS__); \
14
- if (error) { \
15
- napi_throw_error(env, nullptr, error->message); \
16
- delete error; \
17
- goto cleanup; \
18
- } \
19
- } while (0)
20
-
21
-
22
- static napi_status status;
23
-
24
- #define CALL_NAPI(fn, ...) do { \
25
- status = fn(env, __VA_ARGS__); \
26
- if (status != napi_ok) { \
27
- const napi_extended_error_info * error_info; \
28
- napi_get_last_error_info(env, &error_info); \
29
- char * text; \
30
- int length = asprintf(&text, #fn " failed: %s", error_info->error_message); \
31
- napi_throw_error(env, nullptr, length >= 0 ? text : "asprintf failed"); \
32
- goto cleanup; \
33
- } \
34
- } while (0)
35
-
36
-
37
- napi_status
38
- fromVariant(napi_env env, const SdlHelpers::Variant & variant, napi_value * result)
39
- {
40
- status = napi_generic_failure;
41
-
42
- if (std::holds_alternative<std::monostate>(variant)) {
43
- CALL_NAPI(napi_get_null, result);
44
- return napi_ok;
45
- }
46
-
47
- if (std::holds_alternative<SdlHelpers::VariantMap>(variant)) {
48
- CALL_NAPI(napi_create_object, result);
49
-
50
- auto variant_map = std::get<SdlHelpers::VariantMap>(variant);
51
- for (auto it = variant_map.begin(); it != variant_map.end(); ++it) {
52
- napi_value key;
53
- int length = strlen(it->first);
54
- CALL_NAPI(napi_create_string_utf8, it->first, length, &key);
55
-
56
- napi_value value;
57
- CALL_NAPI(fromVariant, it->second, &value);
58
-
59
- CALL_NAPI(napi_set_property, *result, key, value);
60
- }
61
- return napi_ok;
62
- }
63
-
64
- if (std::holds_alternative<SdlHelpers::VariantList>(variant)) {
65
- CALL_NAPI(napi_create_array, result);
66
-
67
- auto variant_list = std::get<SdlHelpers::VariantList>(variant);
68
- for (unsigned i = 0; i < variant_list.size(); ++i) {
69
- napi_value value;
70
- CALL_NAPI(fromVariant, variant_list[i], &value);
71
-
72
- CALL_NAPI(napi_set_element, *result, i, value);
73
- }
74
-
75
- return napi_ok;
76
- }
77
-
78
- if (std::holds_alternative<double>(variant)) {
79
- auto number = std::get<double>(variant);
80
- CALL_NAPI(napi_create_double, number, result);
81
- return napi_ok;
82
- }
83
-
84
- if (std::holds_alternative<const char *>(variant)) {
85
- auto string = std::get<const char *>(variant);
86
- int length = strlen(string);
87
- CALL_NAPI(napi_create_string_utf8, string, length, result);
88
- return napi_ok;
89
- }
90
-
91
- if (std::holds_alternative<bool>(variant)) {
92
- bool flag = std::get<bool>(variant);
93
- CALL_NAPI(napi_create_int32, flag, result);
94
- CALL_NAPI(napi_coerce_to_bool, *result, result);
95
- return napi_ok;
96
- }
97
-
98
- cleanup:
99
- return status;
100
- }
101
-
102
-
103
- void
104
- freePointer(napi_env env, void * data, void * pointer) {
105
- if (pointer) { free(pointer); }
106
- }
107
-
108
-
109
- napi_value
110
- getEnums(napi_env env, napi_callback_info info)
111
- {
112
- napi_value result = nullptr;
113
- napi_value key, value;
114
- CALL_NAPI(napi_create_object, &result);
115
-
116
- {
117
- SdlHelpers::Variant event_families;
118
- CALL_SDL_HELPER(enum_getEventFamilies, event_families);
119
-
120
- CALL_NAPI(fromVariant, event_families, &value);
121
- CALL_NAPI(napi_create_string_latin1, "eventFamily", 11, &key);
122
- CALL_NAPI(napi_set_property, result, key, value);
123
- }
124
-
125
- {
126
- SdlHelpers::Variant event_types;
127
- CALL_SDL_HELPER(enum_getEventTypes, event_types);
128
-
129
- CALL_NAPI(fromVariant, event_types, &value);
130
- CALL_NAPI(napi_create_string_latin1, "eventType", 9, &key);
131
- CALL_NAPI(napi_set_property, result, key, value);
132
- }
133
-
134
- {
135
- SdlHelpers::Variant pixel_formats;
136
- CALL_SDL_HELPER(enum_getPixelFormats, pixel_formats);
137
-
138
- CALL_NAPI(fromVariant, pixel_formats, &value);
139
- CALL_NAPI(napi_create_string_latin1, "pixelFormat", 11, &key);
140
- CALL_NAPI(napi_set_property, result, key, value);
141
- }
142
-
143
- {
144
- SdlHelpers::Variant audio_formats;
145
- CALL_SDL_HELPER(enum_getAudioFormats, audio_formats);
146
-
147
- CALL_NAPI(fromVariant, audio_formats, &value);
148
- CALL_NAPI(napi_create_string_latin1, "audioFormat", 11, &key);
149
- CALL_NAPI(napi_set_property, result, key, value);
150
- }
151
-
152
- {
153
- SdlHelpers::Variant scancodes;
154
- CALL_SDL_HELPER(enum_getScancodes, scancodes);
155
-
156
- CALL_NAPI(fromVariant, scancodes, &value);
157
- CALL_NAPI(napi_create_string_latin1, "scancode", 8, &key);
158
- CALL_NAPI(napi_set_property, result, key, value);
159
- }
160
-
161
- {
162
- SdlHelpers::Variant buttons;
163
- CALL_SDL_HELPER(enum_getMouseButtons, buttons);
164
-
165
- CALL_NAPI(fromVariant, buttons, &value);
166
- CALL_NAPI(napi_create_string_latin1, "button", 6, &key);
167
- CALL_NAPI(napi_set_property, result, key, value);
168
- }
169
-
170
- {
171
- SdlHelpers::Variant cursors;
172
- CALL_SDL_HELPER(enum_getCursors, cursors);
173
-
174
- CALL_NAPI(fromVariant, cursors, &value);
175
- CALL_NAPI(napi_create_string_latin1, "cursor", 6, &key);
176
- CALL_NAPI(napi_set_property, result, key, value);
177
- }
178
-
179
- {
180
- SdlHelpers::Variant hat_positions;
181
- CALL_SDL_HELPER(enum_getHatPositions, hat_positions);
182
-
183
- CALL_NAPI(fromVariant, hat_positions, &value);
184
- CALL_NAPI(napi_create_string_latin1, "hatPosition", 11, &key);
185
- CALL_NAPI(napi_set_property, result, key, value);
186
- }
187
-
188
- {
189
- SdlHelpers::Variant power_levels;
190
- CALL_SDL_HELPER(enum_getPowerLevels, power_levels);
191
-
192
- CALL_NAPI(fromVariant, power_levels, &value);
193
- CALL_NAPI(napi_create_string_latin1, "powerLevel", 10, &key);
194
- CALL_NAPI(napi_set_property, result, key, value);
195
- }
196
-
197
- {
198
- SdlHelpers::Variant joystick_types;
199
- CALL_SDL_HELPER(enum_getJoystickTypes, joystick_types);
200
-
201
- CALL_NAPI(fromVariant, joystick_types, &value);
202
- CALL_NAPI(napi_create_string_latin1, "joystickType", 12, &key);
203
- CALL_NAPI(napi_set_property, result, key, value);
204
- }
205
-
206
- {
207
- SdlHelpers::Variant controller_axes;
208
- CALL_SDL_HELPER(enum_getControllerAxes, controller_axes);
209
-
210
- CALL_NAPI(fromVariant, controller_axes, &value);
211
- CALL_NAPI(napi_create_string_latin1, "controllerAxis", 14, &key);
212
- CALL_NAPI(napi_set_property, result, key, value);
213
- }
214
-
215
- {
216
- SdlHelpers::Variant controller_buttons;
217
- CALL_SDL_HELPER(enum_getControllerButtons, controller_buttons);
218
-
219
- CALL_NAPI(fromVariant, controller_buttons, &value);
220
- CALL_NAPI(napi_create_string_latin1, "controllerButton", 16, &key);
221
- CALL_NAPI(napi_set_property, result, key, value);
222
- }
223
-
224
- {
225
- SdlHelpers::Variant sensor_types;
226
- CALL_SDL_HELPER(enum_getSensorTypes, sensor_types);
227
-
228
- CALL_NAPI(fromVariant, sensor_types, &value);
229
- CALL_NAPI(napi_create_string_latin1, "sensorType", 10, &key);
230
- CALL_NAPI(napi_set_property, result, key, value);
231
- }
232
-
233
- {
234
- SdlHelpers::Variant power_states;
235
- CALL_SDL_HELPER(enum_getPowerStates, power_states);
236
-
237
- CALL_NAPI(fromVariant, power_states, &value);
238
- CALL_NAPI(napi_create_string_latin1, "powerState", 10, &key);
239
- CALL_NAPI(napi_set_property, result, key, value);
240
- }
241
-
242
- cleanup:
243
- return result;
244
- }
245
-
246
- napi_value
247
- initialize(napi_env env, napi_callback_info info)
248
- {
249
- napi_value result = nullptr;
250
-
251
- SdlHelpers::Variant object;
252
- CALL_SDL_HELPER(initialize, object);
253
-
254
- CALL_NAPI(fromVariant, object, &result);
255
-
256
- cleanup:
257
- return result;
258
- }
259
-
260
-
261
- napi_value
262
- events_poll(napi_env env, napi_callback_info info)
263
- {
264
- napi_value result = nullptr;
265
-
266
- SdlHelpers::Variant event;
267
- CALL_SDL_HELPER(events_poll, event);
268
-
269
- CALL_NAPI(fromVariant, event, &result);
270
-
271
- cleanup:
272
- return result;
273
- }
274
-
275
- napi_value
276
- events_wait(napi_env env, napi_callback_info info)
277
- {
278
- napi_value result = nullptr;
279
-
280
- SdlHelpers::Variant event;
281
-
282
- napi_value argv[1];
283
- size_t argc = sizeof(argv) / sizeof(napi_value);
284
- CALL_NAPI(napi_get_cb_info, info, &argc, argv, nullptr, nullptr);
285
-
286
- int timeout;
287
- CALL_NAPI(napi_get_value_int32, argv[0], &timeout);
288
-
289
- CALL_SDL_HELPER(events_wait, timeout, event);
290
-
291
- CALL_NAPI(fromVariant, event, &result);
292
-
293
- cleanup:
294
- return result;
295
- }
296
-
297
-
298
- napi_value
299
- video_getDisplays(napi_env env, napi_callback_info info)
300
- {
301
- napi_value result = nullptr;
302
-
303
- SdlHelpers::Variant displays;
304
- CALL_SDL_HELPER(video_getDisplays, displays);
305
-
306
- CALL_NAPI(fromVariant, displays, &result);
307
-
308
- cleanup:
309
- return result;
310
- }
311
-
312
- napi_value
313
- window_create(napi_env env, napi_callback_info info)
314
- {
315
- napi_value result = nullptr;
316
-
317
- char * title = nullptr;
318
- int * x = nullptr;
319
- int * y = nullptr;
320
- int * width = nullptr;
321
- int * height = nullptr;
322
- void * native_pointer = nullptr;
323
-
324
- napi_value argv[19];
325
- size_t argc = sizeof(argv) / sizeof(napi_value);
326
- CALL_NAPI(napi_get_cb_info, info, &argc, argv, nullptr, nullptr);
327
-
328
- size_t title_length;
329
- CALL_NAPI(napi_get_value_string_utf8, argv[0], nullptr, 0, &title_length);
330
- title = (char *) malloc(title_length + 1);
331
- CALL_NAPI(napi_get_value_string_utf8, argv[0], title, title_length + 1, nullptr);
332
-
333
- int display;
334
- CALL_NAPI(napi_get_value_int32, argv[1], &display);
335
-
336
- napi_valuetype type;
337
-
338
- CALL_NAPI(napi_typeof, argv[2], &type);
339
- if (type != napi_null) {
340
- width = (int *) malloc(sizeof(int));
341
- CALL_NAPI(napi_get_value_int32, argv[2], width);
342
- }
343
-
344
- CALL_NAPI(napi_typeof, argv[3], &type);
345
- if (type != napi_null) {
346
- height = (int *) malloc(sizeof(int));
347
- CALL_NAPI(napi_get_value_int32, argv[3], height);
348
- }
349
-
350
- CALL_NAPI(napi_typeof, argv[4], &type);
351
- if (type != napi_null) {
352
- x = (int *) malloc(sizeof(int));
353
- CALL_NAPI(napi_get_value_int32, argv[4], x);
354
- }
355
-
356
- CALL_NAPI(napi_typeof, argv[5], &type);
357
- if (type != napi_null) {
358
- y = (int *) malloc(sizeof(int));
359
- CALL_NAPI(napi_get_value_int32, argv[5], y);
360
- }
361
-
362
- bool visible, fullscreen, resizable, borderless, always_on_top,
363
- accelerated, vsync, opengl, webgpu,
364
- skip_taskbar, popup_menu, tooltip, utility;
365
- CALL_NAPI(napi_get_value_bool, argv[6], &visible);
366
- CALL_NAPI(napi_get_value_bool, argv[7], &fullscreen);
367
- CALL_NAPI(napi_get_value_bool, argv[8], &resizable);
368
- CALL_NAPI(napi_get_value_bool, argv[9], &borderless);
369
- CALL_NAPI(napi_get_value_bool, argv[10], &always_on_top);
370
- CALL_NAPI(napi_get_value_bool, argv[11], &accelerated);
371
- CALL_NAPI(napi_get_value_bool, argv[12], &vsync);
372
- CALL_NAPI(napi_get_value_bool, argv[13], &opengl);
373
- CALL_NAPI(napi_get_value_bool, argv[14], &webgpu);
374
- CALL_NAPI(napi_get_value_bool, argv[15], &skip_taskbar);
375
- CALL_NAPI(napi_get_value_bool, argv[16], &popup_menu);
376
- CALL_NAPI(napi_get_value_bool, argv[17], &tooltip);
377
- CALL_NAPI(napi_get_value_bool, argv[18], &utility);
378
-
379
- int pixel_width, pixel_height, window_id, native_size;
380
-
381
- CALL_SDL_HELPER(window_create,
382
- title, display,
383
- &x, &y, &width, &height,
384
- &pixel_width, &pixel_height,
385
- visible, &fullscreen, &resizable, &borderless, &always_on_top,
386
- &accelerated, &vsync, opengl, webgpu,
387
- &skip_taskbar, &popup_menu, &tooltip, &utility,
388
- &window_id, &native_pointer, &native_size
389
- );
390
-
391
- napi_value key, value;
392
- CALL_NAPI(napi_create_object, &result);
393
-
394
- CALL_NAPI(napi_create_int32, window_id, &value);
395
- CALL_NAPI(napi_create_string_latin1, "id", 2, &key);
396
- CALL_NAPI(napi_set_property, result, key, value);
397
-
398
- CALL_NAPI(napi_create_int32, *x, &value);
399
- CALL_NAPI(napi_create_string_latin1, "x", 1, &key);
400
- CALL_NAPI(napi_set_property, result, key, value);
401
-
402
- CALL_NAPI(napi_create_int32, *y, &value);
403
- CALL_NAPI(napi_create_string_latin1, "y", 1, &key);
404
- CALL_NAPI(napi_set_property, result, key, value);
405
-
406
- CALL_NAPI(napi_create_int32, *width, &value);
407
- CALL_NAPI(napi_create_string_latin1, "width", 5, &key);
408
- CALL_NAPI(napi_set_property, result, key, value);
409
-
410
- CALL_NAPI(napi_create_int32, *height, &value);
411
- CALL_NAPI(napi_create_string_latin1, "height", 6, &key);
412
- CALL_NAPI(napi_set_property, result, key, value);
413
-
414
- CALL_NAPI(napi_create_int32, pixel_width, &value);
415
- CALL_NAPI(napi_create_string_latin1, "pixelWidth", 10, &key);
416
- CALL_NAPI(napi_set_property, result, key, value);
417
-
418
- CALL_NAPI(napi_create_int32, pixel_height, &value);
419
- CALL_NAPI(napi_create_string_latin1, "pixelHeight", 11, &key);
420
- CALL_NAPI(napi_set_property, result, key, value);
421
-
422
- CALL_NAPI(napi_create_int32, fullscreen, &value);
423
- CALL_NAPI(napi_coerce_to_bool, value, &value);
424
- CALL_NAPI(napi_create_string_latin1, "fullscreen", 10, &key);
425
- CALL_NAPI(napi_set_property, result, key, value);
426
-
427
- CALL_NAPI(napi_create_int32, resizable, &value);
428
- CALL_NAPI(napi_coerce_to_bool, value, &value);
429
- CALL_NAPI(napi_create_string_latin1, "resizable", 9, &key);
430
- CALL_NAPI(napi_set_property, result, key, value);
431
-
432
- CALL_NAPI(napi_create_int32, borderless, &value);
433
- CALL_NAPI(napi_coerce_to_bool, value, &value);
434
- CALL_NAPI(napi_create_string_latin1, "borderless", 10, &key);
435
- CALL_NAPI(napi_set_property, result, key, value);
436
-
437
- CALL_NAPI(napi_create_int32, always_on_top, &value);
438
- CALL_NAPI(napi_coerce_to_bool, value, &value);
439
- CALL_NAPI(napi_create_string_latin1, "alwaysOnTop", 11, &key);
440
- CALL_NAPI(napi_set_property, result, key, value);
441
-
442
- CALL_NAPI(napi_create_int32, accelerated, &value);
443
- CALL_NAPI(napi_coerce_to_bool, value, &value);
444
- CALL_NAPI(napi_create_string_latin1, "accelerated", 11, &key);
445
- CALL_NAPI(napi_set_property, result, key, value);
446
-
447
- CALL_NAPI(napi_create_int32, vsync, &value);
448
- CALL_NAPI(napi_coerce_to_bool, value, &value);
449
- CALL_NAPI(napi_create_string_latin1, "vsync", 5, &key);
450
- CALL_NAPI(napi_set_property, result, key, value);
451
-
452
- CALL_NAPI(napi_create_int32, skip_taskbar, &value);
453
- CALL_NAPI(napi_coerce_to_bool, value, &value);
454
- CALL_NAPI(napi_create_string_latin1, "skipTaskbar", 11, &key);
455
- CALL_NAPI(napi_set_property, result, key, value);
456
-
457
- CALL_NAPI(napi_create_int32, popup_menu, &value);
458
- CALL_NAPI(napi_coerce_to_bool, value, &value);
459
- CALL_NAPI(napi_create_string_latin1, "popupMenu", 9, &key);
460
- CALL_NAPI(napi_set_property, result, key, value);
461
-
462
- CALL_NAPI(napi_create_int32, tooltip, &value);
463
- CALL_NAPI(napi_coerce_to_bool, value, &value);
464
- CALL_NAPI(napi_create_string_latin1, "tooltip", 7, &key);
465
- CALL_NAPI(napi_set_property, result, key, value);
466
-
467
- CALL_NAPI(napi_create_int32, utility, &value);
468
- CALL_NAPI(napi_coerce_to_bool, value, &value);
469
- CALL_NAPI(napi_create_string_latin1, "utility", 7, &key);
470
- CALL_NAPI(napi_set_property, result, key, value);
471
-
472
- if (native_pointer) {
473
- CALL_NAPI(napi_create_external_buffer,
474
- native_size, native_pointer, freePointer, native_pointer,
475
- &value);
476
- CALL_NAPI(napi_create_string_latin1, "native", 6, &key);
477
- CALL_NAPI(napi_set_property, result, key, value);
478
- }
479
-
480
- cleanup:
481
- if (title) { free(title); }
482
- if (x) { free(x); }
483
- if (y) { free(y); }
484
- if (width) { free(width); }
485
- if (height) { free(height); }
486
- return result;
487
- }
488
-
489
- napi_value
490
- window_setTitle(napi_env env, napi_callback_info info)
491
- {
492
- char * title = nullptr;
493
-
494
- napi_value argv[2];
495
- size_t argc = sizeof(argv) / sizeof(napi_value);
496
- CALL_NAPI(napi_get_cb_info, info, &argc, argv, nullptr, nullptr);
497
-
498
- int window_id;
499
- CALL_NAPI(napi_get_value_int32, argv[0], &window_id);
500
-
501
- size_t title_length;
502
- CALL_NAPI(napi_get_value_string_utf8, argv[1], nullptr, 0, &title_length);
503
- title = (char *) malloc(title_length + 1);
504
- CALL_NAPI(napi_get_value_string_utf8, argv[1], title, title_length + 1, nullptr);
505
-
506
- CALL_SDL_HELPER(window_setTitle, window_id, title);
507
-
508
- cleanup:
509
- if (title) { free(title); }
510
- return nullptr;
511
- }
512
-
513
- napi_value
514
- window_setPosition(napi_env env, napi_callback_info info)
515
- {
516
- napi_value argv[3];
517
- size_t argc = sizeof(argv) / sizeof(napi_value);
518
- CALL_NAPI(napi_get_cb_info, info, &argc, argv, nullptr, nullptr);
519
-
520
- int window_id;
521
- CALL_NAPI(napi_get_value_int32, argv[0], &window_id);
522
-
523
- int x, y;
524
- CALL_NAPI(napi_get_value_int32, argv[1], &x);
525
- CALL_NAPI(napi_get_value_int32, argv[2], &y);
526
-
527
- CALL_SDL_HELPER(window_setPosition, window_id, x, y);
528
-
529
- cleanup:
530
- return nullptr;
531
- }
532
-
533
- napi_value
534
- window_setSize(napi_env env, napi_callback_info info)
535
- {
536
- napi_value result = nullptr;
537
-
538
- napi_value argv[3];
539
- size_t argc = sizeof(argv) / sizeof(napi_value);
540
- CALL_NAPI(napi_get_cb_info, info, &argc, argv, nullptr, nullptr);
541
-
542
- int window_id;
543
- CALL_NAPI(napi_get_value_int32, argv[0], &window_id);
544
-
545
- int width, height;
546
- CALL_NAPI(napi_get_value_int32, argv[1], &width);
547
- CALL_NAPI(napi_get_value_int32, argv[2], &height);
548
-
549
- int pixel_width, pixel_height;
550
- CALL_SDL_HELPER(window_setSize,
551
- window_id, width, height,
552
- &pixel_width, &pixel_height
553
- );
554
-
555
- napi_value key, value;
556
- CALL_NAPI(napi_create_object, &result);
557
-
558
- CALL_NAPI(napi_create_int32, pixel_width, &value);
559
- CALL_NAPI(napi_create_string_latin1, "pixelWidth", 10, &key);
560
- CALL_NAPI(napi_set_property, result, key, value);
561
-
562
- CALL_NAPI(napi_create_int32, pixel_height, &value);
563
- CALL_NAPI(napi_create_string_latin1, "pixelHeight", 11, &key);
564
- CALL_NAPI(napi_set_property, result, key, value);
565
-
566
- cleanup:
567
- return result;
568
- }
569
-
570
- napi_value
571
- window_setFullscreen(napi_env env, napi_callback_info info)
572
- {
573
- napi_value result = nullptr;
574
-
575
- napi_value argv[2];
576
- size_t argc = sizeof(argv) / sizeof(napi_value);
577
- CALL_NAPI(napi_get_cb_info, info, &argc, argv, nullptr, nullptr);
578
-
579
- int window_id;
580
- CALL_NAPI(napi_get_value_int32, argv[0], &window_id);
581
-
582
- bool fullscreen;
583
- CALL_NAPI(napi_get_value_bool, argv[1], &fullscreen);
584
-
585
- CALL_SDL_HELPER(window_setFullscreen, window_id, &fullscreen);
586
-
587
- CALL_NAPI(napi_create_int32, fullscreen, &result);
588
- CALL_NAPI(napi_coerce_to_bool, result, &result);
589
-
590
- cleanup:
591
- return result;
592
- }
593
-
594
- napi_value
595
- window_setResizable(napi_env env, napi_callback_info info)
596
- {
597
- napi_value result = nullptr;
598
-
599
- napi_value argv[2];
600
- size_t argc = sizeof(argv) / sizeof(napi_value);
601
- CALL_NAPI(napi_get_cb_info, info, &argc, argv, nullptr, nullptr);
602
-
603
- int window_id;
604
- CALL_NAPI(napi_get_value_int32, argv[0], &window_id);
605
-
606
- bool resizable;
607
- CALL_NAPI(napi_get_value_bool, argv[1], &resizable);
608
-
609
- CALL_SDL_HELPER(window_setResizable, window_id, &resizable);
610
-
611
- CALL_NAPI(napi_create_int32, resizable, &result);
612
- CALL_NAPI(napi_coerce_to_bool, result, &result);
613
-
614
- cleanup:
615
- return result;
616
- }
617
-
618
- napi_value
619
- window_setBorderless(napi_env env, napi_callback_info info)
620
- {
621
- napi_value result = nullptr;
622
-
623
- napi_value argv[2];
624
- size_t argc = sizeof(argv) / sizeof(napi_value);
625
- CALL_NAPI(napi_get_cb_info, info, &argc, argv, nullptr, nullptr);
626
-
627
- int window_id;
628
- CALL_NAPI(napi_get_value_int32, argv[0], &window_id);
629
-
630
- bool borderless;
631
- CALL_NAPI(napi_get_value_bool, argv[1], &borderless);
632
-
633
- CALL_SDL_HELPER(window_setBorderless, window_id, &borderless);
634
-
635
- CALL_NAPI(napi_create_int32, borderless, &result);
636
- CALL_NAPI(napi_coerce_to_bool, result, &result);
637
-
638
- cleanup:
639
- return result;
640
- }
641
-
642
- napi_value
643
- window_setAcceleratedAndVsync(napi_env env, napi_callback_info info)
644
- {
645
- napi_value result = nullptr;
646
-
647
- napi_value argv[3];
648
- size_t argc = sizeof(argv) / sizeof(napi_value);
649
- CALL_NAPI(napi_get_cb_info, info, &argc, argv, nullptr, nullptr);
650
-
651
- int window_id;
652
- CALL_NAPI(napi_get_value_int32, argv[0], &window_id);
653
-
654
- bool accelerated, vsync;
655
- CALL_NAPI(napi_get_value_bool, argv[1], &accelerated);
656
- CALL_NAPI(napi_get_value_bool, argv[2], &vsync);
657
-
658
- CALL_SDL_HELPER(window_setAcceleratedAndVsync, window_id, &accelerated, &vsync);
659
-
660
- CALL_NAPI(napi_create_array, &result);
661
- napi_value value;
662
-
663
- CALL_NAPI(napi_create_int32, accelerated, &value);
664
- CALL_NAPI(napi_coerce_to_bool, value, &value);
665
- CALL_NAPI(napi_set_element, result, 0, value);
666
-
667
- CALL_NAPI(napi_create_int32, vsync, &value);
668
- CALL_NAPI(napi_coerce_to_bool, value, &value);
669
- CALL_NAPI(napi_set_element, result, 1, value);
670
-
671
- cleanup:
672
- return result;
673
- }
674
-
675
- napi_value
676
- window_focus(napi_env env, napi_callback_info info)
677
- {
678
- napi_value argv[1];
679
- size_t argc = sizeof(argv) / sizeof(napi_value);
680
- CALL_NAPI(napi_get_cb_info, info, &argc, argv, nullptr, nullptr);
681
-
682
- int window_id;
683
- CALL_NAPI(napi_get_value_int32, argv[0], &window_id);
684
-
685
- CALL_SDL_HELPER(window_focus, window_id);
686
-
687
- cleanup:
688
- return nullptr;
689
- }
690
-
691
- napi_value
692
- window_show(napi_env env, napi_callback_info info)
693
- {
694
- napi_value argv[1];
695
- size_t argc = sizeof(argv) / sizeof(napi_value);
696
- CALL_NAPI(napi_get_cb_info, info, &argc, argv, nullptr, nullptr);
697
-
698
- int window_id;
699
- CALL_NAPI(napi_get_value_int32, argv[0], &window_id);
700
-
701
- CALL_SDL_HELPER(window_show, window_id);
702
-
703
- cleanup:
704
- return nullptr;
705
- }
706
-
707
- napi_value
708
- window_hide(napi_env env, napi_callback_info info)
709
- {
710
- napi_value argv[1];
711
- size_t argc = sizeof(argv) / sizeof(napi_value);
712
- CALL_NAPI(napi_get_cb_info, info, &argc, argv, nullptr, nullptr);
713
-
714
- int window_id;
715
- CALL_NAPI(napi_get_value_int32, argv[0], &window_id);
716
-
717
- CALL_SDL_HELPER(window_hide, window_id);
718
-
719
- cleanup:
720
- return nullptr;
721
- }
722
-
723
- napi_value
724
- window_maximize(napi_env env, napi_callback_info info)
725
- {
726
- napi_value argv[1];
727
- size_t argc = sizeof(argv) / sizeof(napi_value);
728
- CALL_NAPI(napi_get_cb_info, info, &argc, argv, nullptr, nullptr);
729
-
730
- int window_id;
731
- CALL_NAPI(napi_get_value_int32, argv[0], &window_id);
732
-
733
- CALL_SDL_HELPER(window_maximize, window_id);
734
-
735
- cleanup:
736
- return nullptr;
737
- }
738
-
739
- napi_value
740
- window_minimize(napi_env env, napi_callback_info info)
741
- {
742
- napi_value argv[1];
743
- size_t argc = sizeof(argv) / sizeof(napi_value);
744
- CALL_NAPI(napi_get_cb_info, info, &argc, argv, nullptr, nullptr);
745
-
746
- int window_id;
747
- CALL_NAPI(napi_get_value_int32, argv[0], &window_id);
748
-
749
- CALL_SDL_HELPER(window_minimize, window_id);
750
-
751
- cleanup:
752
- return nullptr;
753
- }
754
-
755
- napi_value
756
- window_restore(napi_env env, napi_callback_info info)
757
- {
758
- napi_value argv[1];
759
- size_t argc = sizeof(argv) / sizeof(napi_value);
760
- CALL_NAPI(napi_get_cb_info, info, &argc, argv, nullptr, nullptr);
761
-
762
- int window_id;
763
- CALL_NAPI(napi_get_value_int32, argv[0], &window_id);
764
-
765
- CALL_SDL_HELPER(window_restore, window_id);
766
-
767
- cleanup:
768
- return nullptr;
769
- }
770
-
771
- napi_value
772
- window_render(napi_env env, napi_callback_info info)
773
- {
774
- napi_value argv[6];
775
- size_t argc = sizeof(argv) / sizeof(napi_value);
776
- CALL_NAPI(napi_get_cb_info, info, &argc, argv, nullptr, nullptr);
777
-
778
- int window_id;
779
- CALL_NAPI(napi_get_value_int32, argv[0], &window_id);
780
-
781
- int w, h, stride;
782
- CALL_NAPI(napi_get_value_int32, argv[1], &w);
783
- CALL_NAPI(napi_get_value_int32, argv[2], &h);
784
- CALL_NAPI(napi_get_value_int32, argv[3], &stride);
785
-
786
- unsigned int format;
787
- CALL_NAPI(napi_get_value_uint32, argv[4], &format);
788
-
789
- void * pixels;
790
- CALL_NAPI(napi_get_buffer_info, argv[5], &pixels, nullptr);
791
-
792
- CALL_SDL_HELPER(window_render, window_id, w, h, stride, format, pixels);
793
-
794
- cleanup:
795
- return nullptr;
796
- }
797
-
798
- napi_value
799
- window_setIcon(napi_env env, napi_callback_info info)
800
- {
801
- napi_value argv[6];
802
- size_t argc = sizeof(argv) / sizeof(napi_value);
803
- CALL_NAPI(napi_get_cb_info, info, &argc, argv, nullptr, nullptr);
804
-
805
- int window_id;
806
- CALL_NAPI(napi_get_value_int32, argv[0], &window_id);
807
-
808
- int w, h, stride;
809
- CALL_NAPI(napi_get_value_int32, argv[1], &w);
810
- CALL_NAPI(napi_get_value_int32, argv[2], &h);
811
- CALL_NAPI(napi_get_value_int32, argv[3], &stride);
812
-
813
- unsigned int format;
814
- CALL_NAPI(napi_get_value_uint32, argv[4], &format);
815
-
816
- void * pixels;
817
- CALL_NAPI(napi_get_buffer_info, argv[5], &pixels, nullptr);
818
-
819
- CALL_SDL_HELPER(window_setIcon, window_id, w, h, stride, format, pixels);
820
-
821
- cleanup:
822
- return nullptr;
823
- }
824
-
825
- napi_value
826
- window_flash(napi_env env, napi_callback_info info)
827
- {
828
- napi_value argv[2];
829
- size_t argc = sizeof(argv) / sizeof(napi_value);
830
- CALL_NAPI(napi_get_cb_info, info, &argc, argv, nullptr, nullptr);
831
-
832
- int window_id;
833
- CALL_NAPI(napi_get_value_int32, argv[0], &window_id);
834
-
835
- int type;
836
- CALL_NAPI(napi_get_value_int32, argv[1], &type);
837
-
838
- CALL_SDL_HELPER(window_flash, window_id, type);
839
-
840
- cleanup:
841
- return nullptr;
842
- }
843
-
844
- napi_value
845
- window_destroy(napi_env env, napi_callback_info info)
846
- {
847
- napi_value argv[1];
848
- size_t argc = sizeof(argv) / sizeof(napi_value);
849
- CALL_NAPI(napi_get_cb_info, info, &argc, argv, nullptr, nullptr);
850
-
851
- int window_id;
852
- CALL_NAPI(napi_get_value_int32, argv[0], &window_id);
853
-
854
- CALL_SDL_HELPER(window_destroy, window_id);
855
-
856
- cleanup:
857
- return nullptr;
858
- }
859
-
860
-
861
- napi_value
862
- keyboard_getKey(napi_env env, napi_callback_info info)
863
- {
864
- napi_value result = nullptr;
865
- const char * key = nullptr;
866
-
867
- napi_value argv[1];
868
- size_t argc = sizeof(argv) / sizeof(napi_value);
869
- CALL_NAPI(napi_get_cb_info, info, &argc, argv, nullptr, nullptr);
870
-
871
- int scancode;
872
- CALL_NAPI(napi_get_value_int32, argv[0], &scancode);
873
-
874
- CALL_SDL_HELPER(keyboard_getKey, scancode, &key);
875
-
876
- if (key) {
877
- CALL_NAPI(napi_create_string_utf8, key, strlen(key), &result);
878
- } else {
879
- CALL_NAPI(napi_get_null, &result);
880
- }
881
-
882
- cleanup:
883
- return result;
884
- }
885
-
886
- napi_value
887
- keyboard_getScancode(napi_env env, napi_callback_info info)
888
- {
889
- napi_value result = nullptr;
890
- char * key = nullptr;
891
-
892
- napi_value argv[1];
893
- size_t argc = sizeof(argv) / sizeof(napi_value);
894
- CALL_NAPI(napi_get_cb_info, info, &argc, argv, nullptr, nullptr);
895
-
896
- size_t key_length;
897
- CALL_NAPI(napi_get_value_string_utf8, argv[0], nullptr, 0, &key_length);
898
- key = (char *) malloc(key_length + 1);
899
- CALL_NAPI(napi_get_value_string_utf8, argv[0], key, key_length + 1, nullptr);
900
-
901
- int scancode;
902
- CALL_SDL_HELPER(keyboard_getScancode, key, &scancode);
903
-
904
- CALL_NAPI(napi_create_uint32, scancode, &result);
905
-
906
- cleanup:
907
- return result;
908
- }
909
-
910
- napi_value
911
- keyboard_getState(napi_env env, napi_callback_info info)
912
- {
913
- napi_value result = nullptr;
914
-
915
- SdlHelpers::Variant state;
916
- CALL_SDL_HELPER(keyboard_getState, state);
917
-
918
- CALL_NAPI(fromVariant, state, &result);
919
-
920
- cleanup:
921
- return result;
922
- }
923
-
924
-
925
- napi_value
926
- mouse_getButton(napi_env env, napi_callback_info info)
927
- {
928
- napi_value result = nullptr;
929
-
930
- napi_value argv[1];
931
- size_t argc = sizeof(argv) / sizeof(napi_value);
932
- CALL_NAPI(napi_get_cb_info, info, &argc, argv, nullptr, nullptr);
933
-
934
- int button;
935
- CALL_NAPI(napi_get_value_int32, argv[0], &button);
936
-
937
- int state;
938
- CALL_SDL_HELPER(mouse_getButton, button, &state);
939
-
940
- CALL_NAPI(napi_create_int32, state, &result);
941
- CALL_NAPI(napi_coerce_to_bool, result, &result);
942
-
943
- cleanup:
944
- return result;
945
- }
946
-
947
- napi_value
948
- mouse_getPosition(napi_env env, napi_callback_info info)
949
- {
950
- napi_value result = nullptr;
951
-
952
- SdlHelpers::Variant position;
953
- CALL_SDL_HELPER(mouse_getPosition, position);
954
-
955
- CALL_NAPI(fromVariant, position, &result);
956
-
957
- cleanup:
958
- return result;
959
- }
960
-
961
- napi_value
962
- mouse_setPosition(napi_env env, napi_callback_info info)
963
- {
964
- napi_value argv[2];
965
- size_t argc = sizeof(argv) / sizeof(napi_value);
966
- CALL_NAPI(napi_get_cb_info, info, &argc, argv, nullptr, nullptr);
967
-
968
- int x, y;
969
- CALL_NAPI(napi_get_value_int32, argv[0], &x);
970
- CALL_NAPI(napi_get_value_int32, argv[1], &y);
971
-
972
- CALL_SDL_HELPER(mouse_setPosition, x, y);
973
-
974
- cleanup:
975
- return nullptr;
976
- }
977
-
978
- napi_value
979
- mouse_capture(napi_env env, napi_callback_info info)
980
- {
981
- napi_value argv[1];
982
- size_t argc = sizeof(argv) / sizeof(napi_value);
983
- CALL_NAPI(napi_get_cb_info, info, &argc, argv, nullptr, nullptr);
984
-
985
- bool capture;
986
- CALL_NAPI(napi_get_value_bool, argv[0], &capture);
987
-
988
- CALL_SDL_HELPER(mouse_capture, capture);
989
-
990
- cleanup:
991
- return nullptr;
992
- }
993
-
994
- napi_value
995
- mouse_setCursor(napi_env env, napi_callback_info info)
996
- {
997
- napi_value argv[1];
998
- size_t argc = sizeof(argv) / sizeof(napi_value);
999
- CALL_NAPI(napi_get_cb_info, info, &argc, argv, nullptr, nullptr);
1000
-
1001
- int cursor_id;
1002
- CALL_NAPI(napi_get_value_int32, argv[0], &cursor_id);
1003
-
1004
- CALL_SDL_HELPER(mouse_setCursor, cursor_id);
1005
-
1006
- cleanup:
1007
- return nullptr;
1008
- }
1009
-
1010
- napi_value
1011
- mouse_setCursorImage(napi_env env, napi_callback_info info)
1012
- {
1013
- napi_value argv[7];
1014
- size_t argc = sizeof(argv) / sizeof(napi_value);
1015
- CALL_NAPI(napi_get_cb_info, info, &argc, argv, nullptr, nullptr);
1016
-
1017
- int w, h, stride;
1018
- CALL_NAPI(napi_get_value_int32, argv[0], &w);
1019
- CALL_NAPI(napi_get_value_int32, argv[1], &h);
1020
- CALL_NAPI(napi_get_value_int32, argv[2], &stride);
1021
-
1022
- unsigned int format;
1023
- CALL_NAPI(napi_get_value_uint32, argv[3], &format);
1024
-
1025
- void * pixels;
1026
- CALL_NAPI(napi_get_buffer_info, argv[4], &pixels, nullptr);
1027
-
1028
- int x, y;
1029
- CALL_NAPI(napi_get_value_int32, argv[5], &x);
1030
- CALL_NAPI(napi_get_value_int32, argv[6], &y);
1031
-
1032
- CALL_SDL_HELPER(mouse_setCursorImage, w, h, stride, format, pixels, x, y);
1033
-
1034
- cleanup:
1035
- return nullptr;
1036
- }
1037
-
1038
- napi_value
1039
- mouse_showCursor(napi_env env, napi_callback_info info)
1040
- {
1041
- napi_value argv[1];
1042
- size_t argc = sizeof(argv) / sizeof(napi_value);
1043
- CALL_NAPI(napi_get_cb_info, info, &argc, argv, nullptr, nullptr);
1044
-
1045
- bool show;
1046
- CALL_NAPI(napi_get_value_bool, argv[0], &show);
1047
-
1048
- CALL_SDL_HELPER(mouse_showCursor, show);
1049
-
1050
- cleanup:
1051
- return nullptr;
1052
- }
1053
-
1054
-
1055
- napi_value
1056
- joystick_getDevices(napi_env env, napi_callback_info info)
1057
- {
1058
- napi_value result = nullptr;
1059
-
1060
- SdlHelpers::Variant devices;
1061
- CALL_SDL_HELPER(joystick_getDevices, devices);
1062
-
1063
- CALL_NAPI(fromVariant, devices, &result);
1064
-
1065
- cleanup:
1066
- return result;
1067
- }
1068
-
1069
- napi_value
1070
- joystick_open(napi_env env, napi_callback_info info)
1071
- {
1072
- napi_value result = nullptr;
1073
-
1074
- SdlHelpers::Variant object;
1075
-
1076
- napi_value argv[1];
1077
- size_t argc = sizeof(argv) / sizeof(napi_value);
1078
- CALL_NAPI(napi_get_cb_info, info, &argc, argv, nullptr, nullptr);
1079
-
1080
- int index;
1081
- CALL_NAPI(napi_get_value_int32, argv[0], &index);
1082
-
1083
- CALL_SDL_HELPER(joystick_open, index, object);
1084
-
1085
- CALL_NAPI(fromVariant, object, &result);
1086
-
1087
- cleanup:
1088
- return result;
1089
- }
1090
-
1091
- napi_value
1092
- joystick_close(napi_env env, napi_callback_info info)
1093
- {
1094
- napi_value argv[1];
1095
- size_t argc = sizeof(argv) / sizeof(napi_value);
1096
- CALL_NAPI(napi_get_cb_info, info, &argc, argv, nullptr, nullptr);
1097
-
1098
- int joystick_id;
1099
- CALL_NAPI(napi_get_value_int32, argv[0], &joystick_id);
1100
-
1101
- CALL_SDL_HELPER(joystick_close, joystick_id);
1102
-
1103
- cleanup:
1104
- return nullptr;
1105
- }
1106
-
1107
- napi_value
1108
- joystick_getPower(napi_env env, napi_callback_info info)
1109
- {
1110
- napi_value result = nullptr;
1111
-
1112
- napi_value argv[1];
1113
- size_t argc = sizeof(argv) / sizeof(napi_value);
1114
- CALL_NAPI(napi_get_cb_info, info, &argc, argv, nullptr, nullptr);
1115
-
1116
- int joystick_id;
1117
- CALL_NAPI(napi_get_value_int32, argv[0], &joystick_id);
1118
-
1119
- int power;
1120
- CALL_SDL_HELPER(joystick_getPower, joystick_id, &power);
1121
-
1122
- CALL_NAPI(napi_create_int32, power, &result);
1123
-
1124
- cleanup:
1125
- return result;
1126
- }
1127
-
1128
- napi_value
1129
- joystick_setLed(napi_env env, napi_callback_info info)
1130
- {
1131
- napi_value result = nullptr;
1132
-
1133
- napi_value argv[4];
1134
- size_t argc = sizeof(argv) / sizeof(napi_value);
1135
- CALL_NAPI(napi_get_cb_info, info, &argc, argv, nullptr, nullptr);
1136
-
1137
- int joystick_id;
1138
- CALL_NAPI(napi_get_value_int32, argv[0], &joystick_id);
1139
-
1140
- double red, green, blue;
1141
- CALL_NAPI(napi_get_value_double, argv[1], &red);
1142
- CALL_NAPI(napi_get_value_double, argv[2], &green);
1143
- CALL_NAPI(napi_get_value_double, argv[3], &blue);
1144
-
1145
- CALL_SDL_HELPER(joystick_setLed, joystick_id, red, green, blue);
1146
-
1147
- cleanup:
1148
- return result;
1149
- }
1150
-
1151
- napi_value
1152
- joystick_setPlayer(napi_env env, napi_callback_info info)
1153
- {
1154
- napi_value result = nullptr;
1155
-
1156
- napi_value argv[2];
1157
- size_t argc = sizeof(argv) / sizeof(napi_value);
1158
- CALL_NAPI(napi_get_cb_info, info, &argc, argv, nullptr, nullptr);
1159
-
1160
- int joystick_id;
1161
- CALL_NAPI(napi_get_value_int32, argv[0], &joystick_id);
1162
-
1163
- int player;
1164
- CALL_NAPI(napi_get_value_int32, argv[1], &player);
1165
-
1166
- CALL_SDL_HELPER(joystick_setPlayer, joystick_id, player);
1167
-
1168
- cleanup:
1169
- return result;
1170
- }
1171
-
1172
- napi_value
1173
- joystick_rumble(napi_env env, napi_callback_info info)
1174
- {
1175
- napi_value result = nullptr;
1176
-
1177
- napi_value argv[4];
1178
- size_t argc = sizeof(argv) / sizeof(napi_value);
1179
- CALL_NAPI(napi_get_cb_info, info, &argc, argv, nullptr, nullptr);
1180
-
1181
- int joystick_id;
1182
- CALL_NAPI(napi_get_value_int32, argv[0], &joystick_id);
1183
-
1184
- double low_freq_rumble, high_freq_rumble, duration;
1185
- CALL_NAPI(napi_get_value_double, argv[1], &low_freq_rumble);
1186
- CALL_NAPI(napi_get_value_double, argv[2], &high_freq_rumble);
1187
- CALL_NAPI(napi_get_value_double, argv[3], &duration);
1188
-
1189
- CALL_SDL_HELPER(joystick_rumble, joystick_id, low_freq_rumble, high_freq_rumble, duration);
1190
-
1191
- cleanup:
1192
- return result;
1193
- }
1194
-
1195
- napi_value
1196
- joystick_rumbleTriggers(napi_env env, napi_callback_info info)
1197
- {
1198
- napi_value result = nullptr;
1199
-
1200
- napi_value argv[4];
1201
- size_t argc = sizeof(argv) / sizeof(napi_value);
1202
- CALL_NAPI(napi_get_cb_info, info, &argc, argv, nullptr, nullptr);
1203
-
1204
- int joystick_id;
1205
- CALL_NAPI(napi_get_value_int32, argv[0], &joystick_id);
1206
-
1207
- double left_rumble, right_rumble, duration;
1208
- CALL_NAPI(napi_get_value_double, argv[1], &left_rumble);
1209
- CALL_NAPI(napi_get_value_double, argv[2], &right_rumble);
1210
- CALL_NAPI(napi_get_value_double, argv[3], &duration);
1211
-
1212
- CALL_SDL_HELPER(joystick_rumbleTriggers, joystick_id, left_rumble, right_rumble, duration);
1213
-
1214
- cleanup:
1215
- return result;
1216
- }
1217
-
1218
-
1219
- napi_value
1220
- controller_open(napi_env env, napi_callback_info info)
1221
- {
1222
- napi_value result = nullptr;
1223
-
1224
- SdlHelpers::Variant device;
1225
-
1226
- napi_value argv[1];
1227
- size_t argc = sizeof(argv) / sizeof(napi_value);
1228
- CALL_NAPI(napi_get_cb_info, info, &argc, argv, nullptr, nullptr);
1229
-
1230
- int index;
1231
- CALL_NAPI(napi_get_value_int32, argv[0], &index);
1232
-
1233
- CALL_SDL_HELPER(controller_open, index, device);
1234
-
1235
- CALL_NAPI(fromVariant, device, &result);
1236
-
1237
- cleanup:
1238
- return result;
1239
- }
1240
-
1241
- napi_value
1242
- controller_close(napi_env env, napi_callback_info info)
1243
- {
1244
- napi_value argv[1];
1245
- size_t argc = sizeof(argv) / sizeof(napi_value);
1246
- CALL_NAPI(napi_get_cb_info, info, &argc, argv, nullptr, nullptr);
1247
-
1248
- int controller_id;
1249
- CALL_NAPI(napi_get_value_int32, argv[0], &controller_id);
1250
-
1251
- CALL_SDL_HELPER(controller_close, controller_id);
1252
-
1253
- cleanup:
1254
- return nullptr;
1255
- }
1256
-
1257
- napi_value
1258
- controller_addMappings(napi_env env, napi_callback_info info)
1259
- {
1260
- char ** mappings = nullptr;
1261
- int num_allocated = 0;
1262
-
1263
- napi_value argv[1];
1264
- size_t argc = sizeof(argv) / sizeof(napi_value);
1265
- CALL_NAPI(napi_get_cb_info, info, &argc, argv, nullptr, nullptr);
1266
-
1267
- unsigned int array_length;
1268
- CALL_NAPI(napi_get_array_length, argv[0], &array_length);
1269
-
1270
- mappings = (char **) malloc(array_length * sizeof(char *));
1271
- napi_value value;
1272
- size_t string_length;
1273
- for (unsigned int i = 0; i < array_length; i++) {
1274
- CALL_NAPI(napi_get_element, argv[0], i, &value);
1275
- CALL_NAPI(napi_get_value_string_utf8, value, nullptr, 0, &string_length);
1276
- mappings[i] = (char *) malloc(string_length + 1);
1277
- num_allocated++;
1278
- CALL_NAPI(napi_get_value_string_utf8, value, mappings[i], string_length + 1, nullptr);
1279
- }
1280
-
1281
- CALL_SDL_HELPER(controller_addMappings, mappings, array_length);
1282
-
1283
- cleanup:
1284
- if (mappings) {
1285
- for (int i = 0; i < num_allocated; i++) { free(mappings[i]); }
1286
- free(mappings);
1287
- }
1288
- return nullptr;
1289
- }
1290
-
1291
-
1292
- napi_value
1293
- sensor_getDevices(napi_env env, napi_callback_info info)
1294
- {
1295
- napi_value result = nullptr;
1296
-
1297
- SdlHelpers::Variant devices;
1298
- CALL_SDL_HELPER(sensor_getDevices, devices);
1299
-
1300
- CALL_NAPI(fromVariant, devices, &result);
1301
-
1302
- cleanup:
1303
- return result;
1304
- }
1305
-
1306
- napi_value
1307
- sensor_open(napi_env env, napi_callback_info info)
1308
- {
1309
- SdlHelpers::Variant object;
1310
-
1311
- napi_value argv[1];
1312
- size_t argc = sizeof(argv) / sizeof(napi_value);
1313
- CALL_NAPI(napi_get_cb_info, info, &argc, argv, nullptr, nullptr);
1314
-
1315
- int index;
1316
- CALL_NAPI(napi_get_value_int32, argv[0], &index);
1317
-
1318
- CALL_SDL_HELPER(sensor_open, index);
1319
-
1320
- cleanup:
1321
- return nullptr;
1322
- }
1323
-
1324
- napi_value
1325
- sensor_getData(napi_env env, napi_callback_info info)
1326
- {
1327
- napi_value result = nullptr;
1328
-
1329
- SdlHelpers::Variant object;
1330
-
1331
- napi_value argv[1];
1332
- size_t argc = sizeof(argv) / sizeof(napi_value);
1333
- CALL_NAPI(napi_get_cb_info, info, &argc, argv, nullptr, nullptr);
1334
-
1335
- int sensor_id;
1336
- CALL_NAPI(napi_get_value_int32, argv[0], &sensor_id);
1337
-
1338
- CALL_SDL_HELPER(sensor_getData, sensor_id, object);
1339
-
1340
- CALL_NAPI(fromVariant, object, &result);
1341
-
1342
- cleanup:
1343
- return result;
1344
- }
1345
-
1346
- napi_value
1347
- sensor_close(napi_env env, napi_callback_info info)
1348
- {
1349
- SdlHelpers::Variant object;
1350
-
1351
- napi_value argv[1];
1352
- size_t argc = sizeof(argv) / sizeof(napi_value);
1353
- CALL_NAPI(napi_get_cb_info, info, &argc, argv, nullptr, nullptr);
1354
-
1355
- int sensor_id;
1356
- CALL_NAPI(napi_get_value_int32, argv[0], &sensor_id);
1357
-
1358
- CALL_SDL_HELPER(sensor_close, sensor_id);
1359
-
1360
- cleanup:
1361
- return nullptr;
1362
- }
1363
-
1364
-
1365
- napi_value
1366
- audio_getDevices(napi_env env, napi_callback_info info)
1367
- {
1368
- napi_value result = nullptr;
1369
- SdlHelpers::Variant devices;
1370
-
1371
- napi_value argv[1];
1372
- size_t argc = sizeof(argv) / sizeof(napi_value);
1373
- CALL_NAPI(napi_get_cb_info, info, &argc, argv, nullptr, nullptr);
1374
-
1375
- bool capture;
1376
- CALL_NAPI(napi_get_value_bool, argv[0], &capture);
1377
-
1378
- CALL_SDL_HELPER(audio_getDevices, capture, devices);
1379
-
1380
- CALL_NAPI(fromVariant, devices, &result);
1381
-
1382
- cleanup:
1383
- return result;
1384
- }
1385
-
1386
- napi_value
1387
- audio_openDevice(napi_env env, napi_callback_info info)
1388
- {
1389
- napi_value result = nullptr;
1390
-
1391
- char * name = nullptr;
1392
-
1393
- napi_value argv[6];
1394
- size_t argc = sizeof(argv) / sizeof(napi_value);
1395
- CALL_NAPI(napi_get_cb_info, info, &argc, argv, nullptr, nullptr);
1396
-
1397
- size_t name_length;
1398
- CALL_NAPI(napi_get_value_string_utf8, argv[0], nullptr, 0, &name_length);
1399
- if (name_length > 0) {
1400
- name = (char *) malloc(name_length + 1);
1401
- CALL_NAPI(napi_get_value_string_utf8, argv[0], name, name_length + 1, nullptr);
1402
- }
1403
-
1404
- bool capture;
1405
- CALL_NAPI(napi_get_value_bool, argv[1], &capture);
1406
-
1407
- int freq, format, channels, samples;
1408
- CALL_NAPI(napi_get_value_int32, argv[2], &freq);
1409
- CALL_NAPI(napi_get_value_int32, argv[3], &format);
1410
- CALL_NAPI(napi_get_value_int32, argv[4], &channels);
1411
- CALL_NAPI(napi_get_value_int32, argv[5], &samples);
1412
-
1413
- int audio_id;
1414
- CALL_SDL_HELPER(audio_openDevice, name, capture, freq, format, channels, samples, &audio_id);
1415
-
1416
- CALL_NAPI(napi_create_uint32, audio_id, &result);
1417
-
1418
- cleanup:
1419
- if (name) { free(name); }
1420
- return result;
1421
- }
1422
-
1423
- napi_value
1424
- audio_close(napi_env env, napi_callback_info info)
1425
- {
1426
- napi_value argv[1];
1427
- size_t argc = sizeof(argv) / sizeof(napi_value);
1428
- CALL_NAPI(napi_get_cb_info, info, &argc, argv, nullptr, nullptr);
1429
-
1430
- int audio_id;
1431
- CALL_NAPI(napi_get_value_int32, argv[0], &audio_id);
1432
-
1433
- CALL_SDL_HELPER(audio_close, audio_id);
1434
-
1435
- cleanup:
1436
- return nullptr;
1437
- }
1438
-
1439
- napi_value
1440
- audio_play(napi_env env, napi_callback_info info)
1441
- {
1442
- napi_value argv[2];
1443
- size_t argc = sizeof(argv) / sizeof(napi_value);
1444
- CALL_NAPI(napi_get_cb_info, info, &argc, argv, nullptr, nullptr);
1445
-
1446
- int audio_id;
1447
- CALL_NAPI(napi_get_value_int32, argv[0], &audio_id);
1448
-
1449
- bool play;
1450
- CALL_NAPI(napi_get_value_bool, argv[1], &play);
1451
-
1452
- CALL_SDL_HELPER(audio_play, audio_id, play);
1453
-
1454
- cleanup:
1455
- return nullptr;
1456
- }
1457
-
1458
- napi_value
1459
- audio_getQueueSize(napi_env env, napi_callback_info info)
1460
- {
1461
- napi_value result = nullptr;
1462
-
1463
- napi_value argv[1];
1464
- size_t argc = sizeof(argv) / sizeof(napi_value);
1465
- CALL_NAPI(napi_get_cb_info, info, &argc, argv, nullptr, nullptr);
1466
-
1467
- int audio_id;
1468
- CALL_NAPI(napi_get_value_int32, argv[0], &audio_id);
1469
-
1470
- unsigned int size;
1471
- CALL_SDL_HELPER(audio_getQueueSize, audio_id, &size);
1472
-
1473
- CALL_NAPI(napi_create_uint32, size, &result);
1474
-
1475
- cleanup:
1476
- return result;
1477
- }
1478
-
1479
- napi_value
1480
- audio_clearQueue(napi_env env, napi_callback_info info)
1481
- {
1482
- napi_value argv[1];
1483
- size_t argc = sizeof(argv) / sizeof(napi_value);
1484
- CALL_NAPI(napi_get_cb_info, info, &argc, argv, nullptr, nullptr);
1485
-
1486
- int audio_id;
1487
- CALL_NAPI(napi_get_value_int32, argv[0], &audio_id);
1488
-
1489
- CALL_SDL_HELPER(audio_clearQueue, audio_id);
1490
-
1491
- cleanup:
1492
- return nullptr;
1493
- }
1494
-
1495
- napi_value
1496
- audio_enqueue(napi_env env, napi_callback_info info)
1497
- {
1498
- napi_value argv[3];
1499
- size_t argc = sizeof(argv) / sizeof(napi_value);
1500
- CALL_NAPI(napi_get_cb_info, info, &argc, argv, nullptr, nullptr);
1501
-
1502
- int audio_id;
1503
- CALL_NAPI(napi_get_value_int32, argv[0], &audio_id);
1504
-
1505
- void * src;
1506
- CALL_NAPI(napi_get_buffer_info, argv[1], &src, nullptr);
1507
-
1508
- int size;
1509
- CALL_NAPI(napi_get_value_int32, argv[2], &size);
1510
-
1511
- CALL_SDL_HELPER(audio_enqueue, audio_id, src, size);
1512
-
1513
- cleanup:
1514
- return nullptr;
1515
- }
1516
-
1517
- napi_value
1518
- audio_dequeue(napi_env env, napi_callback_info info)
1519
- {
1520
- napi_value result = nullptr;
1521
-
1522
- napi_value argv[3];
1523
- size_t argc = sizeof(argv) / sizeof(napi_value);
1524
- CALL_NAPI(napi_get_cb_info, info, &argc, argv, nullptr, nullptr);
1525
-
1526
- int audio_id;
1527
- CALL_NAPI(napi_get_value_int32, argv[0], &audio_id);
1528
-
1529
- void * dst;
1530
- CALL_NAPI(napi_get_buffer_info, argv[1], &dst, nullptr);
1531
-
1532
- int size;
1533
- CALL_NAPI(napi_get_value_int32, argv[2], &size);
1534
-
1535
- int num;
1536
- CALL_SDL_HELPER(audio_dequeue, audio_id, dst, size, &num);
1537
-
1538
- CALL_NAPI(napi_create_uint32, num, &result);
1539
-
1540
- cleanup:
1541
- return result;
1542
- }
1543
-
1544
-
1545
- napi_value
1546
- clipboard_getText(napi_env env, napi_callback_info info)
1547
- {
1548
- napi_value result = nullptr;
1549
-
1550
- const char * text = nullptr;
1551
- CALL_SDL_HELPER(clipboard_getText, &text);
1552
-
1553
- if (!text) { return nullptr; }
1554
-
1555
- CALL_NAPI(napi_create_string_utf8, text, strlen(text), &result);
1556
-
1557
- cleanup:
1558
- return result;
1559
- }
1560
-
1561
- napi_value
1562
- clipboard_setText(napi_env env, napi_callback_info info)
1563
- {
1564
- char * text = nullptr;
1565
-
1566
- napi_value argv[1];
1567
- size_t argc = sizeof(argv) / sizeof(napi_value);
1568
- CALL_NAPI(napi_get_cb_info, info, &argc, argv, nullptr, nullptr);
1569
-
1570
- size_t text_length;
1571
- CALL_NAPI(napi_get_value_string_utf8, argv[0], nullptr, 0, &text_length);
1572
- text = (char *) malloc(text_length + 1);
1573
- CALL_NAPI(napi_get_value_string_utf8, argv[0], text, text_length + 1, nullptr);
1574
-
1575
- CALL_SDL_HELPER(clipboard_setText, text);
1576
-
1577
- cleanup:
1578
- if (text) { free(text); }
1579
- return nullptr;
1580
- }
1581
-
1582
-
1583
- napi_value
1584
- power_getInfo(napi_env env, napi_callback_info info)
1585
- {
1586
- napi_value result = nullptr;
1587
-
1588
- SdlHelpers::Variant power;
1589
- CALL_SDL_HELPER(power_getInfo, power);
1590
-
1591
- CALL_NAPI(fromVariant, power, &result);
1592
-
1593
- cleanup:
1594
- return result;
1595
- }
1596
-
1597
-
1598
- napi_value
1599
- cleanup(napi_env env, napi_callback_info info)
1600
- {
1601
- CALL_SDL_HELPER(cleanup);
1602
-
1603
- cleanup:
1604
- return nullptr;
1605
- }
1606
-
1607
-
1608
- napi_value
1609
- init (napi_env env, napi_value exports)
1610
- {
1611
- napi_property_descriptor desc[] = {
1612
- { "getEnums", NULL, getEnums, NULL, NULL, NULL, napi_enumerable, NULL },
1613
- { "initialize", NULL, initialize, NULL, NULL, NULL, napi_enumerable, NULL },
1614
- { "events_poll", NULL, events_poll, NULL, NULL, NULL, napi_enumerable, NULL },
1615
- { "events_wait", NULL, events_wait, NULL, NULL, NULL, napi_enumerable, NULL },
1616
- { "video_getDisplays", NULL, video_getDisplays, NULL, NULL, NULL, napi_enumerable, NULL },
1617
- { "window_create", NULL, window_create, NULL, NULL, NULL, napi_enumerable, NULL },
1618
- { "window_setTitle", NULL, window_setTitle, NULL, NULL, NULL, napi_enumerable, NULL },
1619
- { "window_setPosition", NULL, window_setPosition, NULL, NULL, NULL, napi_enumerable, NULL },
1620
- { "window_setSize", NULL, window_setSize, NULL, NULL, NULL, napi_enumerable, NULL },
1621
- { "window_setFullscreen", NULL, window_setFullscreen, NULL, NULL, NULL, napi_enumerable, NULL },
1622
- { "window_setResizable", NULL, window_setResizable, NULL, NULL, NULL, napi_enumerable, NULL },
1623
- { "window_setBorderless", NULL, window_setBorderless, NULL, NULL, NULL, napi_enumerable, NULL },
1624
- { "window_setAcceleratedAndVsync", NULL, window_setAcceleratedAndVsync, NULL, NULL, NULL, napi_enumerable, NULL },
1625
- { "window_focus", NULL, window_focus, NULL, NULL, NULL, napi_enumerable, NULL },
1626
- { "window_show", NULL, window_show, NULL, NULL, NULL, napi_enumerable, NULL },
1627
- { "window_hide", NULL, window_hide, NULL, NULL, NULL, napi_enumerable, NULL },
1628
- { "window_maximize", NULL, window_maximize, NULL, NULL, NULL, napi_enumerable, NULL },
1629
- { "window_minimize", NULL, window_minimize, NULL, NULL, NULL, napi_enumerable, NULL },
1630
- { "window_restore", NULL, window_restore, NULL, NULL, NULL, napi_enumerable, NULL },
1631
- { "window_render", NULL, window_render, NULL, NULL, NULL, napi_enumerable, NULL },
1632
- { "window_setIcon", NULL, window_setIcon, NULL, NULL, NULL, napi_enumerable, NULL },
1633
- { "window_flash", NULL, window_flash, NULL, NULL, NULL, napi_enumerable, NULL },
1634
- { "window_destroy", NULL, window_destroy, NULL, NULL, NULL, napi_enumerable, NULL },
1635
- { "keyboard_getKey", NULL, keyboard_getKey, NULL, NULL, NULL, napi_enumerable, NULL },
1636
- { "keyboard_getScancode", NULL, keyboard_getScancode, NULL, NULL, NULL, napi_enumerable, NULL },
1637
- { "keyboard_getState", NULL, keyboard_getState, NULL, NULL, NULL, napi_enumerable, NULL },
1638
- { "mouse_getButton", NULL, mouse_getButton, NULL, NULL, NULL, napi_enumerable, NULL },
1639
- { "mouse_getPosition", NULL, mouse_getPosition, NULL, NULL, NULL, napi_enumerable, NULL },
1640
- { "mouse_setPosition", NULL, mouse_setPosition, NULL, NULL, NULL, napi_enumerable, NULL },
1641
- { "mouse_capture", NULL, mouse_capture, NULL, NULL, NULL, napi_enumerable, NULL },
1642
- { "mouse_setCursor", NULL, mouse_setCursor, NULL, NULL, NULL, napi_enumerable, NULL },
1643
- { "mouse_setCursorImage", NULL, mouse_setCursorImage, NULL, NULL, NULL, napi_enumerable, NULL },
1644
- { "mouse_showCursor", NULL, mouse_showCursor, NULL, NULL, NULL, napi_enumerable, NULL },
1645
- { "joystick_getDevices", NULL, joystick_getDevices, NULL, NULL, NULL, napi_enumerable, NULL },
1646
- { "joystick_open", NULL, joystick_open, NULL, NULL, NULL, napi_enumerable, NULL },
1647
- { "joystick_close", NULL, joystick_close, NULL, NULL, NULL, napi_enumerable, NULL },
1648
- { "joystick_getPower", NULL, joystick_getPower, NULL, NULL, NULL, napi_enumerable, NULL },
1649
- { "joystick_setLed", NULL, joystick_setLed, NULL, NULL, NULL, napi_enumerable, NULL },
1650
- { "joystick_setPlayer", NULL, joystick_setPlayer, NULL, NULL, NULL, napi_enumerable, NULL },
1651
- { "joystick_rumble", NULL, joystick_rumble, NULL, NULL, NULL, napi_enumerable, NULL },
1652
- { "joystick_rumbleTriggers", NULL, joystick_rumbleTriggers, NULL, NULL, NULL, napi_enumerable, NULL },
1653
- { "controller_open", NULL, controller_open, NULL, NULL, NULL, napi_enumerable, NULL },
1654
- { "controller_close", NULL, controller_close, NULL, NULL, NULL, napi_enumerable, NULL },
1655
- { "controller_addMappings", NULL, controller_addMappings, NULL, NULL, NULL, napi_enumerable, NULL },
1656
- { "sensor_getDevices", NULL, sensor_getDevices, NULL, NULL, NULL, napi_enumerable, NULL },
1657
- { "sensor_open", NULL, sensor_open, NULL, NULL, NULL, napi_enumerable, NULL },
1658
- { "sensor_getData", NULL, sensor_getData, NULL, NULL, NULL, napi_enumerable, NULL },
1659
- { "sensor_close", NULL, sensor_close, NULL, NULL, NULL, napi_enumerable, NULL },
1660
- { "audio_getDevices", NULL, audio_getDevices, NULL, NULL, NULL, napi_enumerable, NULL },
1661
- { "audio_openDevice", NULL, audio_openDevice, NULL, NULL, NULL, napi_enumerable, NULL },
1662
- { "audio_close", NULL, audio_close, NULL, NULL, NULL, napi_enumerable, NULL },
1663
- { "audio_play", NULL, audio_play, NULL, NULL, NULL, napi_enumerable, NULL },
1664
- { "audio_getQueueSize", NULL, audio_getQueueSize, NULL, NULL, NULL, napi_enumerable, NULL },
1665
- { "audio_enqueue", NULL, audio_enqueue, NULL, NULL, NULL, napi_enumerable, NULL },
1666
- { "audio_dequeue", NULL, audio_dequeue, NULL, NULL, NULL, napi_enumerable, NULL },
1667
- { "audio_clearQueue", NULL, audio_clearQueue, NULL, NULL, NULL, napi_enumerable, NULL },
1668
- { "clipboard_getText", NULL, clipboard_getText, NULL, NULL, NULL, napi_enumerable, NULL },
1669
- { "clipboard_setText", NULL, clipboard_setText, NULL, NULL, NULL, napi_enumerable, NULL },
1670
- { "power_getInfo", NULL, power_getInfo, NULL, NULL, NULL, napi_enumerable, NULL },
1671
- { "cleanup", NULL, cleanup, NULL, NULL, NULL, napi_enumerable, NULL }
1672
- };
1673
-
1674
- CALL_NAPI(napi_define_properties, exports, 60, desc);
1675
-
1676
- cleanup:
1677
- return exports;
1678
- }
1679
-
1680
- NAPI_MODULE(NODE_GYP_MODULE_NAME, init)