@kmamal/sdl 0.5.0 → 0.6.0

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.
@@ -51,7 +51,7 @@ fromVariant(napi_env env, const SdlHelpers::Variant & variant, napi_value * resu
51
51
  for (auto it = variant_map.begin(); it != variant_map.end(); ++it) {
52
52
  napi_value key;
53
53
  int length = strlen(it->first);
54
- CALL_NAPI(napi_create_string_latin1, it->first, length, &key);
54
+ CALL_NAPI(napi_create_string_utf8, it->first, length, &key);
55
55
 
56
56
  napi_value value;
57
57
  CALL_NAPI(fromVariant, it->second, &value);
@@ -102,8 +102,7 @@ fromVariant(napi_env env, const SdlHelpers::Variant & variant, napi_value * resu
102
102
 
103
103
  void
104
104
  freePointer(napi_env env, void * data, void * pointer) {
105
- if (!pointer) { return; }
106
- free(pointer);
105
+ if (pointer) { free(pointer); }
107
106
  }
108
107
 
109
108
 
@@ -114,6 +113,24 @@ getEnums(napi_env env, napi_callback_info info)
114
113
  napi_value key, value;
115
114
  CALL_NAPI(napi_create_object, &result);
116
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
+
117
134
  {
118
135
  SdlHelpers::Variant pixel_formats;
119
136
  CALL_SDL_HELPER(enum_getPixelFormats, pixel_formats);
@@ -177,6 +194,33 @@ getEnums(napi_env env, napi_callback_info info)
177
194
  CALL_NAPI(napi_set_property, result, key, value);
178
195
  }
179
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
+
180
224
  cleanup:
181
225
  return result;
182
226
  }
@@ -195,13 +239,41 @@ initialize(napi_env env, napi_callback_info info)
195
239
  return result;
196
240
  }
197
241
 
242
+
198
243
  napi_value
199
- cleanup(napi_env env, napi_callback_info info)
244
+ events_poll(napi_env env, napi_callback_info info)
200
245
  {
201
- CALL_SDL_HELPER(cleanup);
246
+ napi_value result = nullptr;
247
+
248
+ SdlHelpers::Variant event;
249
+ CALL_SDL_HELPER(events_poll, event);
250
+
251
+ CALL_NAPI(fromVariant, event, &result);
202
252
 
203
253
  cleanup:
204
- return nullptr;
254
+ return result;
255
+ }
256
+
257
+ napi_value
258
+ events_wait(napi_env env, napi_callback_info info)
259
+ {
260
+ napi_value result = nullptr;
261
+
262
+ SdlHelpers::Variant event;
263
+
264
+ napi_value argv[1];
265
+ size_t argc = sizeof(argv) / sizeof(napi_value);
266
+ CALL_NAPI(napi_get_cb_info, info, &argc, argv, nullptr, nullptr);
267
+
268
+ int timeout;
269
+ CALL_NAPI(napi_get_value_int32, argv[0], &timeout);
270
+
271
+ CALL_SDL_HELPER(events_wait, timeout, event);
272
+
273
+ CALL_NAPI(fromVariant, event, &result);
274
+
275
+ cleanup:
276
+ return result;
205
277
  }
206
278
 
207
279
 
@@ -236,9 +308,9 @@ window_create(napi_env env, napi_callback_info info)
236
308
  CALL_NAPI(napi_get_cb_info, info, &argc, argv, nullptr, nullptr);
237
309
 
238
310
  size_t title_length;
239
- CALL_NAPI(napi_get_value_string_latin1, argv[0], nullptr, 0, &title_length);
311
+ CALL_NAPI(napi_get_value_string_utf8, argv[0], nullptr, 0, &title_length);
240
312
  title = (char *) malloc(title_length + 1);
241
- CALL_NAPI(napi_get_value_string_latin1, argv[0], title, title_length + 1, nullptr);
313
+ CALL_NAPI(napi_get_value_string_utf8, argv[0], title, title_length + 1, nullptr);
242
314
 
243
315
  int display;
244
316
  CALL_NAPI(napi_get_value_int32, argv[1], &display);
@@ -344,11 +416,11 @@ window_create(napi_env env, napi_callback_info info)
344
416
  }
345
417
 
346
418
  cleanup:
347
- free(title);
348
- free(x);
349
- free(y);
350
- free(width);
351
- free(height);
419
+ if (title) { free(title); }
420
+ if (x) { free(x); }
421
+ if (y) { free(y); }
422
+ if (width) { free(width); }
423
+ if (height) { free(height); }
352
424
  return result;
353
425
  }
354
426
 
@@ -365,14 +437,14 @@ window_setTitle(napi_env env, napi_callback_info info)
365
437
  CALL_NAPI(napi_get_value_int32, argv[0], &window_id);
366
438
 
367
439
  size_t title_length;
368
- CALL_NAPI(napi_get_value_string_latin1, argv[1], nullptr, 0, &title_length);
440
+ CALL_NAPI(napi_get_value_string_utf8, argv[1], nullptr, 0, &title_length);
369
441
  title = (char *) malloc(title_length + 1);
370
- CALL_NAPI(napi_get_value_string_latin1, argv[1], title, title_length + 1, nullptr);
442
+ CALL_NAPI(napi_get_value_string_utf8, argv[1], title, title_length + 1, nullptr);
371
443
 
372
444
  CALL_SDL_HELPER(window_setTitle, window_id, title);
373
445
 
374
446
  cleanup:
375
- free(title);
447
+ if (title) { free(title); }
376
448
  return nullptr;
377
449
  }
378
450
 
@@ -689,468 +761,531 @@ window_destroy(napi_env env, napi_callback_info info)
689
761
 
690
762
 
691
763
  napi_value
692
- audio_getDevices(napi_env env, napi_callback_info info)
764
+ keyboard_getKey(napi_env env, napi_callback_info info)
693
765
  {
694
766
  napi_value result = nullptr;
695
- SdlHelpers::Variant devices;
767
+ const char * key = nullptr;
696
768
 
697
769
  napi_value argv[1];
698
770
  size_t argc = sizeof(argv) / sizeof(napi_value);
699
771
  CALL_NAPI(napi_get_cb_info, info, &argc, argv, nullptr, nullptr);
700
772
 
701
- bool capture;
702
- CALL_NAPI(napi_get_value_bool, argv[0], &capture);
773
+ int scancode;
774
+ CALL_NAPI(napi_get_value_int32, argv[0], &scancode);
703
775
 
704
- CALL_SDL_HELPER(audio_getDevices, capture, devices);
776
+ CALL_SDL_HELPER(keyboard_getKey, scancode, &key);
705
777
 
706
- CALL_NAPI(fromVariant, devices, &result);
778
+ if (key) {
779
+ CALL_NAPI(napi_create_string_utf8, key, strlen(key), &result);
780
+ } else {
781
+ CALL_NAPI(napi_get_null, &result);
782
+ }
707
783
 
708
784
  cleanup:
709
785
  return result;
710
786
  }
711
787
 
712
788
  napi_value
713
- audio_openDevice(napi_env env, napi_callback_info info)
789
+ keyboard_getScancode(napi_env env, napi_callback_info info)
714
790
  {
715
791
  napi_value result = nullptr;
792
+ char * key = nullptr;
716
793
 
717
- char * name = nullptr;
718
-
719
- napi_value argv[6];
794
+ napi_value argv[1];
720
795
  size_t argc = sizeof(argv) / sizeof(napi_value);
721
796
  CALL_NAPI(napi_get_cb_info, info, &argc, argv, nullptr, nullptr);
722
797
 
723
- size_t name_length;
724
- CALL_NAPI(napi_get_value_string_latin1, argv[0], nullptr, 0, &name_length);
725
- name = (char *) malloc(name_length + 1);
726
- CALL_NAPI(napi_get_value_string_latin1, argv[0], name, name_length + 1, nullptr);
798
+ size_t key_length;
799
+ CALL_NAPI(napi_get_value_string_utf8, argv[0], nullptr, 0, &key_length);
800
+ key = (char *) malloc(key_length + 1);
801
+ CALL_NAPI(napi_get_value_string_utf8, argv[0], key, key_length + 1, nullptr);
727
802
 
728
- bool capture;
729
- CALL_NAPI(napi_get_value_bool, argv[1], &capture);
803
+ int scancode;
804
+ CALL_SDL_HELPER(keyboard_getScancode, key, &scancode);
730
805
 
731
- int freq, format, channels, samples;
732
- CALL_NAPI(napi_get_value_int32, argv[2], &freq);
733
- CALL_NAPI(napi_get_value_int32, argv[3], &format);
734
- CALL_NAPI(napi_get_value_int32, argv[4], &channels);
735
- CALL_NAPI(napi_get_value_int32, argv[5], &samples);
806
+ CALL_NAPI(napi_create_uint32, scancode, &result);
736
807
 
737
- int device_id;
738
- CALL_SDL_HELPER(audio_openDevice, name, capture, freq, format, channels, samples, &device_id);
808
+ cleanup:
809
+ return result;
810
+ }
739
811
 
740
- CALL_NAPI(napi_create_uint32, device_id, &result);
812
+ napi_value
813
+ keyboard_getState(napi_env env, napi_callback_info info)
814
+ {
815
+ napi_value result = nullptr;
816
+
817
+ SdlHelpers::Variant state;
818
+ CALL_SDL_HELPER(keyboard_getState, state);
819
+
820
+ CALL_NAPI(fromVariant, state, &result);
741
821
 
742
822
  cleanup:
743
- free(name);
744
823
  return result;
745
824
  }
746
825
 
826
+
747
827
  napi_value
748
- audio_close(napi_env env, napi_callback_info info)
828
+ mouse_getButton(napi_env env, napi_callback_info info)
749
829
  {
830
+ napi_value result = nullptr;
831
+
750
832
  napi_value argv[1];
751
833
  size_t argc = sizeof(argv) / sizeof(napi_value);
752
834
  CALL_NAPI(napi_get_cb_info, info, &argc, argv, nullptr, nullptr);
753
835
 
754
- int device_id;
755
- CALL_NAPI(napi_get_value_int32, argv[0], &device_id);
836
+ int button;
837
+ CALL_NAPI(napi_get_value_int32, argv[0], &button);
838
+
839
+ int state;
840
+ CALL_SDL_HELPER(mouse_getButton, button, &state);
841
+
842
+ CALL_NAPI(napi_create_int32, state, &result);
843
+ CALL_NAPI(napi_coerce_to_bool, result, &result);
844
+
845
+ cleanup:
846
+ return result;
847
+ }
848
+
849
+ napi_value
850
+ mouse_getPosition(napi_env env, napi_callback_info info)
851
+ {
852
+ napi_value result = nullptr;
853
+
854
+ SdlHelpers::Variant position;
855
+ CALL_SDL_HELPER(mouse_getPosition, position);
756
856
 
757
- CALL_SDL_HELPER(audio_close, device_id);
857
+ CALL_NAPI(fromVariant, position, &result);
758
858
 
759
859
  cleanup:
760
- return nullptr;
860
+ return result;
761
861
  }
762
862
 
763
863
  napi_value
764
- audio_play(napi_env env, napi_callback_info info)
864
+ mouse_setPosition(napi_env env, napi_callback_info info)
765
865
  {
766
866
  napi_value argv[2];
767
867
  size_t argc = sizeof(argv) / sizeof(napi_value);
768
868
  CALL_NAPI(napi_get_cb_info, info, &argc, argv, nullptr, nullptr);
769
869
 
770
- int device_id;
771
- CALL_NAPI(napi_get_value_int32, argv[0], &device_id);
772
-
773
- bool play;
774
- CALL_NAPI(napi_get_value_bool, argv[1], &play);
870
+ int x, y;
871
+ CALL_NAPI(napi_get_value_int32, argv[0], &x);
872
+ CALL_NAPI(napi_get_value_int32, argv[1], &y);
775
873
 
776
- CALL_SDL_HELPER(audio_play, device_id, play);
874
+ CALL_SDL_HELPER(mouse_setPosition, x, y);
777
875
 
778
876
  cleanup:
779
877
  return nullptr;
780
878
  }
781
879
 
782
880
  napi_value
783
- audio_getQueueSize(napi_env env, napi_callback_info info)
881
+ mouse_capture(napi_env env, napi_callback_info info)
784
882
  {
785
- napi_value result = nullptr;
786
-
787
883
  napi_value argv[1];
788
884
  size_t argc = sizeof(argv) / sizeof(napi_value);
789
885
  CALL_NAPI(napi_get_cb_info, info, &argc, argv, nullptr, nullptr);
790
886
 
791
- int device_id;
792
- CALL_NAPI(napi_get_value_int32, argv[0], &device_id);
793
-
794
- unsigned int size;
795
- CALL_SDL_HELPER(audio_getQueueSize, device_id, &size);
887
+ bool capture;
888
+ CALL_NAPI(napi_get_value_bool, argv[0], &capture);
796
889
 
797
- CALL_NAPI(napi_create_uint32, size, &result);
890
+ CALL_SDL_HELPER(mouse_capture, capture);
798
891
 
799
892
  cleanup:
800
- return result;
893
+ return nullptr;
801
894
  }
802
895
 
803
896
  napi_value
804
- audio_clearQueue(napi_env env, napi_callback_info info)
897
+ mouse_setCursor(napi_env env, napi_callback_info info)
805
898
  {
806
899
  napi_value argv[1];
807
900
  size_t argc = sizeof(argv) / sizeof(napi_value);
808
901
  CALL_NAPI(napi_get_cb_info, info, &argc, argv, nullptr, nullptr);
809
902
 
810
- int device_id;
811
- CALL_NAPI(napi_get_value_int32, argv[0], &device_id);
903
+ int cursor_id;
904
+ CALL_NAPI(napi_get_value_int32, argv[0], &cursor_id);
812
905
 
813
- CALL_SDL_HELPER(audio_clearQueue, device_id);
906
+ CALL_SDL_HELPER(mouse_setCursor, cursor_id);
814
907
 
815
908
  cleanup:
816
909
  return nullptr;
817
910
  }
818
911
 
819
912
  napi_value
820
- audio_enqueue(napi_env env, napi_callback_info info)
913
+ mouse_setCursorImage(napi_env env, napi_callback_info info)
821
914
  {
822
- napi_value argv[3];
915
+ napi_value argv[7];
823
916
  size_t argc = sizeof(argv) / sizeof(napi_value);
824
917
  CALL_NAPI(napi_get_cb_info, info, &argc, argv, nullptr, nullptr);
825
918
 
826
- int device_id;
827
- CALL_NAPI(napi_get_value_int32, argv[0], &device_id);
919
+ int w, h, stride;
920
+ CALL_NAPI(napi_get_value_int32, argv[0], &w);
921
+ CALL_NAPI(napi_get_value_int32, argv[1], &h);
922
+ CALL_NAPI(napi_get_value_int32, argv[2], &stride);
828
923
 
829
- void * src;
830
- CALL_NAPI(napi_get_buffer_info, argv[1], &src, nullptr);
924
+ unsigned int format;
925
+ CALL_NAPI(napi_get_value_uint32, argv[3], &format);
831
926
 
832
- int size;
833
- CALL_NAPI(napi_get_value_int32, argv[2], &size);
927
+ void * pixels;
928
+ CALL_NAPI(napi_get_buffer_info, argv[4], &pixels, nullptr);
929
+
930
+ int x, y;
931
+ CALL_NAPI(napi_get_value_int32, argv[5], &x);
932
+ CALL_NAPI(napi_get_value_int32, argv[6], &y);
834
933
 
835
- CALL_SDL_HELPER(audio_enqueue, device_id, src, size);
934
+ CALL_SDL_HELPER(mouse_setCursorImage, w, h, stride, format, pixels, x, y);
836
935
 
837
936
  cleanup:
838
937
  return nullptr;
839
938
  }
840
939
 
841
940
  napi_value
842
- audio_dequeue(napi_env env, napi_callback_info info)
941
+ mouse_showCursor(napi_env env, napi_callback_info info)
843
942
  {
844
- napi_value result = nullptr;
845
-
846
- napi_value argv[3];
943
+ napi_value argv[1];
847
944
  size_t argc = sizeof(argv) / sizeof(napi_value);
848
945
  CALL_NAPI(napi_get_cb_info, info, &argc, argv, nullptr, nullptr);
849
946
 
850
- int device_id;
851
- CALL_NAPI(napi_get_value_int32, argv[0], &device_id);
852
-
853
- void * dst;
854
- CALL_NAPI(napi_get_buffer_info, argv[1], &dst, nullptr);
855
-
856
- int size;
857
- CALL_NAPI(napi_get_value_int32, argv[2], &size);
858
-
859
- int num;
860
- CALL_SDL_HELPER(audio_dequeue, device_id, dst, size, &num);
947
+ bool show;
948
+ CALL_NAPI(napi_get_value_bool, argv[0], &show);
861
949
 
862
- CALL_NAPI(napi_create_uint32, num, &result);
950
+ CALL_SDL_HELPER(mouse_showCursor, show);
863
951
 
864
952
  cleanup:
865
- return result;
953
+ return nullptr;
866
954
  }
867
955
 
868
956
 
869
957
  napi_value
870
- events_poll(napi_env env, napi_callback_info info)
958
+ joystick_getDevices(napi_env env, napi_callback_info info)
871
959
  {
872
960
  napi_value result = nullptr;
873
961
 
874
- SdlHelpers::Variant event;
875
- CALL_SDL_HELPER(events_poll, event);
962
+ SdlHelpers::Variant devices;
963
+ CALL_SDL_HELPER(joystick_getDevices, devices);
876
964
 
877
- CALL_NAPI(fromVariant, event, &result);
965
+ CALL_NAPI(fromVariant, devices, &result);
878
966
 
879
967
  cleanup:
880
968
  return result;
881
969
  }
882
970
 
883
971
  napi_value
884
- events_wait(napi_env env, napi_callback_info info)
972
+ joystick_open(napi_env env, napi_callback_info info)
885
973
  {
886
974
  napi_value result = nullptr;
887
975
 
888
- SdlHelpers::Variant event;
976
+ SdlHelpers::Variant object;
889
977
 
890
978
  napi_value argv[1];
891
979
  size_t argc = sizeof(argv) / sizeof(napi_value);
892
980
  CALL_NAPI(napi_get_cb_info, info, &argc, argv, nullptr, nullptr);
893
981
 
894
- int timeout;
895
- CALL_NAPI(napi_get_value_int32, argv[0], &timeout);
982
+ int index;
983
+ CALL_NAPI(napi_get_value_int32, argv[0], &index);
896
984
 
897
- CALL_SDL_HELPER(events_wait, timeout, event);
985
+ CALL_SDL_HELPER(joystick_open, index, object);
898
986
 
899
- CALL_NAPI(fromVariant, event, &result);
987
+ CALL_NAPI(fromVariant, object, &result);
900
988
 
901
989
  cleanup:
902
990
  return result;
903
991
  }
904
992
 
905
993
  napi_value
906
- keyboard_getKey(napi_env env, napi_callback_info info)
994
+ joystick_close(napi_env env, napi_callback_info info)
907
995
  {
908
- napi_value result = nullptr;
909
- const char * key = nullptr;
910
-
911
996
  napi_value argv[1];
912
997
  size_t argc = sizeof(argv) / sizeof(napi_value);
913
998
  CALL_NAPI(napi_get_cb_info, info, &argc, argv, nullptr, nullptr);
914
999
 
915
- int scancode;
916
- CALL_NAPI(napi_get_value_int32, argv[0], &scancode);
917
-
918
- CALL_SDL_HELPER(keyboard_getKey, scancode, &key);
1000
+ int joystick_id;
1001
+ CALL_NAPI(napi_get_value_int32, argv[0], &joystick_id);
919
1002
 
920
- if (key) {
921
- CALL_NAPI(napi_create_string_utf8, key, strlen(key), &result);
922
- } else {
923
- CALL_NAPI(napi_get_null, &result);
924
- }
1003
+ CALL_SDL_HELPER(joystick_close, joystick_id);
925
1004
 
926
1005
  cleanup:
927
- return result;
1006
+ return nullptr;
928
1007
  }
929
1008
 
930
1009
  napi_value
931
- keyboard_getScancode(napi_env env, napi_callback_info info)
1010
+ joystick_getPower(napi_env env, napi_callback_info info)
932
1011
  {
933
1012
  napi_value result = nullptr;
934
- char * key = nullptr;
935
1013
 
936
1014
  napi_value argv[1];
937
1015
  size_t argc = sizeof(argv) / sizeof(napi_value);
938
1016
  CALL_NAPI(napi_get_cb_info, info, &argc, argv, nullptr, nullptr);
939
1017
 
940
- size_t key_length;
941
- CALL_NAPI(napi_get_value_string_latin1, argv[0], nullptr, 0, &key_length);
942
- key = (char *) malloc(key_length + 1);
943
- CALL_NAPI(napi_get_value_string_latin1, argv[0], key, key_length + 1, nullptr);
1018
+ int joystick_id;
1019
+ CALL_NAPI(napi_get_value_int32, argv[0], &joystick_id);
944
1020
 
945
- int scancode;
946
- CALL_SDL_HELPER(keyboard_getScancode, key, &scancode);
1021
+ int power;
1022
+ CALL_SDL_HELPER(joystick_getPower, joystick_id, &power);
947
1023
 
948
- CALL_NAPI(napi_create_uint32, scancode, &result);
1024
+ CALL_NAPI(napi_create_int32, power, &result);
949
1025
 
950
1026
  cleanup:
951
1027
  return result;
952
1028
  }
953
1029
 
954
1030
  napi_value
955
- keyboard_getState(napi_env env, napi_callback_info info)
1031
+ joystick_setLed(napi_env env, napi_callback_info info)
956
1032
  {
957
1033
  napi_value result = nullptr;
958
1034
 
959
- SdlHelpers::Variant state;
960
- CALL_SDL_HELPER(keyboard_getState, state);
1035
+ napi_value argv[4];
1036
+ size_t argc = sizeof(argv) / sizeof(napi_value);
1037
+ CALL_NAPI(napi_get_cb_info, info, &argc, argv, nullptr, nullptr);
961
1038
 
962
- CALL_NAPI(fromVariant, state, &result);
1039
+ int joystick_id;
1040
+ CALL_NAPI(napi_get_value_int32, argv[0], &joystick_id);
1041
+
1042
+ double red, green, blue;
1043
+ CALL_NAPI(napi_get_value_double, argv[1], &red);
1044
+ CALL_NAPI(napi_get_value_double, argv[2], &green);
1045
+ CALL_NAPI(napi_get_value_double, argv[3], &blue);
1046
+
1047
+ CALL_SDL_HELPER(joystick_setLed, joystick_id, red, green, blue);
963
1048
 
964
1049
  cleanup:
965
1050
  return result;
966
1051
  }
967
1052
 
968
-
969
1053
  napi_value
970
- mouse_getButton(napi_env env, napi_callback_info info)
1054
+ joystick_setPlayer(napi_env env, napi_callback_info info)
971
1055
  {
972
1056
  napi_value result = nullptr;
973
1057
 
974
- napi_value argv[1];
1058
+ napi_value argv[2];
975
1059
  size_t argc = sizeof(argv) / sizeof(napi_value);
976
1060
  CALL_NAPI(napi_get_cb_info, info, &argc, argv, nullptr, nullptr);
977
1061
 
978
- int button;
979
- CALL_NAPI(napi_get_value_int32, argv[0], &button);
1062
+ int joystick_id;
1063
+ CALL_NAPI(napi_get_value_int32, argv[0], &joystick_id);
980
1064
 
981
- int state;
982
- CALL_SDL_HELPER(mouse_getButton, button, &state);
1065
+ int player;
1066
+ CALL_NAPI(napi_get_value_int32, argv[1], &player);
983
1067
 
984
- CALL_NAPI(napi_create_int32, state, &result);
985
- CALL_NAPI(napi_coerce_to_bool, result, &result);
1068
+ CALL_SDL_HELPER(joystick_setPlayer, joystick_id, player);
986
1069
 
987
1070
  cleanup:
988
1071
  return result;
989
1072
  }
990
1073
 
991
1074
  napi_value
992
- mouse_getPosition(napi_env env, napi_callback_info info)
1075
+ joystick_rumble(napi_env env, napi_callback_info info)
993
1076
  {
994
1077
  napi_value result = nullptr;
995
1078
 
996
- SdlHelpers::Variant position;
997
- CALL_SDL_HELPER(mouse_getPosition, position);
1079
+ napi_value argv[4];
1080
+ size_t argc = sizeof(argv) / sizeof(napi_value);
1081
+ CALL_NAPI(napi_get_cb_info, info, &argc, argv, nullptr, nullptr);
998
1082
 
999
- CALL_NAPI(fromVariant, position, &result);
1083
+ int joystick_id;
1084
+ CALL_NAPI(napi_get_value_int32, argv[0], &joystick_id);
1085
+
1086
+ double low_freq_rumble, high_freq_rumble, duration;
1087
+ CALL_NAPI(napi_get_value_double, argv[1], &low_freq_rumble);
1088
+ CALL_NAPI(napi_get_value_double, argv[2], &high_freq_rumble);
1089
+ CALL_NAPI(napi_get_value_double, argv[3], &duration);
1090
+
1091
+ CALL_SDL_HELPER(joystick_rumble, joystick_id, low_freq_rumble, high_freq_rumble, duration);
1000
1092
 
1001
1093
  cleanup:
1002
1094
  return result;
1003
1095
  }
1004
1096
 
1005
1097
  napi_value
1006
- mouse_setPosition(napi_env env, napi_callback_info info)
1098
+ joystick_rumbleTriggers(napi_env env, napi_callback_info info)
1007
1099
  {
1008
- napi_value argv[2];
1100
+ napi_value result = nullptr;
1101
+
1102
+ napi_value argv[4];
1009
1103
  size_t argc = sizeof(argv) / sizeof(napi_value);
1010
1104
  CALL_NAPI(napi_get_cb_info, info, &argc, argv, nullptr, nullptr);
1011
1105
 
1012
- int x, y;
1013
- CALL_NAPI(napi_get_value_int32, argv[0], &x);
1014
- CALL_NAPI(napi_get_value_int32, argv[1], &y);
1106
+ int joystick_id;
1107
+ CALL_NAPI(napi_get_value_int32, argv[0], &joystick_id);
1015
1108
 
1016
- CALL_SDL_HELPER(mouse_setPosition, x, y);
1109
+ double left_rumble, right_rumble, duration;
1110
+ CALL_NAPI(napi_get_value_double, argv[1], &left_rumble);
1111
+ CALL_NAPI(napi_get_value_double, argv[2], &right_rumble);
1112
+ CALL_NAPI(napi_get_value_double, argv[3], &duration);
1113
+
1114
+ CALL_SDL_HELPER(joystick_rumbleTriggers, joystick_id, left_rumble, right_rumble, duration);
1017
1115
 
1018
1116
  cleanup:
1019
- return nullptr;
1117
+ return result;
1020
1118
  }
1021
1119
 
1120
+
1022
1121
  napi_value
1023
- mouse_capture(napi_env env, napi_callback_info info)
1122
+ controller_open(napi_env env, napi_callback_info info)
1024
1123
  {
1124
+ napi_value result = nullptr;
1125
+
1126
+ SdlHelpers::Variant device;
1127
+
1025
1128
  napi_value argv[1];
1026
1129
  size_t argc = sizeof(argv) / sizeof(napi_value);
1027
1130
  CALL_NAPI(napi_get_cb_info, info, &argc, argv, nullptr, nullptr);
1028
1131
 
1029
- bool capture;
1030
- CALL_NAPI(napi_get_value_bool, argv[0], &capture);
1132
+ int index;
1133
+ CALL_NAPI(napi_get_value_int32, argv[0], &index);
1031
1134
 
1032
- CALL_SDL_HELPER(mouse_capture, capture);
1135
+ CALL_SDL_HELPER(controller_open, index, device);
1136
+
1137
+ CALL_NAPI(fromVariant, device, &result);
1033
1138
 
1034
1139
  cleanup:
1035
- return nullptr;
1140
+ return result;
1036
1141
  }
1037
1142
 
1038
1143
  napi_value
1039
- mouse_setCursor(napi_env env, napi_callback_info info)
1144
+ controller_close(napi_env env, napi_callback_info info)
1040
1145
  {
1041
1146
  napi_value argv[1];
1042
1147
  size_t argc = sizeof(argv) / sizeof(napi_value);
1043
1148
  CALL_NAPI(napi_get_cb_info, info, &argc, argv, nullptr, nullptr);
1044
1149
 
1045
- int cursor_id;
1046
- CALL_NAPI(napi_get_value_int32, argv[0], &cursor_id);
1150
+ int controller_id;
1151
+ CALL_NAPI(napi_get_value_int32, argv[0], &controller_id);
1047
1152
 
1048
- CALL_SDL_HELPER(mouse_setCursor, cursor_id);
1153
+ CALL_SDL_HELPER(controller_close, controller_id);
1049
1154
 
1050
1155
  cleanup:
1051
1156
  return nullptr;
1052
1157
  }
1053
1158
 
1054
1159
  napi_value
1055
- mouse_setCursorImage(napi_env env, napi_callback_info info)
1160
+ controller_addMappings(napi_env env, napi_callback_info info)
1056
1161
  {
1057
- napi_value argv[7];
1162
+ char ** mappings = nullptr;
1163
+ int num_allocated = 0;
1164
+
1165
+ napi_value argv[1];
1058
1166
  size_t argc = sizeof(argv) / sizeof(napi_value);
1059
1167
  CALL_NAPI(napi_get_cb_info, info, &argc, argv, nullptr, nullptr);
1060
1168
 
1061
- int w, h, stride;
1062
- CALL_NAPI(napi_get_value_int32, argv[0], &w);
1063
- CALL_NAPI(napi_get_value_int32, argv[1], &h);
1064
- CALL_NAPI(napi_get_value_int32, argv[2], &stride);
1065
-
1066
- unsigned int format;
1067
- CALL_NAPI(napi_get_value_uint32, argv[3], &format);
1169
+ unsigned int array_length;
1170
+ CALL_NAPI(napi_get_array_length, argv[0], &array_length);
1068
1171
 
1069
- void * pixels;
1070
- CALL_NAPI(napi_get_buffer_info, argv[4], &pixels, nullptr);
1071
-
1072
- int x, y;
1073
- CALL_NAPI(napi_get_value_int32, argv[5], &x);
1074
- CALL_NAPI(napi_get_value_int32, argv[6], &y);
1172
+ mappings = (char **) malloc(array_length * sizeof(char *));
1173
+ napi_value value;
1174
+ size_t string_length;
1175
+ for (unsigned int i = 0; i < array_length; i++) {
1176
+ CALL_NAPI(napi_get_element, argv[0], i, &value);
1177
+ CALL_NAPI(napi_get_value_string_utf8, value, nullptr, 0, &string_length);
1178
+ mappings[i] = (char *) malloc(string_length + 1);
1179
+ num_allocated++;
1180
+ CALL_NAPI(napi_get_value_string_utf8, value, mappings[i], string_length + 1, nullptr);
1181
+ }
1075
1182
 
1076
- CALL_SDL_HELPER(mouse_setCursorImage, w, h, stride, format, pixels, x, y);
1183
+ CALL_SDL_HELPER(controller_addMappings, mappings, array_length);
1077
1184
 
1078
1185
  cleanup:
1186
+ if (mappings) {
1187
+ for (int i = 0; i < num_allocated; i++) { free(mappings[i]); }
1188
+ free(mappings);
1189
+ }
1079
1190
  return nullptr;
1080
1191
  }
1081
1192
 
1193
+
1082
1194
  napi_value
1083
- mouse_showCursor(napi_env env, napi_callback_info info)
1195
+ audio_getDevices(napi_env env, napi_callback_info info)
1084
1196
  {
1197
+ napi_value result = nullptr;
1198
+ SdlHelpers::Variant devices;
1199
+
1085
1200
  napi_value argv[1];
1086
1201
  size_t argc = sizeof(argv) / sizeof(napi_value);
1087
1202
  CALL_NAPI(napi_get_cb_info, info, &argc, argv, nullptr, nullptr);
1088
1203
 
1089
- bool show;
1090
- CALL_NAPI(napi_get_value_bool, argv[0], &show);
1204
+ bool capture;
1205
+ CALL_NAPI(napi_get_value_bool, argv[0], &capture);
1091
1206
 
1092
- CALL_SDL_HELPER(mouse_showCursor, show);
1207
+ CALL_SDL_HELPER(audio_getDevices, capture, devices);
1208
+
1209
+ CALL_NAPI(fromVariant, devices, &result);
1093
1210
 
1094
1211
  cleanup:
1095
- return nullptr;
1212
+ return result;
1096
1213
  }
1097
1214
 
1098
-
1099
1215
  napi_value
1100
- joystick_getDevices(napi_env env, napi_callback_info info)
1216
+ audio_openDevice(napi_env env, napi_callback_info info)
1101
1217
  {
1102
1218
  napi_value result = nullptr;
1103
1219
 
1104
- SdlHelpers::Variant devices;
1105
- CALL_SDL_HELPER(joystick_getDevices, devices);
1220
+ char * name = nullptr;
1106
1221
 
1107
- CALL_NAPI(fromVariant, devices, &result);
1222
+ napi_value argv[6];
1223
+ size_t argc = sizeof(argv) / sizeof(napi_value);
1224
+ CALL_NAPI(napi_get_cb_info, info, &argc, argv, nullptr, nullptr);
1225
+
1226
+ size_t name_length;
1227
+ CALL_NAPI(napi_get_value_string_utf8, argv[0], nullptr, 0, &name_length);
1228
+ if (name_length > 0) {
1229
+ name = (char *) malloc(name_length + 1);
1230
+ CALL_NAPI(napi_get_value_string_utf8, argv[0], name, name_length + 1, nullptr);
1231
+ }
1232
+
1233
+ bool capture;
1234
+ CALL_NAPI(napi_get_value_bool, argv[1], &capture);
1235
+
1236
+ int freq, format, channels, samples;
1237
+ CALL_NAPI(napi_get_value_int32, argv[2], &freq);
1238
+ CALL_NAPI(napi_get_value_int32, argv[3], &format);
1239
+ CALL_NAPI(napi_get_value_int32, argv[4], &channels);
1240
+ CALL_NAPI(napi_get_value_int32, argv[5], &samples);
1241
+
1242
+ int audio_id;
1243
+ CALL_SDL_HELPER(audio_openDevice, name, capture, freq, format, channels, samples, &audio_id);
1244
+
1245
+ CALL_NAPI(napi_create_uint32, audio_id, &result);
1108
1246
 
1109
1247
  cleanup:
1248
+ if (name) { free(name); }
1110
1249
  return result;
1111
1250
  }
1112
1251
 
1113
1252
  napi_value
1114
- joystick_open(napi_env env, napi_callback_info info)
1253
+ audio_close(napi_env env, napi_callback_info info)
1115
1254
  {
1116
- napi_value result = nullptr;
1117
-
1118
- SdlHelpers::Variant device;
1119
-
1120
1255
  napi_value argv[1];
1121
1256
  size_t argc = sizeof(argv) / sizeof(napi_value);
1122
1257
  CALL_NAPI(napi_get_cb_info, info, &argc, argv, nullptr, nullptr);
1123
1258
 
1124
- int index;
1125
- CALL_NAPI(napi_get_value_int32, argv[0], &index);
1126
-
1127
- CALL_SDL_HELPER(joystick_open, index, device);
1259
+ int audio_id;
1260
+ CALL_NAPI(napi_get_value_int32, argv[0], &audio_id);
1128
1261
 
1129
- CALL_NAPI(fromVariant, device, &result);
1262
+ CALL_SDL_HELPER(audio_close, audio_id);
1130
1263
 
1131
1264
  cleanup:
1132
- //
1133
- return result;
1265
+ return nullptr;
1134
1266
  }
1135
1267
 
1136
1268
  napi_value
1137
- joystick_close(napi_env env, napi_callback_info info)
1269
+ audio_play(napi_env env, napi_callback_info info)
1138
1270
  {
1139
- napi_value argv[1];
1271
+ napi_value argv[2];
1140
1272
  size_t argc = sizeof(argv) / sizeof(napi_value);
1141
1273
  CALL_NAPI(napi_get_cb_info, info, &argc, argv, nullptr, nullptr);
1142
1274
 
1143
- int device_id;
1144
- CALL_NAPI(napi_get_value_int32, argv[0], &device_id);
1275
+ int audio_id;
1276
+ CALL_NAPI(napi_get_value_int32, argv[0], &audio_id);
1277
+
1278
+ bool play;
1279
+ CALL_NAPI(napi_get_value_bool, argv[1], &play);
1145
1280
 
1146
- CALL_SDL_HELPER(joystick_close, device_id);
1281
+ CALL_SDL_HELPER(audio_play, audio_id, play);
1147
1282
 
1148
1283
  cleanup:
1149
1284
  return nullptr;
1150
1285
  }
1151
1286
 
1152
1287
  napi_value
1153
- joystick_getPower(napi_env env, napi_callback_info info)
1288
+ audio_getQueueSize(napi_env env, napi_callback_info info)
1154
1289
  {
1155
1290
  napi_value result = nullptr;
1156
1291
 
@@ -1158,56 +1293,81 @@ joystick_getPower(napi_env env, napi_callback_info info)
1158
1293
  size_t argc = sizeof(argv) / sizeof(napi_value);
1159
1294
  CALL_NAPI(napi_get_cb_info, info, &argc, argv, nullptr, nullptr);
1160
1295
 
1161
- int device_id;
1162
- CALL_NAPI(napi_get_value_int32, argv[0], &device_id);
1296
+ int audio_id;
1297
+ CALL_NAPI(napi_get_value_int32, argv[0], &audio_id);
1163
1298
 
1164
- int power;
1165
- CALL_SDL_HELPER(joystick_getPower, device_id, &power);
1299
+ unsigned int size;
1300
+ CALL_SDL_HELPER(audio_getQueueSize, audio_id, &size);
1166
1301
 
1167
- CALL_NAPI(napi_create_int32, power, &result);
1302
+ CALL_NAPI(napi_create_uint32, size, &result);
1168
1303
 
1169
1304
  cleanup:
1170
1305
  return result;
1171
1306
  }
1172
1307
 
1173
-
1174
1308
  napi_value
1175
- controller_open(napi_env env, napi_callback_info info)
1309
+ audio_clearQueue(napi_env env, napi_callback_info info)
1176
1310
  {
1177
- napi_value result = nullptr;
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);
1178
1314
 
1179
- SdlHelpers::Variant device;
1315
+ int audio_id;
1316
+ CALL_NAPI(napi_get_value_int32, argv[0], &audio_id);
1180
1317
 
1181
- napi_value argv[1];
1318
+ CALL_SDL_HELPER(audio_clearQueue, audio_id);
1319
+
1320
+ cleanup:
1321
+ return nullptr;
1322
+ }
1323
+
1324
+ napi_value
1325
+ audio_enqueue(napi_env env, napi_callback_info info)
1326
+ {
1327
+ napi_value argv[3];
1182
1328
  size_t argc = sizeof(argv) / sizeof(napi_value);
1183
1329
  CALL_NAPI(napi_get_cb_info, info, &argc, argv, nullptr, nullptr);
1184
1330
 
1185
- int index;
1186
- CALL_NAPI(napi_get_value_int32, argv[0], &index);
1331
+ int audio_id;
1332
+ CALL_NAPI(napi_get_value_int32, argv[0], &audio_id);
1187
1333
 
1188
- CALL_SDL_HELPER(controller_open, index, device);
1334
+ void * src;
1335
+ CALL_NAPI(napi_get_buffer_info, argv[1], &src, nullptr);
1189
1336
 
1190
- CALL_NAPI(fromVariant, device, &result);
1337
+ int size;
1338
+ CALL_NAPI(napi_get_value_int32, argv[2], &size);
1339
+
1340
+ CALL_SDL_HELPER(audio_enqueue, audio_id, src, size);
1191
1341
 
1192
1342
  cleanup:
1193
- //
1194
- return result;
1343
+ return nullptr;
1195
1344
  }
1196
1345
 
1197
1346
  napi_value
1198
- controller_close(napi_env env, napi_callback_info info)
1347
+ audio_dequeue(napi_env env, napi_callback_info info)
1199
1348
  {
1200
- napi_value argv[1];
1349
+ napi_value result = nullptr;
1350
+
1351
+ napi_value argv[3];
1201
1352
  size_t argc = sizeof(argv) / sizeof(napi_value);
1202
1353
  CALL_NAPI(napi_get_cb_info, info, &argc, argv, nullptr, nullptr);
1203
1354
 
1204
- int device_id;
1205
- CALL_NAPI(napi_get_value_int32, argv[0], &device_id);
1355
+ int audio_id;
1356
+ CALL_NAPI(napi_get_value_int32, argv[0], &audio_id);
1357
+
1358
+ void * dst;
1359
+ CALL_NAPI(napi_get_buffer_info, argv[1], &dst, nullptr);
1360
+
1361
+ int size;
1362
+ CALL_NAPI(napi_get_value_int32, argv[2], &size);
1363
+
1364
+ int num;
1365
+ CALL_SDL_HELPER(audio_dequeue, audio_id, dst, size, &num);
1206
1366
 
1207
- CALL_SDL_HELPER(controller_close, device_id);
1367
+ CALL_NAPI(napi_create_uint32, num, &result);
1208
1368
 
1209
1369
  cleanup:
1210
- return nullptr;
1370
+ return result;
1211
1371
  }
1212
1372
 
1213
1373
 
@@ -1221,7 +1381,7 @@ clipboard_getText(napi_env env, napi_callback_info info)
1221
1381
 
1222
1382
  if (!text) { return nullptr; }
1223
1383
 
1224
- CALL_NAPI(napi_create_string_latin1, text, strlen(text), &result);
1384
+ CALL_NAPI(napi_create_string_utf8, text, strlen(text), &result);
1225
1385
 
1226
1386
  cleanup:
1227
1387
  return result;
@@ -1237,14 +1397,24 @@ clipboard_setText(napi_env env, napi_callback_info info)
1237
1397
  CALL_NAPI(napi_get_cb_info, info, &argc, argv, nullptr, nullptr);
1238
1398
 
1239
1399
  size_t text_length;
1240
- CALL_NAPI(napi_get_value_string_latin1, argv[0], nullptr, 0, &text_length);
1400
+ CALL_NAPI(napi_get_value_string_utf8, argv[0], nullptr, 0, &text_length);
1241
1401
  text = (char *) malloc(text_length + 1);
1242
- CALL_NAPI(napi_get_value_string_latin1, argv[0], text, text_length + 1, nullptr);
1402
+ CALL_NAPI(napi_get_value_string_utf8, argv[0], text, text_length + 1, nullptr);
1243
1403
 
1244
1404
  CALL_SDL_HELPER(clipboard_setText, text);
1245
1405
 
1246
1406
  cleanup:
1247
- free(text);
1407
+ if (text) { free(text); }
1408
+ return nullptr;
1409
+ }
1410
+
1411
+
1412
+ napi_value
1413
+ cleanup(napi_env env, napi_callback_info info)
1414
+ {
1415
+ CALL_SDL_HELPER(cleanup);
1416
+
1417
+ cleanup:
1248
1418
  return nullptr;
1249
1419
  }
1250
1420
 
@@ -1255,6 +1425,8 @@ init (napi_env env, napi_value exports)
1255
1425
  napi_property_descriptor desc[] = {
1256
1426
  { "getEnums", NULL, getEnums, NULL, NULL, NULL, napi_enumerable, NULL },
1257
1427
  { "initialize", NULL, initialize, NULL, NULL, NULL, napi_enumerable, NULL },
1428
+ { "events_poll", NULL, events_poll, NULL, NULL, NULL, napi_enumerable, NULL },
1429
+ { "events_wait", NULL, events_wait, NULL, NULL, NULL, napi_enumerable, NULL },
1258
1430
  { "video_getDisplays", NULL, video_getDisplays, NULL, NULL, NULL, napi_enumerable, NULL },
1259
1431
  { "window_create", NULL, window_create, NULL, NULL, NULL, napi_enumerable, NULL },
1260
1432
  { "window_setTitle", NULL, window_setTitle, NULL, NULL, NULL, napi_enumerable, NULL },
@@ -1273,16 +1445,6 @@ init (napi_env env, napi_value exports)
1273
1445
  { "window_setIcon", NULL, window_setIcon, NULL, NULL, NULL, napi_enumerable, NULL },
1274
1446
  { "window_render", NULL, window_render, NULL, NULL, NULL, napi_enumerable, NULL },
1275
1447
  { "window_destroy", NULL, window_destroy, NULL, NULL, NULL, napi_enumerable, NULL },
1276
- { "audio_getDevices", NULL, audio_getDevices, NULL, NULL, NULL, napi_enumerable, NULL },
1277
- { "audio_openDevice", NULL, audio_openDevice, NULL, NULL, NULL, napi_enumerable, NULL },
1278
- { "audio_close", NULL, audio_close, NULL, NULL, NULL, napi_enumerable, NULL },
1279
- { "audio_play", NULL, audio_play, NULL, NULL, NULL, napi_enumerable, NULL },
1280
- { "audio_getQueueSize", NULL, audio_getQueueSize, NULL, NULL, NULL, napi_enumerable, NULL },
1281
- { "audio_enqueue", NULL, audio_enqueue, NULL, NULL, NULL, napi_enumerable, NULL },
1282
- { "audio_dequeue", NULL, audio_dequeue, NULL, NULL, NULL, napi_enumerable, NULL },
1283
- { "audio_clearQueue", NULL, audio_clearQueue, NULL, NULL, NULL, napi_enumerable, NULL },
1284
- { "events_poll", NULL, events_poll, NULL, NULL, NULL, napi_enumerable, NULL },
1285
- { "events_wait", NULL, events_wait, NULL, NULL, NULL, napi_enumerable, NULL },
1286
1448
  { "keyboard_getKey", NULL, keyboard_getKey, NULL, NULL, NULL, napi_enumerable, NULL },
1287
1449
  { "keyboard_getScancode", NULL, keyboard_getScancode, NULL, NULL, NULL, napi_enumerable, NULL },
1288
1450
  { "keyboard_getState", NULL, keyboard_getState, NULL, NULL, NULL, napi_enumerable, NULL },
@@ -1297,14 +1459,27 @@ init (napi_env env, napi_value exports)
1297
1459
  { "joystick_open", NULL, joystick_open, NULL, NULL, NULL, napi_enumerable, NULL },
1298
1460
  { "joystick_close", NULL, joystick_close, NULL, NULL, NULL, napi_enumerable, NULL },
1299
1461
  { "joystick_getPower", NULL, joystick_getPower, NULL, NULL, NULL, napi_enumerable, NULL },
1462
+ { "joystick_setLed", NULL, joystick_setLed, NULL, NULL, NULL, napi_enumerable, NULL },
1463
+ { "joystick_setPlayer", NULL, joystick_setPlayer, NULL, NULL, NULL, napi_enumerable, NULL },
1464
+ { "joystick_rumble", NULL, joystick_rumble, NULL, NULL, NULL, napi_enumerable, NULL },
1465
+ { "joystick_rumbleTriggers", NULL, joystick_rumbleTriggers, NULL, NULL, NULL, napi_enumerable, NULL },
1300
1466
  { "controller_open", NULL, controller_open, NULL, NULL, NULL, napi_enumerable, NULL },
1301
1467
  { "controller_close", NULL, controller_close, NULL, NULL, NULL, napi_enumerable, NULL },
1468
+ { "controller_addMappings", NULL, controller_addMappings, NULL, NULL, NULL, napi_enumerable, NULL },
1469
+ { "audio_getDevices", NULL, audio_getDevices, NULL, NULL, NULL, napi_enumerable, NULL },
1470
+ { "audio_openDevice", NULL, audio_openDevice, NULL, NULL, NULL, napi_enumerable, NULL },
1471
+ { "audio_close", NULL, audio_close, NULL, NULL, NULL, napi_enumerable, NULL },
1472
+ { "audio_play", NULL, audio_play, NULL, NULL, NULL, napi_enumerable, NULL },
1473
+ { "audio_getQueueSize", NULL, audio_getQueueSize, NULL, NULL, NULL, napi_enumerable, NULL },
1474
+ { "audio_enqueue", NULL, audio_enqueue, NULL, NULL, NULL, napi_enumerable, NULL },
1475
+ { "audio_dequeue", NULL, audio_dequeue, NULL, NULL, NULL, napi_enumerable, NULL },
1476
+ { "audio_clearQueue", NULL, audio_clearQueue, NULL, NULL, NULL, napi_enumerable, NULL },
1302
1477
  { "clipboard_getText", NULL, clipboard_getText, NULL, NULL, NULL, napi_enumerable, NULL },
1303
1478
  { "clipboard_setText", NULL, clipboard_setText, NULL, NULL, NULL, napi_enumerable, NULL },
1304
1479
  { "cleanup", NULL, cleanup, NULL, NULL, NULL, napi_enumerable, NULL }
1305
1480
  };
1306
1481
 
1307
- CALL_NAPI(napi_define_properties, exports, 49, desc);
1482
+ CALL_NAPI(napi_define_properties, exports, 54, desc);
1308
1483
 
1309
1484
  cleanup:
1310
1485
  return exports;