Add Zelda64Recomp API header, config header, UI headers, util header, and data structure header and fix uname being run on Windows (#9)

* Add example toml/code for config values and example code for building a UI

* Update UI enums.

* Add new margin auto setters and total height define

* Add UI callback types to headers and add callback example

* Add z64recomp_api.h header for game-specific mod APIs and document actor data extensions in it

* Organize imports into headers, add label and textinput

* Add context input capture setters to recompui.h

* Add UI API functions for setting visibility, setting text, and destroying elements

* Add UI API functions and example code for imageview elements

* Add recompdata.h header with data structure API imports

* Add exports and examples for slider, label radio, and password input

* Add recomp_get_mod_version import and example

* Add recomp_change_save_file export and documentation in recompconfig.h

* Add recomp_get_save_file_path export

* Add extra flex direction enums

* Add navigation exports to recompui.h

* Remove UI example code (will be restored in another branch to keep main branch example simple)

* Fix uname being run on windows

---------

Co-authored-by: Dario <dariosamo@gmail.com>

Author: Mr-Wiseguy

Makefile

@@ -2,12 +2,15 @@ BUILD_DIR := build
 
 # Allow the user to specify the compiler and linker on macOS
 # as Apple Clang does not support MIPS architecture
-ifeq ($(shell uname),Darwin)
-    CC      ?= clang
-    LD      ?= ld.lld
-else
+ifeq ($(OS),Windows_NT)
     CC      := clang
     LD      := ld.lld
+else ifneq ($(shell uname),Darwin)
+    CC      := clang
+    LD      := ld.lld
+else
+    CC      ?= clang
+    LD      ?= ld.lld
 endif
 
 TARGET  := $(BUILD_DIR)/mod.elf

include/recompconfig.h

@@ -0,0 +1,28 @@
+#ifndef __RECOMPCONFIG_H__
+#define __RECOMPCONFIG_H__
+
+#include "modding.h"
+
+// Reads a config value of the specified type and name for the mod that called these functions.
+// These correspond to the config schema provided in the mod's manifest.
+RECOMP_IMPORT("*", unsigned long recomp_get_config_u32(const char* key));
+RECOMP_IMPORT("*", double recomp_get_config_double(const char* key));
+RECOMP_IMPORT("*", char* recomp_get_config_string(const char* key));
+
+// Frees a value returned by `recomp_get_config_string`. MUST be called to prevent a memory leak.
+RECOMP_IMPORT("*", void recomp_free_config_string(char* str));
+
+// Gets the version of the mod that called this function. Writes the mod's version numbers into the provided pointers.
+RECOMP_IMPORT("*", void recomp_get_mod_version(unsigned long* major, unsigned long* minor, unsigned long* patch));
+
+// Swaps to using a different file. The new save file will be located at `<mod id>/<filename>.bin` in the normal saves folder.
+// Don't include `.bin` in the provided filename.
+// Be careful calling this function during normal gameplay as the game won't be aware that any currently loaded save data is outdated.
+RECOMP_IMPORT("*", void recomp_change_save_file(const char* filename));
+
+// Returns a UTF-8 encoded zero-terminated string containing the absolute path to the current save file.
+// The return type is an unsigned char pointer to indicate the UTF-8 encoding.
+// `recomp_free` (found in `recomputils.h`) MUST be called on the return value of this when the value is no longer in use to prevent a memory leak.
+RECOMP_IMPORT("*", unsigned char* recomp_get_save_file_path());
+
+#endif

include/recompdata.h

@@ -0,0 +1,183 @@
+#ifndef __RECOMPDATA_H__
+#define __RECOMPDATA_H__
+
+#include "modding.h"
+
+// This file contains imports for utility data collection types.
+// hashmaps: Maps arbitrary unique numeric keys to elements.
+//   Amortized O(1) performance for insertion, lookup, and deletion.
+// hashsets: Tracks a collection of unique numeric keys.
+//   Amortized O(1) performance for insertion, lookup, and deletion.
+// slotmaps: Like hashmaps, but the keys are generated instead of provided.
+//   Amortized O(1) performance for insertion, lookup, and deletion. More performant than hashmaps.
+
+// Hashmaps and slotmaps types are available that hold either 32-bit elements or data elements of a fixed element size.  
+
+typedef unsigned long collection_key_t;
+
+/////////////////////////
+// u32 -> u32 hashmaps //
+/////////////////////////
+
+typedef unsigned long U32ValueHashmapHandle;
+
+// Creates a hashmap that maps u32 keys to u32 values.
+// Returns the handle for that hashmap.
+RECOMP_IMPORT("*", U32ValueHashmapHandle recomputil_create_u32_value_hashmap());
+
+// Destroys a u32 -> u32 hashmap.
+RECOMP_IMPORT("*", void recomputil_destroy_u32_value_hashmap(U32ValueHashmapHandle handle));
+
+// Checks if a u32 -> u32 hashmap contains the given key.
+// Returns 1 if the key exists in the map, otherwise returns 0.
+RECOMP_IMPORT("*", int recomputil_u32_value_hashmap_contains(U32ValueHashmapHandle handle, collection_key_t key));
+
+// Inserts a value into a u32 -> u32 hashmap. The value is always assigned even if the key already exists.
+// Returns 1 if the key was created (i.e. did not exist in the map), otherwise returns 0.
+RECOMP_IMPORT("*", int recomputil_u32_value_hashmap_insert(U32ValueHashmapHandle handle, collection_key_t key, unsigned long value));
+
+// Attempts to retrieve a value from a u32 -> u32 hashmap.
+// Returns 1 if the key exists in the map and writes the element's value to *out, otherwise returns 0 and does not modify the contents in *out.
+RECOMP_IMPORT("*", int recomputil_u32_value_hashmap_get(U32ValueHashmapHandle handle, collection_key_t key, unsigned long* out));
+
+// Erases a key from a u32 -> u32 hashmap. Does nothing if the key doesn't exist in the hashmap.
+// Returns 1 if the key was erased (i.e. it existed in the map), otherwise returns 0.
+RECOMP_IMPORT("*", int recomputil_u32_value_hashmap_erase(U32ValueHashmapHandle handle, collection_key_t key));
+
+// Gets the size of a u32 -> u32 hashmap.
+// Returns the number of elements in the map.
+RECOMP_IMPORT("*", unsigned long recomputil_u32_value_hashmap_size(U32ValueHashmapHandle handle));
+
+//////////////////////////
+// u32 -> data hashmaps //
+//////////////////////////
+
+typedef unsigned long U32MemoryHashmapHandle;
+
+// Creates a hashmap that maps u32 keys to data of a given element size.
+// Returns the handle for that hashmap.
+RECOMP_IMPORT("*", U32MemoryHashmapHandle recomputil_create_u32_memory_hashmap(unsigned long element_size));
+
+// Destroys a u32 -> data hashmap.
+RECOMP_IMPORT("*", void recomputil_destroy_u32_memory_hashmap(U32MemoryHashmapHandle handle));
+
+// Checks if a u32 -> data hashmap contains the given key.
+// Returns 1 if the key exists in the map, otherwise returns 0.
+RECOMP_IMPORT("*", int recomputil_u32_memory_hashmap_contains(U32MemoryHashmapHandle handle, collection_key_t key));
+
+// Creates an element in a u32 -> data hashmap with the given key. Does nothing if the key already exists.
+// Returns 1 if the element was created (i.e. the key did not already existed), otherwise returns 0.
+RECOMP_IMPORT("*", int recomputil_u32_memory_hashmap_create(U32MemoryHashmapHandle handle, collection_key_t key));
+
+// Attempts to retrieve a value from a u32 -> data hashmap.
+// Returns the element's pointer if the key exists in the map, otherwise returns null.
+RECOMP_IMPORT("*", void* recomputil_u32_memory_hashmap_get(U32MemoryHashmapHandle handle, collection_key_t key));
+
+// Erases a key from a u32 -> data hashmap. Does nothing if the key doesn't exist in the hashmap.
+// Returns 1 if the key was erased (i.e. it existed in the map), otherwise returns 0.
+RECOMP_IMPORT("*", int recomputil_u32_memory_hashmap_erase(U32MemoryHashmapHandle handle, collection_key_t key));
+
+// Gets the size of a u32 -> data hashmap.
+// Returns the number of elements in the map.
+RECOMP_IMPORT("*", unsigned long recomputil_u32_memory_hashmap_size(U32MemoryHashmapHandle handle));
+
+//////////////////
+// u32 hashsets //
+//////////////////
+
+typedef unsigned long U32HashsetHandle;
+
+// Creates a hashset of u32 keys.
+// Returns the handle for that hashset.
+RECOMP_IMPORT("*", U32HashsetHandle recomputil_create_u32_hashset());
+
+// Destroys a u32 hashset.
+RECOMP_IMPORT("*", void recomputil_destroy_u32_hashset(U32HashsetHandle handle));
+
+// Checks if a u32 hashset contains the given key.
+// Returns 1 if the key exists in the set, otherwise returns 0.
+RECOMP_IMPORT("*", int recomputil_u32_hashset_contains(U32HashsetHandle handle, collection_key_t key));
+
+// Inserts a key into a u32 hashset.
+// Returns 1 if the key was inserted (i.e. it did not exist in the set), otherwise returns 0.
+RECOMP_IMPORT("*", int recomputil_u32_hashset_insert(U32HashsetHandle handle, collection_key_t key));
+
+// Erases a key from a u32 hashset.
+// Returns 1 if the key was erased (i.e. it exited in the set), otherwise returns 0.
+RECOMP_IMPORT("*", int recomputil_u32_hashset_erase(U32HashsetHandle handle, collection_key_t key));
+
+// Gets the size of a u32 hashset.
+// Returns the number of elements in the set.
+RECOMP_IMPORT("*", unsigned long recomputil_u32_hashset_size(U32HashsetHandle handle));
+
+//////////////////
+// u32 slotmaps //
+//////////////////
+
+typedef unsigned long U32SlotmapHandle;
+
+// Creates a slotmap with u32 elements.
+// Returns the handle for that slotmap.
+RECOMP_IMPORT("*", U32SlotmapHandle recomputil_create_u32_slotmap());
+
+// Destroys a u32 slotmap.
+RECOMP_IMPORT("*", void recomputil_destroy_u32_slotmap(U32SlotmapHandle handle));
+
+// Checks if a u32 slotmap contains the given key.
+// Returns 1 if the key exists in the map, otherwise returns 0.
+RECOMP_IMPORT("*", int recomputil_u32_slotmap_contains(U32SlotmapHandle handle, collection_key_t key));
+
+// Creates an element in a u32 slotmap.
+// Returns the created element's key.
+RECOMP_IMPORT("*", collection_key_t recomputil_u32_slotmap_create(U32SlotmapHandle handle));
+
+// Attempts to retrieve a value from a u32 slotmap.
+// Returns 1 if the key exists in the map and writes the element's value to *out, otherwise returns 0 and does not modify the contents in *out.
+RECOMP_IMPORT("*", int recomputil_u32_slotmap_get(U32SlotmapHandle handle, collection_key_t key, unsigned long* out));
+
+// Attempts to set a value in a u32 slotmap. The value is not assigned if the key does not exist.
+// Returns 1 if the key existed, otherwise returns 0.
+RECOMP_IMPORT("*", int recomputil_u32_slotmap_set(U32SlotmapHandle handle, collection_key_t key, unsigned long value));
+
+// Erases a key from a u32 slotmap.
+// Returns 1 if the key was erased (i.e. it exited in the map), otherwise returns 0.
+RECOMP_IMPORT("*", int recomputil_u32_slotmap_erase(U32SlotmapHandle handle, collection_key_t key));
+
+// Gets the size of a u32 slotmap.
+// Returns the number of elements in the map.
+RECOMP_IMPORT("*", unsigned long recomputil_u32_slotmap_size(U32SlotmapHandle handle));
+
+///////////////////
+// data slotmaps //
+///////////////////
+
+typedef unsigned long MemorySlotmapHandle;
+
+// Creates a slotmap with data elements of a given element size.
+// Returns the handle for that slotmap.
+RECOMP_IMPORT("*", MemorySlotmapHandle recomputil_create_memory_slotmap(unsigned long element_size));
+
+// Destroys a memory slotmap.
+RECOMP_IMPORT("*", void recomputil_destroy_memory_slotmap(MemorySlotmapHandle handle));
+
+// Checks if a memory slotmap contains the given key.
+// Returns 1 if the key exists in the map, otherwise returns 0.
+RECOMP_IMPORT("*", int recomputil_memory_slotmap_contains(MemorySlotmapHandle handle, collection_key_t key));
+
+// Creates an element in a memory slotmap.
+// Returns the created element's key.
+RECOMP_IMPORT("*", collection_key_t recomputil_memory_slotmap_create(MemorySlotmapHandle handle));
+
+// Attempts to retrieve an element from a u32 slotmap.
+// Returns 1 if the key exists in the map and writes the element's pointer to *out, otherwise returns 0 and does not modify the contents in *out.
+RECOMP_IMPORT("*", int recomputil_memory_slotmap_get(MemorySlotmapHandle handle, collection_key_t key, void** out));
+
+// Erases a key from a memory slotmap.
+// Returns 1 if the key was erased (i.e. it exited in the map), otherwise returns 0.
+RECOMP_IMPORT("*", int recomputil_memory_slotmap_erase(MemorySlotmapHandle handle, collection_key_t key));
+
+// Gets the size of a memory slotmap.
+// Returns the number of elements in the map.
+RECOMP_IMPORT("*", unsigned long recomputil_memory_slotmap_size(MemorySlotmapHandle handle));
+
+#endif