chore(build): use SDL3

vendor/sdl-3.2.10/src/video/emscripten/SDL_emscriptenevents.h

@@ -0,0 +1,31 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2025 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef SDL_emscriptenevents_h_
+#define SDL_emscriptenevents_h_
+
+#include "SDL_emscriptenvideo.h"
+
+extern void Emscripten_RegisterEventHandlers(SDL_WindowData *data);
+extern void Emscripten_UnregisterEventHandlers(SDL_WindowData *data);
+extern EM_BOOL Emscripten_HandleCanvasResize(int eventType, const void *reserved, void *userData);
+
+#endif // SDL_emscriptenevents_h_

vendor/sdl-3.2.10/src/video/emscripten/SDL_emscriptenframebuffer.c

@@ -0,0 +1,161 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2025 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+#include "SDL_internal.h"
+
+#ifdef SDL_VIDEO_DRIVER_EMSCRIPTEN
+
+#include "SDL_emscriptenvideo.h"
+#include "SDL_emscriptenframebuffer.h"
+
+#include <emscripten/threading.h>
+
+bool Emscripten_CreateWindowFramebuffer(SDL_VideoDevice *_this, SDL_Window *window, SDL_PixelFormat *format, void **pixels, int *pitch)
+{
+    SDL_Surface *surface;
+    const SDL_PixelFormat surface_format = SDL_PIXELFORMAT_XBGR8888;
+    int w, h;
+
+    // Free the old framebuffer surface
+    SDL_WindowData *data = window->internal;
+    surface = data->surface;
+    SDL_DestroySurface(surface);
+
+    // Create a new one
+    SDL_GetWindowSizeInPixels(window, &w, &h);
+
+    surface = SDL_CreateSurface(w, h, surface_format);
+    if (!surface) {
+        return false;
+    }
+
+    // Save the info and return!
+    data->surface = surface;
+    *format = surface_format;
+    *pixels = surface->pixels;
+    *pitch = surface->pitch;
+    return true;
+}
+
+bool Emscripten_UpdateWindowFramebuffer(SDL_VideoDevice *_this, SDL_Window *window, const SDL_Rect *rects, int numrects)
+{
+    SDL_Surface *surface;
+
+    SDL_WindowData *data = window->internal;
+    surface = data->surface;
+    if (!surface) {
+        return SDL_SetError("Couldn't find framebuffer surface for window");
+    }
+
+    // Send the data to the display
+
+    /* *INDENT-OFF* */ // clang-format off
+    MAIN_THREAD_EM_ASM({
+        var w = $0;
+        var h = $1;
+        var pixels = $2;
+        var canvasId = UTF8ToString($3);
+        var canvas = document.querySelector(canvasId);
+
+        //TODO: this should store a context per canvas
+        if (!Module['SDL3']) Module['SDL3'] = {};
+        var SDL3 = Module['SDL3'];
+        if (SDL3.ctxCanvas !== canvas) {
+            SDL3.ctx = Module['createContext'](canvas, false, true);
+            SDL3.ctxCanvas = canvas;
+        }
+        if (SDL3.w !== w || SDL3.h !== h || SDL3.imageCtx !== SDL3.ctx) {
+            SDL3.image = SDL3.ctx.createImageData(w, h);
+            SDL3.w = w;
+            SDL3.h = h;
+            SDL3.imageCtx = SDL3.ctx;
+        }
+        var data = SDL3.image.data;
+        var src = pixels / 4;
+        var dst = 0;
+        var num;
+
+        if (SDL3.data32Data !== data) {
+            SDL3.data32 = new Int32Array(data.buffer);
+            SDL3.data8 = new Uint8Array(data.buffer);
+            SDL3.data32Data = data;
+        }
+        var data32 = SDL3.data32;
+        num = data32.length;
+        // logically we need to do
+        //      while (dst < num) {
+        //          data32[dst++] = HEAP32[src++] | 0xff000000
+        //      }
+        // the following code is faster though, because
+        // .set() is almost free - easily 10x faster due to
+        // native SDL_memcpy efficiencies, and the remaining loop
+        // just stores, not load + store, so it is faster
+        data32.set(HEAP32.subarray(src, src + num));
+        var data8 = SDL3.data8;
+        var i = 3;
+        var j = i + 4*num;
+        if (num % 8 == 0) {
+            // unrolling gives big speedups
+            while (i < j) {
+              data8[i] = 0xff;
+              i = i + 4 | 0;
+              data8[i] = 0xff;
+              i = i + 4 | 0;
+              data8[i] = 0xff;
+              i = i + 4 | 0;
+              data8[i] = 0xff;
+              i = i + 4 | 0;
+              data8[i] = 0xff;
+              i = i + 4 | 0;
+              data8[i] = 0xff;
+              i = i + 4 | 0;
+              data8[i] = 0xff;
+              i = i + 4 | 0;
+              data8[i] = 0xff;
+              i = i + 4 | 0;
+            }
+         } else {
+            while (i < j) {
+              data8[i] = 0xff;
+              i = i + 4 | 0;
+            }
+        }
+
+        SDL3.ctx.putImageData(SDL3.image, 0, 0);
+    }, surface->w, surface->h, surface->pixels, data->canvas_id);
+    /* *INDENT-ON* */ // clang-format on
+
+    if (emscripten_has_asyncify() && SDL_GetHintBoolean(SDL_HINT_EMSCRIPTEN_ASYNCIFY, true)) {
+        // give back control to browser for screen refresh
+        emscripten_sleep(0);
+    }
+
+    return true;
+}
+
+void Emscripten_DestroyWindowFramebuffer(SDL_VideoDevice *_this, SDL_Window *window)
+{
+    SDL_WindowData *data = window->internal;
+
+    SDL_DestroySurface(data->surface);
+    data->surface = NULL;
+}
+
+#endif // SDL_VIDEO_DRIVER_EMSCRIPTEN

vendor/sdl-3.2.10/src/video/emscripten/SDL_emscriptenframebuffer.h

@@ -0,0 +1,30 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2025 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+#include "SDL_internal.h"
+
+#ifndef SDL_emscriptenframebuffer_h_
+#define SDL_emscriptenframebuffer_h_
+
+extern bool Emscripten_CreateWindowFramebuffer(SDL_VideoDevice *_this, SDL_Window *window, SDL_PixelFormat *format, void **pixels, int *pitch);
+extern bool Emscripten_UpdateWindowFramebuffer(SDL_VideoDevice *_this, SDL_Window *window, const SDL_Rect *rects, int numrects);
+extern void Emscripten_DestroyWindowFramebuffer(SDL_VideoDevice *_this, SDL_Window *window);
+
+#endif // SDL_emscriptenframebuffer_h_

vendor/sdl-3.2.10/src/video/emscripten/SDL_emscriptenmouse.c

@@ -0,0 +1,216 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2025 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+#include "SDL_internal.h"
+
+#ifdef SDL_VIDEO_DRIVER_EMSCRIPTEN
+
+#include <emscripten/emscripten.h>
+#include <emscripten/html5.h>
+#include <emscripten/threading.h>
+
+#include "SDL_emscriptenmouse.h"
+#include "SDL_emscriptenvideo.h"
+
+#include "../SDL_video_c.h"
+#include "../../events/SDL_mouse_c.h"
+
+// older Emscriptens don't have this, but we need to for wasm64 compatibility.
+#ifndef MAIN_THREAD_EM_ASM_PTR
+    #ifdef __wasm64__
+        #error You need to upgrade your Emscripten compiler to support wasm64
+    #else
+        #define MAIN_THREAD_EM_ASM_PTR MAIN_THREAD_EM_ASM_INT
+    #endif
+#endif
+
+static SDL_Cursor *Emscripten_CreateCursorFromString(const char *cursor_str, bool is_custom)
+{
+    SDL_CursorData *curdata;
+    SDL_Cursor *cursor = SDL_calloc(1, sizeof(SDL_Cursor));
+    if (cursor) {
+        curdata = (SDL_CursorData *)SDL_calloc(1, sizeof(*curdata));
+        if (!curdata) {
+            SDL_free(cursor);
+            return NULL;
+        }
+
+        curdata->system_cursor = cursor_str;
+        curdata->is_custom = is_custom;
+        cursor->internal = curdata;
+    }
+
+    return cursor;
+}
+
+static SDL_Cursor *Emscripten_CreateDefaultCursor(void)
+{
+    SDL_SystemCursor id = SDL_GetDefaultSystemCursor();
+    const char *cursor_name = SDL_GetCSSCursorName(id, NULL);
+    return Emscripten_CreateCursorFromString(cursor_name, false);
+}
+
+EM_JS_DEPS(sdlmouse, "$stringToUTF8,$UTF8ToString");
+
+static SDL_Cursor *Emscripten_CreateCursor(SDL_Surface *surface, int hot_x, int hot_y)
+{
+    const char *cursor_url = NULL;
+    SDL_Surface *conv_surf;
+
+    conv_surf = SDL_ConvertSurface(surface, SDL_PIXELFORMAT_ABGR8888);
+
+    if (!conv_surf) {
+        return NULL;
+    }
+
+    /* *INDENT-OFF* */ // clang-format off
+    cursor_url = (const char *)MAIN_THREAD_EM_ASM_PTR({
+        var w = $0;
+        var h = $1;
+        var hot_x = $2;
+        var hot_y = $3;
+        var pixels = $4;
+
+        var canvas = document.createElement("canvas");
+        canvas.width = w;
+        canvas.height = h;
+
+        var ctx = canvas.getContext("2d");
+
+        var image = ctx.createImageData(w, h);
+        var data = image.data;
+        var src = pixels / 4;
+
+        var data32 = new Int32Array(data.buffer);
+        data32.set(HEAP32.subarray(src, src + data32.length));
+
+        ctx.putImageData(image, 0, 0);
+        var url = hot_x === 0 && hot_y === 0
+            ? "url(" + canvas.toDataURL() + "), auto"
+            : "url(" + canvas.toDataURL() + ") " + hot_x + " " + hot_y + ", auto";
+
+        var urlBuf = _SDL_malloc(url.length + 1);
+        stringToUTF8(url, urlBuf, url.length + 1);
+
+        return urlBuf;
+    }, surface->w, surface->h, hot_x, hot_y, conv_surf->pixels);
+    /* *INDENT-ON* */ // clang-format on
+
+    SDL_DestroySurface(conv_surf);
+
+    return Emscripten_CreateCursorFromString(cursor_url, true);
+}
+
+static SDL_Cursor *Emscripten_CreateSystemCursor(SDL_SystemCursor id)
+{
+    const char *cursor_name = SDL_GetCSSCursorName(id, NULL);
+
+    return Emscripten_CreateCursorFromString(cursor_name, false);
+}
+
+static void Emscripten_FreeCursor(SDL_Cursor *cursor)
+{
+    SDL_CursorData *curdata;
+    if (cursor) {
+        curdata = cursor->internal;
+
+        if (curdata) {
+            if (curdata->is_custom) {
+                SDL_free((char *)curdata->system_cursor);
+            }
+            SDL_free(cursor->internal);
+        }
+
+        SDL_free(cursor);
+    }
+}
+
+static bool Emscripten_ShowCursor(SDL_Cursor *cursor)
+{
+    SDL_CursorData *curdata;
+    if (SDL_GetMouseFocus() != NULL) {
+        if (cursor && cursor->internal) {
+            curdata = cursor->internal;
+
+            if (curdata->system_cursor) {
+                /* *INDENT-OFF* */ // clang-format off
+                MAIN_THREAD_EM_ASM({
+                    if (Module['canvas']) {
+                        Module['canvas'].style['cursor'] = UTF8ToString($0);
+                    }
+                }, curdata->system_cursor);
+                /* *INDENT-ON* */ // clang-format on
+            }
+        } else {
+            /* *INDENT-OFF* */ // clang-format off
+            MAIN_THREAD_EM_ASM(
+                if (Module['canvas']) {
+                    Module['canvas'].style['cursor'] = 'none';
+                }
+            );
+            /* *INDENT-ON* */ // clang-format on
+        }
+    }
+    return true;
+}
+
+static bool Emscripten_SetRelativeMouseMode(bool enabled)
+{
+    SDL_Window *window;
+    SDL_WindowData *window_data;
+
+    // TODO: pointer lock isn't actually enabled yet
+    if (enabled) {
+        window = SDL_GetMouseFocus();
+        if (!window) {
+            return false;
+        }
+
+        window_data = window->internal;
+
+        if (emscripten_request_pointerlock(window_data->canvas_id, 1) >= EMSCRIPTEN_RESULT_SUCCESS) {
+            return true;
+        }
+    } else {
+        if (emscripten_exit_pointerlock() >= EMSCRIPTEN_RESULT_SUCCESS) {
+            return true;
+        }
+    }
+    return false;
+}
+
+void Emscripten_InitMouse(void)
+{
+    SDL_Mouse *mouse = SDL_GetMouse();
+
+    mouse->CreateCursor = Emscripten_CreateCursor;
+    mouse->ShowCursor = Emscripten_ShowCursor;
+    mouse->FreeCursor = Emscripten_FreeCursor;
+    mouse->CreateSystemCursor = Emscripten_CreateSystemCursor;
+    mouse->SetRelativeMouseMode = Emscripten_SetRelativeMouseMode;
+
+    SDL_SetDefaultCursor(Emscripten_CreateDefaultCursor());
+}
+
+void Emscripten_QuitMouse(void)
+{
+}
+
+#endif // SDL_VIDEO_DRIVER_EMSCRIPTEN

vendor/sdl-3.2.10/src/video/emscripten/SDL_emscriptenmouse.h

@@ -0,0 +1,34 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2025 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef SDL_emscriptenmouse_h_
+#define SDL_emscriptenmouse_h_
+
+struct SDL_CursorData
+{
+    const char *system_cursor;
+    bool is_custom;
+};
+
+extern void Emscripten_InitMouse(void);
+extern void Emscripten_QuitMouse(void);
+
+#endif // SDL_emscriptenmouse_h_

vendor/sdl-3.2.10/src/video/emscripten/SDL_emscriptenopengles.c

@@ -0,0 +1,162 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2025 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+#include "SDL_internal.h"
+
+#ifdef SDL_VIDEO_DRIVER_EMSCRIPTEN
+
+#include <emscripten/emscripten.h>
+#include <emscripten/html5_webgl.h>
+#include <GLES2/gl2.h>
+
+#include "SDL_emscriptenvideo.h"
+#include "SDL_emscriptenopengles.h"
+
+bool Emscripten_GLES_LoadLibrary(SDL_VideoDevice *_this, const char *path)
+{
+    return true;
+}
+
+void Emscripten_GLES_UnloadLibrary(SDL_VideoDevice *_this)
+{
+}
+
+SDL_FunctionPointer Emscripten_GLES_GetProcAddress(SDL_VideoDevice *_this, const char *proc)
+{
+    return emscripten_webgl_get_proc_address(proc);
+}
+
+bool Emscripten_GLES_SetSwapInterval(SDL_VideoDevice *_this, int interval)
+{
+    if (interval < 0) {
+        return SDL_SetError("Late swap tearing currently unsupported");
+    }
+
+    if (Emscripten_ShouldSetSwapInterval(interval)) {
+        if (interval == 0) {
+            emscripten_set_main_loop_timing(EM_TIMING_SETTIMEOUT, 0);
+        } else {
+            emscripten_set_main_loop_timing(EM_TIMING_RAF, interval);
+        }
+    }
+
+    return true;
+}
+
+bool Emscripten_GLES_GetSwapInterval(SDL_VideoDevice *_this, int *interval)
+{
+    int mode, value;
+
+    emscripten_get_main_loop_timing(&mode, &value);
+
+    if (mode == EM_TIMING_RAF) {
+        *interval = value;
+        return true;
+    } else {
+        *interval = 0;
+        return true;
+    }
+}
+
+SDL_GLContext Emscripten_GLES_CreateContext(SDL_VideoDevice *_this, SDL_Window *window)
+{
+    SDL_WindowData *window_data;
+
+    EmscriptenWebGLContextAttributes attribs;
+    EMSCRIPTEN_WEBGL_CONTEXT_HANDLE context;
+
+    emscripten_webgl_init_context_attributes(&attribs);
+
+    attribs.alpha = _this->gl_config.alpha_size > 0;
+    attribs.depth = _this->gl_config.depth_size > 0;
+    attribs.stencil = _this->gl_config.stencil_size > 0;
+    attribs.antialias = _this->gl_config.multisamplebuffers == 1;
+
+    if (_this->gl_config.major_version == 3)
+        attribs.majorVersion = 2; // WebGL 2.0 ~= GLES 3.0
+
+    window_data = window->internal;
+
+    if (window_data->gl_context) {
+        SDL_SetError("Cannot create multiple webgl contexts per window");
+        return NULL;
+    }
+
+    context = emscripten_webgl_create_context(window_data->canvas_id, &attribs);
+
+    if (context < 0) {
+        SDL_SetError("Could not create webgl context");
+        return NULL;
+    }
+
+    if (emscripten_webgl_make_context_current(context) != EMSCRIPTEN_RESULT_SUCCESS) {
+        emscripten_webgl_destroy_context(context);
+        return NULL;
+    }
+
+    window_data->gl_context = (SDL_GLContext)context;
+
+    return (SDL_GLContext)context;
+}
+
+bool Emscripten_GLES_DestroyContext(SDL_VideoDevice *_this, SDL_GLContext context)
+{
+    SDL_Window *window;
+
+    // remove the context from its window
+    for (window = _this->windows; window; window = window->next) {
+        SDL_WindowData *window_data = window->internal;
+
+        if (window_data->gl_context == context) {
+            window_data->gl_context = NULL;
+        }
+    }
+
+    emscripten_webgl_destroy_context((EMSCRIPTEN_WEBGL_CONTEXT_HANDLE)context);
+    return true;
+}
+
+bool Emscripten_GLES_SwapWindow(SDL_VideoDevice *_this, SDL_Window *window)
+{
+    if (emscripten_has_asyncify() && SDL_GetHintBoolean(SDL_HINT_EMSCRIPTEN_ASYNCIFY, true)) {
+        // give back control to browser for screen refresh
+        emscripten_sleep(0);
+    }
+    return true;
+}
+
+bool Emscripten_GLES_MakeCurrent(SDL_VideoDevice *_this, SDL_Window *window, SDL_GLContext context)
+{
+    // it isn't possible to reuse contexts across canvases
+    if (window && context) {
+        SDL_WindowData *window_data = window->internal;
+
+        if (context != window_data->gl_context) {
+            return SDL_SetError("Cannot make context current to another window");
+        }
+    }
+
+    if (emscripten_webgl_make_context_current((EMSCRIPTEN_WEBGL_CONTEXT_HANDLE)context) != EMSCRIPTEN_RESULT_SUCCESS) {
+        return SDL_SetError("Unable to make context current");
+    }
+    return true;
+}
+
+#endif // SDL_VIDEO_DRIVER_EMSCRIPTEN

vendor/sdl-3.2.10/src/video/emscripten/SDL_emscriptenopengles.h

@@ -0,0 +1,43 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2025 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+#include "SDL_internal.h"
+
+#ifndef SDL_emscriptenopengles_h_
+#define SDL_emscriptenopengles_h_
+
+#ifdef SDL_VIDEO_DRIVER_EMSCRIPTEN
+
+#include "../SDL_sysvideo.h"
+
+// OpenGLES functions
+extern bool Emscripten_GLES_LoadLibrary(SDL_VideoDevice *_this, const char *path);
+extern void Emscripten_GLES_UnloadLibrary(SDL_VideoDevice *_this);
+extern SDL_FunctionPointer Emscripten_GLES_GetProcAddress(SDL_VideoDevice *_this, const char *proc);
+extern bool Emscripten_GLES_SetSwapInterval(SDL_VideoDevice *_this, int interval);
+extern bool Emscripten_GLES_GetSwapInterval(SDL_VideoDevice *_this, int *interval);
+extern SDL_GLContext Emscripten_GLES_CreateContext(SDL_VideoDevice *_this, SDL_Window *window);
+extern bool Emscripten_GLES_DestroyContext(SDL_VideoDevice *_this, SDL_GLContext context);
+extern bool Emscripten_GLES_SwapWindow(SDL_VideoDevice *_this, SDL_Window *window);
+extern bool Emscripten_GLES_MakeCurrent(SDL_VideoDevice *_this, SDL_Window *window, SDL_GLContext context);
+
+#endif // SDL_VIDEO_DRIVER_EMSCRIPTEN
+
+#endif // SDL_emscriptenopengles_h_

vendor/sdl-3.2.10/src/video/emscripten/SDL_emscriptenvideo.c

@@ -0,0 +1,459 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2025 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+#include "SDL_internal.h"
+
+#ifdef SDL_VIDEO_DRIVER_EMSCRIPTEN
+
+#include "../SDL_sysvideo.h"
+#include "../SDL_pixels_c.h"
+#include "../../events/SDL_events_c.h"
+
+#include "SDL_emscriptenvideo.h"
+#include "SDL_emscriptenopengles.h"
+#include "SDL_emscriptenframebuffer.h"
+#include "SDL_emscriptenevents.h"
+#include "SDL_emscriptenmouse.h"
+
+#define EMSCRIPTENVID_DRIVER_NAME "emscripten"
+
+// Initialization/Query functions
+static bool Emscripten_VideoInit(SDL_VideoDevice *_this);
+static bool Emscripten_SetDisplayMode(SDL_VideoDevice *_this, SDL_VideoDisplay *display, SDL_DisplayMode *mode);
+static void Emscripten_VideoQuit(SDL_VideoDevice *_this);
+static bool Emscripten_GetDisplayUsableBounds(SDL_VideoDevice *_this, SDL_VideoDisplay *display, SDL_Rect *rect);
+
+static bool Emscripten_CreateWindow(SDL_VideoDevice *_this, SDL_Window *window, SDL_PropertiesID create_props);
+static void Emscripten_SetWindowSize(SDL_VideoDevice *_this, SDL_Window *window);
+static void Emscripten_GetWindowSizeInPixels(SDL_VideoDevice *_this, SDL_Window *window, int *w, int *h);
+static void Emscripten_DestroyWindow(SDL_VideoDevice *_this, SDL_Window *window);
+static SDL_FullscreenResult Emscripten_SetWindowFullscreen(SDL_VideoDevice *_this, SDL_Window *window, SDL_VideoDisplay *display, SDL_FullscreenOp fullscreen);
+static void Emscripten_PumpEvents(SDL_VideoDevice *_this);
+static void Emscripten_SetWindowTitle(SDL_VideoDevice *_this, SDL_Window *window);
+
+static bool pumpevents_has_run = false;
+static int pending_swap_interval = -1;
+
+
+// Emscripten driver bootstrap functions
+
+static void Emscripten_DeleteDevice(SDL_VideoDevice *device)
+{
+    SDL_free(device);
+}
+
+static SDL_SystemTheme Emscripten_GetSystemTheme(void)
+{
+    /* Technically, light theme can mean explicit light theme or no preference.
+       https://developer.mozilla.org/en-US/docs/Web/CSS/@media/prefers-color-scheme#syntax */
+
+    int theme_code = EM_ASM_INT({
+        if (!window.matchMedia) {
+            return -1;
+        }
+
+        if (window.matchMedia('(prefers-color-scheme: light)').matches) {
+            return 0;
+        }
+
+        if (window.matchMedia('(prefers-color-scheme: dark)').matches) {
+            return 1;
+        }
+
+        return -1;
+    });
+
+    switch (theme_code) {
+    case 0:
+        return SDL_SYSTEM_THEME_LIGHT;
+
+    case 1:
+        return SDL_SYSTEM_THEME_DARK;
+
+    default:
+        return SDL_SYSTEM_THEME_UNKNOWN;
+    }
+}
+
+static void Emscripten_ListenSystemTheme(void)
+{
+    MAIN_THREAD_EM_ASM({
+        if (window.matchMedia) {
+            if (typeof(Module['SDL3']) === 'undefined') {
+                Module['SDL3'] = {};
+            }
+
+            var SDL3 = Module['SDL3'];
+
+            SDL3.eventHandlerThemeChanged = function(event) {
+                _Emscripten_SendSystemThemeChangedEvent();
+            };
+
+            SDL3.themeChangedMatchMedia = window.matchMedia('(prefers-color-scheme: dark)');
+            SDL3.themeChangedMatchMedia.addEventListener('change', SDL3.eventHandlerThemeChanged);
+        }
+    });
+}
+
+static void Emscripten_UnlistenSystemTheme(void)
+{
+    MAIN_THREAD_EM_ASM({
+        if (typeof(Module['SDL3']) !== 'undefined') {
+            var SDL3 = Module['SDL3'];
+
+            SDL3.themeChangedMatchMedia.removeEventListener('change', SDL3.eventHandlerThemeChanged);
+            SDL3.themeChangedMatchMedia = undefined;
+            SDL3.eventHandlerThemeChanged = undefined;
+        }
+    });
+}
+
+EMSCRIPTEN_KEEPALIVE void Emscripten_SendSystemThemeChangedEvent(void)
+{
+    SDL_SetSystemTheme(Emscripten_GetSystemTheme());
+}
+
+static SDL_VideoDevice *Emscripten_CreateDevice(void)
+{
+    SDL_VideoDevice *device;
+
+    // Initialize all variables that we clean on shutdown
+    device = (SDL_VideoDevice *)SDL_calloc(1, sizeof(SDL_VideoDevice));
+    if (!device) {
+        return NULL;
+    }
+
+    /* Firefox sends blur event which would otherwise prevent full screen
+     * when the user clicks to allow full screen.
+     * See https://bugzilla.mozilla.org/show_bug.cgi?id=1144964
+     */
+    SDL_SetHint(SDL_HINT_VIDEO_MINIMIZE_ON_FOCUS_LOSS, "0");
+
+    // Set the function pointers
+    device->VideoInit = Emscripten_VideoInit;
+    device->VideoQuit = Emscripten_VideoQuit;
+    device->GetDisplayUsableBounds = Emscripten_GetDisplayUsableBounds;
+    device->SetDisplayMode = Emscripten_SetDisplayMode;
+
+    device->PumpEvents = Emscripten_PumpEvents;
+
+    device->CreateSDLWindow = Emscripten_CreateWindow;
+    device->SetWindowTitle = Emscripten_SetWindowTitle;
+    /*device->SetWindowIcon = Emscripten_SetWindowIcon;
+    device->SetWindowPosition = Emscripten_SetWindowPosition;*/
+    device->SetWindowSize = Emscripten_SetWindowSize;
+    /*device->ShowWindow = Emscripten_ShowWindow;
+    device->HideWindow = Emscripten_HideWindow;
+    device->RaiseWindow = Emscripten_RaiseWindow;
+    device->MaximizeWindow = Emscripten_MaximizeWindow;
+    device->MinimizeWindow = Emscripten_MinimizeWindow;
+    device->RestoreWindow = Emscripten_RestoreWindow;
+    device->SetWindowMouseGrab = Emscripten_SetWindowMouseGrab;*/
+    device->GetWindowSizeInPixels = Emscripten_GetWindowSizeInPixels;
+    device->DestroyWindow = Emscripten_DestroyWindow;
+    device->SetWindowFullscreen = Emscripten_SetWindowFullscreen;
+
+    device->CreateWindowFramebuffer = Emscripten_CreateWindowFramebuffer;
+    device->UpdateWindowFramebuffer = Emscripten_UpdateWindowFramebuffer;
+    device->DestroyWindowFramebuffer = Emscripten_DestroyWindowFramebuffer;
+
+    device->GL_LoadLibrary = Emscripten_GLES_LoadLibrary;
+    device->GL_GetProcAddress = Emscripten_GLES_GetProcAddress;
+    device->GL_UnloadLibrary = Emscripten_GLES_UnloadLibrary;
+    device->GL_CreateContext = Emscripten_GLES_CreateContext;
+    device->GL_MakeCurrent = Emscripten_GLES_MakeCurrent;
+    device->GL_SetSwapInterval = Emscripten_GLES_SetSwapInterval;
+    device->GL_GetSwapInterval = Emscripten_GLES_GetSwapInterval;
+    device->GL_SwapWindow = Emscripten_GLES_SwapWindow;
+    device->GL_DestroyContext = Emscripten_GLES_DestroyContext;
+
+    device->free = Emscripten_DeleteDevice;
+
+    Emscripten_ListenSystemTheme();
+    device->system_theme = Emscripten_GetSystemTheme();
+
+    return device;
+}
+
+VideoBootStrap Emscripten_bootstrap = {
+    EMSCRIPTENVID_DRIVER_NAME, "SDL emscripten video driver",
+    Emscripten_CreateDevice,
+    NULL, // no ShowMessageBox implementation
+    false
+};
+
+bool Emscripten_VideoInit(SDL_VideoDevice *_this)
+{
+    SDL_DisplayMode mode;
+
+    // Use a fake 32-bpp desktop mode
+    SDL_zero(mode);
+    mode.format = SDL_PIXELFORMAT_XRGB8888;
+    emscripten_get_screen_size(&mode.w, &mode.h);
+    mode.pixel_density = emscripten_get_device_pixel_ratio();
+
+    if (SDL_AddBasicVideoDisplay(&mode) == 0) {
+        return false;
+    }
+
+    Emscripten_InitMouse();
+
+    // Assume we have a mouse and keyboard
+    SDL_AddKeyboard(SDL_DEFAULT_KEYBOARD_ID, NULL, false);
+    SDL_AddMouse(SDL_DEFAULT_MOUSE_ID, NULL, false);
+
+    // We're done!
+    return true;
+}
+
+static bool Emscripten_SetDisplayMode(SDL_VideoDevice *_this, SDL_VideoDisplay *display, SDL_DisplayMode *mode)
+{
+    // can't do this
+    return true;
+}
+
+static void Emscripten_VideoQuit(SDL_VideoDevice *_this)
+{
+    Emscripten_QuitMouse();
+    Emscripten_UnlistenSystemTheme();
+    pumpevents_has_run = false;
+    pending_swap_interval = -1;
+}
+
+static bool Emscripten_GetDisplayUsableBounds(SDL_VideoDevice *_this, SDL_VideoDisplay *display, SDL_Rect *rect)
+{
+    if (rect) {
+        rect->x = 0;
+        rect->y = 0;
+        rect->w = MAIN_THREAD_EM_ASM_INT({
+            return window.innerWidth;
+        });
+        rect->h = MAIN_THREAD_EM_ASM_INT({
+            return window.innerHeight;
+        });
+    }
+    return true;
+}
+
+bool Emscripten_ShouldSetSwapInterval(int interval)
+{
+    if (!pumpevents_has_run) {
+        pending_swap_interval = interval;
+        return false;
+    }
+    return true;
+}
+
+static void Emscripten_PumpEvents(SDL_VideoDevice *_this)
+{
+    if (!pumpevents_has_run) {
+        // we assume you've set a mainloop by the time you've called pumpevents, so we delay initial SetInterval changes until then.
+        // otherwise you'll get a warning on the javascript console.
+        pumpevents_has_run = true;
+        if (pending_swap_interval >= 0) {
+            Emscripten_GLES_SetSwapInterval(_this, pending_swap_interval);
+            pending_swap_interval = -1;
+        }
+    }
+}
+
+EMSCRIPTEN_KEEPALIVE void requestFullscreenThroughSDL(SDL_Window *window)
+{
+    SDL_SetWindowFullscreen(window, true);
+}
+
+static bool Emscripten_CreateWindow(SDL_VideoDevice *_this, SDL_Window *window, SDL_PropertiesID props)
+{
+    SDL_WindowData *wdata;
+    double scaled_w, scaled_h;
+    double css_w, css_h;
+    const char *selector;
+
+    // Allocate window internal data
+    wdata = (SDL_WindowData *)SDL_calloc(1, sizeof(SDL_WindowData));
+    if (!wdata) {
+        return false;
+    }
+
+    selector = SDL_GetHint(SDL_HINT_EMSCRIPTEN_CANVAS_SELECTOR);
+    if (!selector) {
+        selector = "#canvas";
+    }
+
+    wdata->canvas_id = SDL_strdup(selector);
+
+    if (window->flags & SDL_WINDOW_HIGH_PIXEL_DENSITY) {
+        wdata->pixel_ratio = emscripten_get_device_pixel_ratio();
+    } else {
+        wdata->pixel_ratio = 1.0f;
+    }
+
+    scaled_w = SDL_floor(window->w * wdata->pixel_ratio);
+    scaled_h = SDL_floor(window->h * wdata->pixel_ratio);
+
+    // set a fake size to check if there is any CSS sizing the canvas
+    emscripten_set_canvas_element_size(wdata->canvas_id, 1, 1);
+    emscripten_get_element_css_size(wdata->canvas_id, &css_w, &css_h);
+
+    wdata->external_size = SDL_floor(css_w) != 1 || SDL_floor(css_h) != 1;
+
+    if ((window->flags & SDL_WINDOW_RESIZABLE) && wdata->external_size) {
+        // external css has resized us
+        scaled_w = css_w * wdata->pixel_ratio;
+        scaled_h = css_h * wdata->pixel_ratio;
+
+        SDL_SendWindowEvent(window, SDL_EVENT_WINDOW_RESIZED, SDL_lroundf(css_w), SDL_lroundf(css_h));
+    }
+    emscripten_set_canvas_element_size(wdata->canvas_id, SDL_lroundf(scaled_w), SDL_lroundf(scaled_h));
+
+    // if the size is not being controlled by css, we need to scale down for hidpi
+    if (!wdata->external_size) {
+        if (wdata->pixel_ratio != 1.0f) {
+            // scale canvas down
+            emscripten_set_element_css_size(wdata->canvas_id, window->w, window->h);
+        }
+    }
+
+    wdata->window = window;
+
+    // Setup driver data for this window
+    window->internal = wdata;
+
+    // One window, it always has focus
+    SDL_SetMouseFocus(window);
+    SDL_SetKeyboardFocus(window);
+
+    Emscripten_RegisterEventHandlers(wdata);
+
+    // disable the emscripten "fullscreen" button.
+    MAIN_THREAD_EM_ASM({
+        Module['requestFullscreen'] = function(lockPointer, resizeCanvas) {
+            _requestFullscreenThroughSDL($0);
+        };
+    }, window);
+
+    // Window has been successfully created
+    return true;
+}
+
+static void Emscripten_SetWindowSize(SDL_VideoDevice *_this, SDL_Window *window)
+{
+    SDL_WindowData *data;
+
+    if (window->internal) {
+        data = window->internal;
+        // update pixel ratio
+        if (window->flags & SDL_WINDOW_HIGH_PIXEL_DENSITY) {
+            data->pixel_ratio = emscripten_get_device_pixel_ratio();
+        }
+        emscripten_set_canvas_element_size(data->canvas_id, SDL_lroundf(window->pending.w * data->pixel_ratio), SDL_lroundf(window->pending.h * data->pixel_ratio));
+
+        // scale canvas down
+        if (!data->external_size && data->pixel_ratio != 1.0f) {
+            emscripten_set_element_css_size(data->canvas_id, window->pending.w, window->pending.h);
+        }
+
+        SDL_SendWindowEvent(window, SDL_EVENT_WINDOW_RESIZED, window->pending.w, window->pending.h);
+    }
+}
+
+static void Emscripten_GetWindowSizeInPixels(SDL_VideoDevice *_this, SDL_Window *window, int *w, int *h)
+{
+    SDL_WindowData *data;
+    if (window->internal) {
+        data = window->internal;
+        *w = SDL_lroundf(window->w * data->pixel_ratio);
+        *h = SDL_lroundf(window->h * data->pixel_ratio);
+    }
+}
+
+static void Emscripten_DestroyWindow(SDL_VideoDevice *_this, SDL_Window *window)
+{
+    SDL_WindowData *data;
+
+    if (window->internal) {
+        data = window->internal;
+
+        Emscripten_UnregisterEventHandlers(data);
+
+        // We can't destroy the canvas, so resize it to zero instead
+        emscripten_set_canvas_element_size(data->canvas_id, 0, 0);
+        SDL_free(data->canvas_id);
+
+        SDL_free(window->internal);
+        window->internal = NULL;
+    }
+
+    // just ignore clicks on the fullscreen button while there's no SDL window.
+    MAIN_THREAD_EM_ASM({ Module['requestFullscreen'] = function(lockPointer, resizeCanvas) {}; });
+}
+
+static SDL_FullscreenResult Emscripten_SetWindowFullscreen(SDL_VideoDevice *_this, SDL_Window *window, SDL_VideoDisplay *display, SDL_FullscreenOp fullscreen)
+{
+    SDL_WindowData *data;
+    int res = -1;
+
+    if (window->internal) {
+        data = window->internal;
+
+        if (fullscreen) {
+            EmscriptenFullscreenStrategy strategy;
+            bool is_fullscreen_desktop = !window->fullscreen_exclusive;
+
+            SDL_zero(strategy);
+            strategy.scaleMode = is_fullscreen_desktop ? EMSCRIPTEN_FULLSCREEN_SCALE_STRETCH : EMSCRIPTEN_FULLSCREEN_SCALE_ASPECT;
+
+            if (!is_fullscreen_desktop) {
+                strategy.canvasResolutionScaleMode = EMSCRIPTEN_FULLSCREEN_CANVAS_SCALE_NONE;
+            } else if (window->flags & SDL_WINDOW_HIGH_PIXEL_DENSITY) {
+                strategy.canvasResolutionScaleMode = EMSCRIPTEN_FULLSCREEN_CANVAS_SCALE_HIDEF;
+            } else {
+                strategy.canvasResolutionScaleMode = EMSCRIPTEN_FULLSCREEN_CANVAS_SCALE_STDDEF;
+            }
+
+            strategy.filteringMode = EMSCRIPTEN_FULLSCREEN_FILTERING_DEFAULT;
+
+            strategy.canvasResizedCallback = Emscripten_HandleCanvasResize;
+            strategy.canvasResizedCallbackUserData = data;
+
+            data->fullscreen_mode_flags = (window->flags & SDL_WINDOW_FULLSCREEN);
+            data->fullscreen_resize = is_fullscreen_desktop;
+
+            res = emscripten_request_fullscreen_strategy(data->canvas_id, 1, &strategy);
+        } else {
+            res = emscripten_exit_fullscreen();
+        }
+    }
+
+    if (res == EMSCRIPTEN_RESULT_SUCCESS) {
+        return SDL_FULLSCREEN_SUCCEEDED;
+    } else if (res == EMSCRIPTEN_RESULT_DEFERRED) {
+        return SDL_FULLSCREEN_PENDING;
+    } else {
+        return SDL_FULLSCREEN_FAILED;
+    }
+}
+
+static void Emscripten_SetWindowTitle(SDL_VideoDevice *_this, SDL_Window *window)
+{
+    emscripten_set_window_title(window->title);
+}
+
+#endif // SDL_VIDEO_DRIVER_EMSCRIPTEN

vendor/sdl-3.2.10/src/video/emscripten/SDL_emscriptenvideo.h

@@ -0,0 +1,54 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2025 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+#include "SDL_internal.h"
+
+#ifndef SDL_emscriptenvideo_h_
+#define SDL_emscriptenvideo_h_
+
+#include "../SDL_sysvideo.h"
+#include "../../events/SDL_touch_c.h"
+#include <emscripten/emscripten.h>
+#include <emscripten/html5.h>
+
+struct SDL_WindowData
+{
+    SDL_Window *window;
+    SDL_Surface *surface;
+
+    SDL_GLContext gl_context;
+
+    char *canvas_id;
+
+    float pixel_ratio;
+
+    bool external_size;
+
+    Uint32 fullscreen_mode_flags;
+    bool fullscreen_resize;
+
+    bool has_pointer_lock;
+
+    bool mouse_focus_loss_pending;
+};
+
+bool Emscripten_ShouldSetSwapInterval(int interval);
+
+#endif // SDL_emscriptenvideo_h_