Merge pull request #23 from ColleagueRiley/master

review internal api

Author: IoIxD

Makefile

@@ -39,13 +39,19 @@ ifeq ($(PLATFORM),Windows)
    	EXT = dll
 	LDFLAGS = -shared 
 	# change later
-	BACKEND ?= WINMM
+	BACKEND ?= windows
 
-	ifeq ($(BACKEND),WINMM)
+	ifeq ($(BACKEND),windows)
+		LIBS = 	
+		CFLAGS += -I./src/windows/ 
+		SOURCES += $(wildcard src/windows/*.c)	
+	else ifeq ($(BACKEND),WINMM)
 		LIBS = -lwinmm	
 		CFLAGS += -I./src/winmm/ 
 		SOURCES += $(wildcard src/winmm/*.c)
 	endif
+
+	CFLAGS += -D BUILD_LIBTYPE_SHARED
 endif
 
 TARGET = $(OUTDIR)/libminigamepad.$(EXT) \
@@ -71,7 +77,7 @@ $(OUTDIR)/%.o: $(SOURCES) | $(OUTDIR)
 	$(CC) $(CFLAGS) -c $< -o $@
 
 $(EXAMPLES): %: %.c		
-	$(CC) $(CFLAGS) -I. $< $(LIBS) -L./build -lminigamepad -o $(OUTDIR)/$@ 
+	$(CC) -static $(CFLAGS) -I. $< $(LIBS) -L./build -lminigamepad -o $(OUTDIR)/$@ 
 
 $(LIBEVDEV_OBJECTS): %.o: %.c
 	$(CC) -fPIC  -c $< -o $@

examples/gamepadlist.c

@@ -3,13 +3,10 @@
 
 int main(void) {
   mg_gamepads gamepads = {0};
-  mg_gamepads_fetch(&gamepads);
+  mg_gamepads_init(&gamepads);
 
-  size_t joystick_num = gamepads.num;
-
-  for (size_t i = 0; i < joystick_num; i++) {
-    mg_gamepad *gamepad = mg_gamepads_at(&gamepads, i);
-    printf("%s\n", mg_gamepad_get_name(gamepad));
+  for (mg_gamepad* cur = mg_gamepad_get_head(&gamepads); cur; cur = mg_gamepad_iterate(cur)) {
+    printf("%s\n", cur->name);
   }
 
   mg_gamepads_free(&gamepads);

examples/gamepadquery.c

@@ -15,12 +15,10 @@ void clear(void) {
 int main(void) {
   mg_gamepads gamepads = {0};
 
-  size_t idx = 0;
-
   clear();
 
   mg_gamepads_init(&gamepads);
-  mg_gamepad *gamepad = mg_gamepads_at(&gamepads, idx);
+  mg_gamepad* gamepad = gamepads.head;
 
   for (;;) {
     while(mg_gamepads_update(&gamepads, NULL));
@@ -30,10 +28,13 @@ int main(void) {
     if (!mg_gamepad_is_connected(gamepad)) {
       clear();
       mg_gamepads_fetch(&gamepads);
-      gamepad = mg_gamepads_at(&gamepads, idx);
+
+      gamepad = gamepad->next;
+      if (gamepad == NULL)
+        break;
     }
 
-    printf("     Gamepad: %-25s\n", mg_gamepad_get_name(gamepad));
+    printf("     Gamepad: %-25s\n", gamepad->name);
     size_t gamepad_button_num = gamepad->button_num;
     for (size_t i = 0; i < gamepad_button_num; i++) {
       mg_gamepad_btn btn = gamepad->buttons[i].key;

examples/gamepadrumble.c

@@ -5,18 +5,21 @@
 #include <time.h>
 #include <unistd.h>
 
-#ifndef __WIN32
+#ifndef _WIN32
 #include <pthread.h>
 #else
 #include <windows.h>
+#include <processthreadsapi.h>
+#include <handleapi.h>
+#include <synchapi.h>
 #endif
 
 mg_gamepads gamepads = {0};
 mg_gamepad *gamepad;
 
 double axis_value;
 
-#ifndef __WIN32
+#ifndef _WIN32
 pthread_t thread_id;
 __attribute__((__noreturn__)) void *rumble_thread(void *arg);
 #else
@@ -33,7 +36,7 @@ int main(void) {
 
   gamepad = mg_gamepads_at(&gamepads, 0);
 
-#ifndef __WIN32
+#ifndef _WIN32
   pthread_create(&thread_id, NULL, &rumble_thread, NULL);
 #else
   CreateThread(NULL,            // default security attributes
@@ -51,16 +54,16 @@ int main(void) {
 
   mg_gamepads_free(&gamepads);
 
-#ifndef __WIN32
+#ifndef _WIN32
   pthread_cancel(thread_id);
 #else
-  CloseHandle(thread_id);
+  CloseHandle(thread_handle);
 #endif
 
   return 0;
 }
 
-#ifndef __WIN32
+#ifndef _WIN32
 __attribute__((__noreturn__)) void *rumble_thread(void *arg) {
 #else
 __declspec(noreturn) DWORD WINAPI rumble_thread(LPVOID arg) {
@@ -71,7 +74,7 @@ __declspec(noreturn) DWORD WINAPI rumble_thread(LPVOID arg) {
     mg_gamepad_rumble(gamepad, (uint16_t)axis_value / 2, (uint16_t)axis_value,
                       1000);
     printf("\rVibration: %0.2f", axis_value);
-#ifndef __WIN32
+#ifndef _WIN32
     fflush(stdout);
     sleep(1);
 #else

include/minigamepad.h

@@ -1,6 +1,25 @@
 #ifndef __minigamepad_H
 #define __minigamepad_H
 
+#if defined(_WIN32) && !defined(MG_API)
+    #if defined(__TINYC__)
+        #define __declspec(x) __attribute__((x))
+    #endif
+    #if defined(BUILD_LIBTYPE_SHARED)
+        #define MG_API __declspec(dllexport)     // We are building the library as a Win32 shared library (.dll)
+    #elif defined(USE_LIBTYPE_SHARED)
+        #define MG_API __declspec(dllimport)     // We are using the library as a Win32 shared library (.dll)
+    #endif
+#elif !defined(MG_API)
+    #if defined(BUILD_LIBTYPE_SHARED)
+        #define MG_API __attribute__((visibility("default"))) // We are building as a Unix shared library (.so/.dylib)
+    #endif
+#endif
+
+#ifndef MG_API 
+    #define MG_API 
+#endif
+
 #include <stddef.h>
 
 #ifdef __cplusplus
@@ -33,6 +52,10 @@ typedef enum {
   MG_GAMEPAD_BUTTON_RIGHT_STICK,
   MG_GAMEPAD_BUTTON_LEFT_SHOULDER,
   MG_GAMEPAD_BUTTON_RIGHT_SHOULDER,
+  MG_GAMEPAD_BUTTON_DPAD_UP,
+  MG_GAMEPAD_BUTTON_DPAD_DOWN,
+  MG_GAMEPAD_BUTTON_DPAD_LEFT,
+  MG_GAMEPAD_BUTTON_DPAD_RIGHT,
   MG_GAMEPAD_BUTTON_MISC1, /**< Additional button (e.g. Xbox Series X share
                                button, PS5 microphone button, Nintendo Switch
                                Pro capture button, Amazon Luna microphone
@@ -88,54 +111,67 @@ typedef enum {
   MG_GAMEPAD_AXIS_MAX,
 } mg_gamepad_axis;
 
-#define MAX_BUTTONS MG_GAMEPAD_BUTTON_MAX
-#define MAX_AXISES MG_GAMEPAD_AXIS_MAX
+#define MG_MAX_BUTTONS MG_GAMEPAD_BUTTON_MAX
+#define MG_MAX_AXISES MG_GAMEPAD_AXIS_MAX
 
 /// Internal context of the gamepad, i.e. implementation details.
 struct mg_gamepad_context_t;
 
-typedef struct mg_gamepad_t {
+typedef struct mg_buttons {
+    mg_gamepad_btn key;
+    int16_t value;
+} mg_buttons;
+
+typedef struct mg_axises {
+    mg_gamepad_axis key;
+    int16_t value;
+    int16_t deadzone;
+} mg_axises;
+
+struct mg_mapping;
+
+typedef struct mg_gamepad {
     // Internal context for platform dependent items.
     struct mg_gamepad_context_t *ctx;
     // Map of buttons that the controller has
-    struct {
-        mg_gamepad_btn key;
-        int16_t value;
-    } buttons[MAX_BUTTONS];
+    mg_buttons buttons[MG_MAX_BUTTONS];
     // The number of buttons on the controller.
     size_t button_num;
     // Map of axises that the controller has, + their deadzones
     // By default, the deadzones are 5000 for any axis that isn't the d-pad; you
     // are strongly encouraged to make this customizable in any program you make
     // with this.
-    struct {
-        mg_gamepad_axis key;
-        int16_t value;
-        int16_t deadzone;
-    } axises[MAX_AXISES];
+
+    mg_axises axises[MG_MAX_AXISES];
     // The number of axises on the controller.
     size_t axis_num;
 
-    struct mg_gamepad_t* prev;
-    struct mg_gamepad_t* next;
+    bool connected;
+    char name[128];
+    char guid[33];
+
+    struct mg_mapping* mapping;
+
+    struct mg_gamepad* prev;
+    struct mg_gamepad* next;
 } mg_gamepad;
 
 /// A list of gamepads recognized by the system.
-typedef struct mg_gamepads_t {
-    struct mg_gamepad_t __list[16];
-    struct mg_gamepad_t* cur;
-    struct mg_gamepad_t* head;
+typedef struct mg_gamepads {
+    mg_gamepad __list[16];
+    mg_gamepad* cur;
+    mg_gamepad* head;
 
     struct {
-        struct mg_gamepad_t* cur;
-        struct mg_gamepad_t* head;
+        mg_gamepad* cur;
+        mg_gamepad* head;
     } freed;
 
     size_t num;
 } mg_gamepads;
 
 
-typedef enum mg_gamepad_event_type_t {
+typedef enum mg_gamepad_event_type {
     MG_GAMEPAD_NONE = 0,
     MG_GAMEPAD_CONNECT,
     MG_GAMEPAD_DISCONNECT,
@@ -144,7 +180,7 @@ typedef enum mg_gamepad_event_type_t {
     MG_GAMEPAD_AXIS_MOVE
 } mg_gamepad_event_type;
 
-typedef struct mg_gamepad_event_t {
+typedef struct mg_gamepad_event {
     mg_gamepad_event_type type;
     mg_gamepad_btn btn;
     mg_gamepad_axis axis;
@@ -153,38 +189,47 @@ typedef struct mg_gamepad_event_t {
 } mg_gamepad_event; 
 
 
+// get the head gamepad in the linked list of gamepads
+MG_API mg_gamepad* mg_gamepad_get_head(mg_gamepads* gamepads);
+
+// iterates to the next node in the linked list of gamepads, returns `cur`, allowing you to check if cur == NULL 
+MG_API mg_gamepad* mg_gamepad_iterate(mg_gamepad* cur);
+
 /// Init the gamepads internal structure.
-void mg_gamepads_init(mg_gamepads *gamepad);
+MG_API void mg_gamepads_init(mg_gamepads *gamepad);
 
 /// Fetch and update all gamepads and return the first event
-bool mg_gamepads_update(mg_gamepads* gamepads, mg_gamepad_event* ev);
+MG_API bool mg_gamepads_update(mg_gamepads* gamepads, mg_gamepad_event* ev);
+
+/// Add another mapping to the gamepads mappings
+MG_API int mg_update_gamepad_mappings(mg_gamepads*gamepads, const char* string);
 
 /// Update the gamepad's internal structure.
 /// This needs to be called before any gamepad buttons/axises are checked if you
 /// want the correct values.
-bool mg_gamepad_update(mg_gamepad *gamepad, mg_gamepad_event* ev);
+MG_API bool mg_gamepad_update(mg_gamepad *gamepad, mg_gamepad_event* ev);
 
 /// Get the gamepads currently connected to the system. Returns true if a new gamepad was found
-bool mg_gamepads_fetch(mg_gamepads *);
+MG_API bool mg_gamepads_fetch(mg_gamepads *);
 /// Get the number of gamepads attached to the system.
-size_t mg_gamepads_num(mg_gamepads *gamepads);
+MG_API size_t mg_gamepads_num(mg_gamepads *gamepads);
 /// Get the game pad at the given index.
-mg_gamepad *mg_gamepads_at(mg_gamepads *mj, size_t idx);
+MG_API mg_gamepad *mg_gamepads_at(mg_gamepads *mj, size_t idx);
 /// Free gamepads.
-void mg_gamepads_free(mg_gamepads *gamepads);
+MG_API void mg_gamepads_free(mg_gamepads *gamepads);
 
 /// Get the gamepad's name.
-const char *mg_gamepad_get_name(mg_gamepad *gamepad);
+MG_API const char *mg_gamepad_get_name(mg_gamepad *gamepad);
 /// Check if this gamepad is connected.
-bool mg_gamepad_is_connected(mg_gamepad *gamepad);
+MG_API bool mg_gamepad_is_connected(mg_gamepad *gamepad);
 
 /// Get the name of a gamepad button.
-const char *mg_gamepad_btn_get_name(mg_gamepad_btn);
+MG_API const char *mg_gamepad_btn_get_name(mg_gamepad_btn);
 /// Get the name of a gamepad axis.
-const char *mg_gamepad_axis_get_name(mg_gamepad_axis axis);
+MG_API const char *mg_gamepad_axis_get_name(mg_gamepad_axis axis);
 
 /// Rumble the controller
-void mg_gamepad_rumble(mg_gamepad *gamepad, uint16_t strong_vibration, uint16_t weak_vibration, uint16_t milliseconds);
+MG_API void mg_gamepad_rumble(mg_gamepad *gamepad, uint16_t strong_vibration, uint16_t weak_vibration, uint16_t milliseconds);
 
 #ifdef __cplusplus
 }