[feat] Add SDL3 bindings

libraries/sdl3.c3l/README.md

@@ -0,0 +1,10 @@
+
+### SDL3.c3l
+
+#### Info
+- Functions are named like this: ```SDL_FunctionName``` -> ```sdl3::functionName``` or ```SDL_EGL_FunctionName``` -> ```sdl3::egl::functionName```.
+- Typedefs, Structs, and Enums are translated as 1-to-1 as possible with Flag typedefs being converted to bitstructs where possible.
+- Types from SDL_stdinc.h are included, functions are not.
+
+#### Documentation
+https://wiki.libsdl.org/SDL3/FrontPage

libraries/sdl3.c3l/assert.c3i

@@ -0,0 +1,33 @@
+
+module sdl3;
+
+// Types
+alias AssertionHandler = fn AssertState(AssertData* data, void* userdata);
+
+// Structs
+struct AssertData {
+    bool always_ignore; /**< true if app should always continue when assertion is triggered. */
+    uint trigger_count; /**< Number of times this assertion has been triggered. */
+    char* condition;    /**< A string of this assert's test code. */
+    char* filename;     /**< The source file where this assert lives. */
+    int linenum;        /**< The line in `filename` where this assert lives. */
+    char* function;     /**< The name of the function where this assert lives. */
+    AssertData* next;   /**< next item in the linked list. */
+}
+
+// Enums
+enum AssertState {
+    RETRY,    /**< Retry the assert immediately. */
+    BREAK,    /**< Make the debugger trigger a breakpoint. */
+    ABORT,    /**< Terminate the program. */
+    IGNORE,   /**< Ignore the assert. */
+    ALWAYS_IGNORE  /**< Ignore the assert from now on. */
+}
+
+// Functions
+extern fn AssertionHandler getAssertionHandler(void** puserdata) @cname("SDL_GetAssertionHandler");
+extern fn AssertData* getAssertionReport() @cname("SDL_GetAssertionReport");
+extern fn AssertionHandler getDefaultAssertionHandler() @cname("SDL_GetDefaultAssertionHandler");
+extern fn AssertState reportAssertion(AssertData* data, char* func, char* file, int line) @cname("SDL_ReportAssertion");
+extern fn void resetAssertionReport() @cname("SDL_ResetAssertionReport");
+extern fn void setAssertionHandler(AssertionHandler handler, void* userdata) @cname("SDL_SetAssertionHandler");

libraries/sdl3.c3l/asyncio.c3i

@@ -0,0 +1,43 @@
+
+module sdl3;
+
+// Types
+alias AsyncIO = void;
+alias AsyncIOQueue = void;
+
+// Structs
+struct AsyncIOOutcome {
+  AsyncIO* asyncio;      /**< what generated this task. This pointer will be invalid if it was closed! */
+  AsyncIOTaskType type;  /**< What sort of task was this? Read, write, etc? */
+  AsyncIOResult result;  /**< the result of the work (success, failure, cancellation). */
+  void* buffer;          /**< buffer where data was read/written. */
+  ulong offset;          /**< offset in the SDL_AsyncIO where data was read/written. */
+  ulong bytes_requested; /**< number of bytes the task was to read/write. */
+  ulong bytes_transferred; /**< actual number of bytes that were read/written. */
+  void* userdata;        /**< pointer provided by the app when starting the task */
+}
+
+// Enums
+enum AsyncIOResult {
+  COMPLETE,  /**< request was completed without error */
+  FAILURE,   /**< request failed for some reason; check SDL_GetError()! */
+  CANCELED,  /**< request was canceled before completing. */
+}
+enum AsyncIOTaskType {
+  READ,   /**< A read operation. */
+  WRITE,  /**< A write operation. */
+  CLOSE,  /**< A close operation. */
+}
+
+// Functions
+extern fn AsyncIO* asyncIOFromFile(char* file, char* mode) @cname("SDL_AsyncIOFromFile");
+extern fn bool closeAsyncIO(AsyncIO* asyncio, bool flush, AsyncIOQueue* queue, void* userdata) @cname("SDL_CloseAsyncIO");
+extern fn AsyncIOQueue* createAsyncIOQueue() @cname("SDL_AsyncIOQueue");
+extern fn void destroyAsyncIOQueue(AsyncIOQueue* queue) @cname("SDL_DestroyAsyncIOQueue");
+extern fn bool getAsyncIOResult(AsyncIOQueue* queue, AsyncIOOutcome* outcome) @cname("SDL_GetAsyncIOResult");
+extern fn long getAsyncIOSize(AsyncIO* asyncio) @cname("SDL_GetAsyncIOSize");
+extern fn bool loadFileAsync(char* file, AsyncIOQueue* queue, void* userdata) @cname("SDL_LoadFileAsync");
+extern fn bool readAsyncIO(AsyncIO* asyncio, void* ptr, ulong offset, ulong size, AsyncIOQueue* queue, void* userdata) @cname("SDL_ReadAsyncIO");
+extern fn void signalAsyncIOQueue(AsyncIOQueue* queue) @cname("SDL_SignalAsyncIOQueue");
+extern fn bool waitAsyncIOResult(AsyncIOQueue* queue, AsyncIOOutcome* outcome, int timeoutMS) @cname("SDL_WaitAsyncIOResult");
+extern fn bool writeAsyncIO(AsyncIO* asyncio, void* ptr, ulong offset, ulong size, AsyncIOQueue* queue, void* userdata) @cname("SDL_WriteAsyncIO");

libraries/sdl3.c3l/atomic.c3i

@@ -0,0 +1,27 @@
+
+module sdl3;
+
+// Types
+alias SpinLock = int;
+
+// Structs
+struct AtomicInt { int value; }
+struct AtomicU32 { uint value; }
+
+// Functions
+extern fn int sddAtomicInt(AtomicInt* a, int v) @cname("SDL_AddAtomicInt");
+extern fn uint addAtomicU32(AtomicU32* a, int v) @cname("SDL_AddAtomicU32");
+extern fn bool compareAndSwapAtomicInt(AtomicInt* a, int oldval, int newval) @cname("SDL_CompareAndSwapAtomicInt");
+extern fn bool compareAndSwapAtomicPointer(void** a, void* oldval, void* newval) @cname("SDL_CompareAndSwapAtomicPointer");
+extern fn bool compareAndSwapAtomicU32(AtomicU32* a, uint oldval, uint newval) @cname("SDL_CompareAndSwapAtomicU32");
+extern fn int getAtomicInt(AtomicInt* a) @cname("SDL_GetAtomicInt");
+extern fn void* getAtomicPointer(void** a) @cname("SDL_GetAtomicPointer");
+extern fn uint getAtomicU32(AtomicU32* a) @cname("SDL_GetAtomicU32");
+extern fn void lockSpinlock(SpinLock* lock) @cname("SDL_LockSpinlock");
+extern fn void memoryBarrierAcquireFunction() @cname("SDL_MemoryBarrierAcquireFunction");
+extern fn void memoryBarrierReleaseFunction() @cname("SDL_MemoryBarrierReleaseFunction");
+extern fn int aetAtomicInt(AtomicInt* a, int v) @cname("SDL_SetAtomicInt");
+extern fn void* setAtomicPointer(void** a, void* v) @cname("SDL_SetAtomicPointer");
+extern fn uint setAtomicU32(AtomicU32* a, uint v) @cname("SDL_SetAtomicU32");
+extern fn bool tryLockSpinlock(SpinLock* lock) @cname("SDL_TryLockSpinlock");
+extern fn void unlockSpinlock(SpinLock* lock) @cname("SDL_UnlockSpinlock");

libraries/sdl3.c3l/audio.c3i

@@ -0,0 +1,97 @@
+
+module sdl3;
+
+// Types
+alias AudioDeviceID = uint;
+alias AudioPostmixCallback = fn void(void* userdata, AudioSpec* spec, float* buffer, int buflen);
+alias AudioStream = void;
+alias AudioStreamCallback = fn void(void* userdata, AudioStream* stream, int additional_amount, int total_amount);
+alias AudioStreamDataCompleteCallback = fn void(void* userdata, void* buf, int buflen);
+
+// Structs
+struct AudioSpec {
+  AudioFormat format; /**< Audio data format */
+  int channels;       /**< Number of channels: 1 mono, 2 stereo, etc */
+  int freq;           /**< sample rate: sample frames per second */
+}
+
+// Enums
+constdef AudioFormat : CInt {
+  UNKNOWN   = 0x0000u,  /**< Unspecified audio format */
+  U8        = 0x0008u,  /**< Unsigned 8-bit samples */
+    /* SDL_DEFINE_AUDIO_FORMAT(0, 0, 0, 8), */
+  S8        = 0x8008u,  /**< Signed 8-bit samples */
+    /* SDL_DEFINE_AUDIO_FORMAT(1, 0, 0, 8), */
+  S16LE     = 0x8010u,  /**< Signed 16-bit samples */
+    /* SDL_DEFINE_AUDIO_FORMAT(1, 0, 0, 16), */
+  S16BE     = 0x9010u,  /**< As above, but big-endian byte order */
+    /* SDL_DEFINE_AUDIO_FORMAT(1, 1, 0, 16), */
+  S32LE     = 0x8020u,  /**< 32-bit integer samples */
+    /* SDL_DEFINE_AUDIO_FORMAT(1, 0, 0, 32), */
+  S32BE     = 0x9020u,  /**< As above, but big-endian byte order */
+    /* SDL_DEFINE_AUDIO_FORMAT(1, 1, 0, 32), */
+  F32LE     = 0x8120u,  /**< 32-bit floating point samples */
+    /* SDL_DEFINE_AUDIO_FORMAT(1, 0, 1, 32), */
+  F32BE     = 0x9120u,  /**< As above, but big-endian byte order */
+    /* SDL_DEFINE_AUDIO_FORMAT(1, 1, 1, 32), */
+}
+
+// Functions
+extern fn bool audioDevicePaused(AudioDeviceID devid) @cname("SDL_AudioDevicePaused");
+extern fn bool audioStreamDevicePaused(AudioStream* stream) @cname("SDL_AudioStreamDevicePaused");
+extern fn bool bindAudioStream(AudioDeviceID devid, AudioStream* stream) @cname("SDL_BindAudioStream");
+extern fn bool bindAudioStreams(AudioDeviceID devid, AudioStream** streams, int num_streams) @cname("SDL_BindAudioStreams");
+extern fn bool clearAudioStream(AudioStream* stream) @cname("SDL_ClearAudioStream");
+extern fn void closeAudioDevice(AudioDeviceID devid) @cname("SDL_CloseAudioDevice");
+extern fn bool convertAudioSamples(AudioSpec* src_spec, char* src_data, int src_len, AudioSpec* dst_spec, char** dst_data, int* dst_len) @cname("SDL_ConvertAudioSamples");
+extern fn AudioStream* createAudioStream(AudioSpec* src_spec, AudioSpec* dst_spec) @cname("SDL_CreateAudioStream");
+extern fn void destroyAudioStream(AudioStream* stream) @cname("SDL_DestroyAudioStream");
+extern fn bool flushAudioStream(AudioStream* stream) @cname("SDL_FlushAudioStream");
+extern fn int* getAudioDeviceChannelMap(AudioDeviceID devid, int* count) @cname("SDL_GetAudioDeviceChannelMap");
+extern fn bool getAudioDeviceFormat(AudioDeviceID devid, AudioSpec* spec, int* sample_frames) @cname("SDL_GetAudioDeviceFormat");
+extern fn float getAudiDeviceGain(AudioDeviceID devid) @cname("SDL_GetAudioDeviceGain");
+extern fn char* getAudioDeviceName(AudioDeviceID devid) @cname("SDL_GetAudioDeviceName");
+extern fn char* getAudioDriver(int index) @cname("SDL_GetAudioDriver");
+extern fn char* getAudioFormatName(AudioFormat format) @cname("SDL_GetAudioFormatName");
+extern fn AudioDeviceID* getAudioPlaybackDevices(int* count) @cname("SDL_GetAudioPlaybackDevices");
+extern fn AudioDeviceID* getAudioRecordingDevices(int* count) @cname("SDL_GetAudioRecordingDevices");
+extern fn int getAudioStreamAvailable(AudioStream* stream) @cname("SDL_GetAudioStreamAvailable");
+extern fn int getAudioStreamData(AudioStream* stream, void* buf, int len) @cname("SDL_GetAudioStreamData");
+extern fn AudioDeviceID getAudioStreamDevice(AudioStream* stream) @cname("SDL_GetAudioStreamDevice");
+extern fn bool getAudioStreamFormat(AudioStream* stream, AudioSpec* src_spec, AudioSpec* dst_spec) @cname("SDL_GetAudioStreamFormat");
+extern fn float getAudioStreamFrequencyRatio(AudioStream* stream) @cname("SDL_GetAudioStreamFrequencyRatio");
+extern fn float getAudioStreamGain(AudioStream* stream) @cname("SDL_GetAudioStreamGain");
+extern fn int* getAudioStreamInputChannelMap(AudioStream* stream, int* count) @cname("SDL_GetAudioStreamInputChannelMap");
+extern fn int* getAudioStreamOutputChannelMap(AudioStream* stream, int* count) @cname("SDL_GetAudioStreamOutputChannelMap");
+extern fn PropertiesID getAudioStreamProperties(AudioStream* stream) @cname("SDL_GetAudioStreamProperties");
+extern fn int getAudioStreamQueued(AudioStream* stream) @cname("SDL_GetAudioStreamQueued");
+extern fn char* getCurrentAudioDriver() @cname("SDL_GetCurrentAudioDriver");
+extern fn int getNumAudioDrivers() @cname("SDL_GetNumAudioDrivers");
+extern fn int getSilenceValueForFormat(AudioFormat format) @cname("SDL_GetSilenceValueForFormat");
+extern fn bool isAudioDevicePhysical(AudioDeviceID devid) @cname("SDL_IsAudioDevicePhysical");
+extern fn bool isAudioDevicePlayback(AudioDeviceID devid) @cname("SDL_IsAudioDevicePlayback");
+extern fn bool loadWAV(char* path, AudioSpec* spec, char** audio_buf, uint* audio_len) @cname("SDL_LoadWAV");
+extern fn bool loadWAV_IO(IOStream* src, bool closeio, AudioSpec* spec, char** audio_buf, uint *audio_len) @cname("SDL_LoadWAV_IO");
+extern fn bool lockAudioStream(AudioStream* stream) @cname("SDL_LockAudioStream");
+extern fn bool mixAudio(char* dst, char* src, AudioFormat format, uint len, float volume) @cname("SDL_MixAudio");
+extern fn AudioDeviceID openAudioDevice(AudioDeviceID devid, AudioSpec* spec) @cname("SDL_OpenAudioDevice");
+extern fn AudioStream* openAudioDeviceStream(AudioDeviceID devid, AudioSpec* spec, AudioStreamCallback callback, void* userdata) @cname("SDL_OpenAudioDeviceStream");
+extern fn bool pauseAudioDevice(AudioDeviceID devid) @cname("SDL_PauseAudioDevice");
+extern fn bool pauseAudioStreamDevice(AudioStream* stream) @cname("SDL_PauseAudioStreamDevice");
+extern fn bool putAudioStreamData(AudioStream* stream, void* buf, int len) @cname("SDL_PutAudioStreamData");
+extern fn bool putAudioStreamDataNoCopy(AudioStream* stream, void* buf, int len, AudioStreamDataCompleteCallback callback, void* userdata) @cname("SDL_PutAudioStreamDataNoCopy");
+extern fn bool putAudioStreamPlanarData(AudioStream* stream, void** channel_buffers, int num_channels, int num_samples) @cname("SDL_PutAudioStreamPlanarData");
+extern fn bool resumeAudioDevice(AudioDeviceID devid) @cname("SDL_ResumeAudioDevice");
+extern fn bool resumeAudioStreamDevice(AudioStream* stream) @cname("SDL_ResumeAudioStreamDevice");
+extern fn bool setAudioDeviceGain(AudioDeviceID devid, float gain) @cname("SDL_SetAudioDeviceGain");
+extern fn bool setAudioPostmixCallback(AudioDeviceID devid, AudioPostmixCallback callback, void* userdata) @cname("SDL_SetAudioPostmixCallback");
+extern fn bool setAudioStreamFormat(AudioStream* stream, AudioSpec* src_spec, AudioSpec* dst_spec) @cname("SDL_SetAudioStreamFormat");
+extern fn bool setAudioStreamFrequencyRatio(AudioStream* stream, float ratio) @cname("SDL_SetAudioStreamFrequencyRatio");
+extern fn bool setAudioStreamGain(AudioStream* stream, float gain) @cname("SDL_SetAudioStreamGain");
+extern fn bool setAudioStreamGetCallback(AudioStream* stream, AudioStreamCallback callback, void* userdata) @cname("SDL_SetAudioStreamGetCallback");
+extern fn bool setAudioStreamInputChannelMap(AudioStream* stream, int* chmap, int count) @cname("SDL_SetAudioStreamInputChannelMap");
+extern fn bool setAudioStreamOutputChannelMap(AudioStream* stream, int* chmap, int count) @cname("SDL_SetAudioStreamOutputChannelMap");
+extern fn bool setAudioStreamPutCallback(AudioStream* stream, AudioStreamCallback callback, void* userdata) @cname("SDL_SetAudioStreamPutCallback");
+extern fn void unbindAudioStream(AudioStream* stream) @cname("SDL_UnbindAudioStream");
+extern fn void unbindAudioStreams(AudioStream** streams, int num_streams) @cname("SDL_UnbindAudioStreams");
+extern fn bool unlockAudioStream(AudioStream* stream) @cname("SDL_UnlockAudioStream");

libraries/sdl3.c3l/bits.c3i

@@ -0,0 +1,6 @@
+
+module sdl3;
+
+// Functions
+extern fn bool hasExactlyOneBitSet32(ushort x) @cname("SDL_HasExactlyOneBitSet32");
+extern fn int mostSignificantBitIndex32(ushort x) @cname("SDL_MostSignificantBitIndex32");

libraries/sdl3.c3l/blendmode.c3i

@@ -0,0 +1,37 @@
+
+module sdl3;
+
+// Bitstructs
+bitstruct BlendMode : uint {
+  bool blend:   0;
+  bool add:     1;
+  bool mod:     2;
+  bool mul:     3; // Also premul
+}
+
+// Enums
+enum BlendFactor {
+  EMPTY,
+  ZERO,
+  ONE,
+  SRC_COLOR,
+  ONE_MINUS_SRC_COLOR,
+  SRC_ALPHA,
+  ONE_MINUS_SRC_ALPHA,
+  DST_COLOR,
+  ONE_MINUS_DST_COLOR,
+  DST_ALPHA,
+  ONE_MINUS_DST_ALPHA,
+}
+enum BlendOperation {
+  EMPTY,
+  ADD,
+  SUBTRACT,
+  REV_SUBTRACT,
+  MINIMUM,
+  MAXIMUM,
+}
+
+// Functions
+extern fn BlendMode composeCustomBlendMode(BlendFactor srcColorFactor, BlendFactor dstColorFactor, BlendOperation colorOperation, BlendFactor srcAlphaFactor, BlendFactor dstAlphaFactor, BlendOperation alphaOperation) @cname("SDL_ComposeCustomBlendMode");
+

libraries/sdl3.c3l/camera.c3i

@@ -0,0 +1,45 @@
+
+module sdl3;
+
+// Types
+alias Camera = void;
+alias CameraID = uint;
+
+// Structs
+struct CameraSpec {
+  PixelFormat format;      /**< Frame format */
+  Colorspace colorspace;   /**< Frame colorspace */
+  int width;               /**< Frame width */
+  int height;              /**< Frame height */
+  int framerate_numerator; /**< Frame rate numerator ((num / denom) == FPS, (denom / num) == duration in seconds) */
+  int framerate_denominator; /**< Frame rate denominator ((num / denom) == FPS, (denom / num) == duration in seconds) */
+}
+
+// Enums
+constdef CameraPermissionState : CInt {
+    DENIED   = -1,
+    PENDING  =  0,
+    APPROVED =  1,
+}
+enum CameraPosition {
+  UNKNOWN,
+  FRONT_FACING,
+  BACK_FACING,
+}
+
+// Functions
+extern fn Surface* acquireCameraFrame(Camera* camera, ulong* timestampNS) @cname("SDL_AcquireCameraFrame");
+extern fn void closeCamera(Camera* camera) @cname("SDL_CloseCamera");
+extern fn char* getCameraDriver(int index) @cname("SDL_GetCameraDriver");
+extern fn bool getCameraFormat(Camera* camera, CameraSpec* spec) @cname("SDL_GetCameraFormat");
+extern fn CameraID getCameraID(Camera* camera) @cname("SDL_GetCameraID");
+extern fn char* getCameraName(CameraID instance_id) @cname("SDL_GetCameraName");
+extern fn CameraPermissionState getCameraPermissionState(Camera* camera) @cname("SDL_GetCameraPermissionState");
+extern fn CameraPosition getCameraPosition(CameraID instance_id) @cname("SDL_GetCameraPosition");
+extern fn PropertiesID getCameraProperties(Camera* camera) @cname("SDL_GetCameraProperties");
+extern fn CameraID* getCameras(int* count) @cname("SDL_GetCameras");
+extern fn CameraSpec** getCameraSupportedFormats(CameraID instance_id, int* count) @cname("SDL_GetCameraSupportedFormats");
+extern fn char* getCurrentCameraDriver() @cname("SDL_GetCurrentCameraDriver");
+extern fn int getNumCameraDrivers() @cname("SDL_GetNumCameraDrivers");
+extern fn Camera* openCamera(CameraID instance_id, CameraSpec* spec) @cname("SDL_OpenCamera");
+extern fn void releaseCameraFrame(Camera* camera, Surface* frame) @cname("SDL_ReleaseCameraFrame");

libraries/sdl3.c3l/clipboard.c3i

@@ -0,0 +1,19 @@
+
+module sdl3;
+
+// Types
+alias ClipboardCleanupCallback = fn void(void* userdata);
+alias ClipboardDataCallback = fn void*(void *userdata, char* mime_type, usz* size);
+
+// Functions
+extern fn bool clearClipboardData() @cname("SDL_ClearClipboardData");
+extern fn void* getClipboardData(char* mime_type, usz* size) @cname("SDL_GetClipboardData");
+extern fn char** getClipboardMimeTypes(usz* num_mime_types) @cname("SDL_GetClipboardMimeTypes");
+extern fn char* getClipboardText() @cname("SDL_GetClipboardText");
+extern fn char* getPrimarySelectionText() @cname("SDL_GetPrimarySelectionText");
+extern fn bool hasClipboardData(char* mime_type) @cname("SDL_HasClipboardData");
+extern fn bool hasClipboardText() @cname("SDL_HasClipboardText");
+extern fn bool hasPrimarySelectionText() @cname("SDL_HasPrimarySelectionText");
+extern fn bool setClipboardData(ClipboardDataCallback callback, ClipboardCleanupCallback cleanup, void* userdata, char** mime_types, usz num_mime_types) @cname("SDL_SetClipboardData");
+extern fn bool setClipboardText(char* text) @cname("SDL_SetClipboardText");
+extern fn bool setPrimarySelectionText(char* text) @cname("SDL_SetPrimarySelectionText");

libraries/sdl3.c3l/cpuinfo.c3i

@@ -0,0 +1,23 @@
+
+module sdl3;
+
+// Functions
+extern fn int getCPUCacheLineSize() @cname("SDL_GetCPUCacheLineSize");
+extern fn int getNumLogicalCPUCores() @cname("SDL_GetNumLogicalCPUCores");
+extern fn usz getSIMDAlignment() @cname("SDL_GetSIMDAlignment");
+extern fn int getSystemPageSize() @cname("SDL_GetSystemPageSize");
+extern fn int getSystemRAM() @cname("SDL_GetSystemRAM");
+extern fn bool hasAltiVec() @cname("SDL_HasAltiVec");
+extern fn bool hasARMSIMD() @cname("SDL_HasARMSIMD");
+extern fn bool hasAVX() @cname("SDL_HasAVX");
+extern fn bool hasAVX2() @cname("SDL_HasAVX2");
+extern fn bool hasAVX512F() @cname("SDL_HasAVX512F");
+extern fn bool hasLASX() @cname("SDL_HasLASX");
+extern fn bool hasLSX() @cname("SDL_HasLSX");
+extern fn bool hasMMX() @cname("SDL_HasMMX");
+extern fn bool hasNEON() @cname("SDL_HasNEON");
+extern fn bool hasSSE() @cname("SDL_HasSSE");
+extern fn bool hasSSE2() @cname("SDL_HasSSE2");
+extern fn bool hasSSE3() @cname("SDL_HasSSE3");
+extern fn bool hasSSE41() @cname("SDL_HasSSE41");
+extern fn bool hasSSE42() @cname("SDL_HasSSE42");