Merge commit 'dec0d4ec4153bf9fc2b78ae6c2df45b6ea8dde7a' as 'external/sdl/SDL'

external/sdl/SDL/src/video/emscripten/SDL_emscriptenevents.h

@@ -0,0 +1,31 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2023 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_ */

external/sdl/SDL/src/video/emscripten/SDL_emscriptenframebuffer.c

@@ -0,0 +1,161 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2023 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>
+
+int Emscripten_CreateWindowFramebuffer(SDL_VideoDevice *_this, SDL_Window *window, Uint32 *format, void **pixels, int *pitch)
+{
+    SDL_Surface *surface;
+    const Uint32 surface_format = SDL_PIXELFORMAT_XBGR8888;
+    int w, h;
+
+    /* Free the old framebuffer surface */
+    SDL_WindowData *data = window->driverdata;
+    surface = data->surface;
+    SDL_DestroySurface(surface);
+
+    /* Create a new one */
+    SDL_GetWindowSizeInPixels(window, &w, &h);
+
+    surface = SDL_CreateSurface(w, h, surface_format);
+    if (surface == NULL) {
+        return -1;
+    }
+
+    /* Save the info and return! */
+    data->surface = surface;
+    *format = surface_format;
+    *pixels = surface->pixels;
+    *pitch = surface->pitch;
+    return 0;
+}
+
+int Emscripten_UpdateWindowFramebuffer(SDL_VideoDevice *_this, SDL_Window *window, const SDL_Rect *rects, int numrects)
+{
+    SDL_Surface *surface;
+
+    SDL_WindowData *data = window->driverdata;
+    surface = data->surface;
+    if (surface == NULL) {
+        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 >> 2;
+        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, SDL_TRUE)) {
+        /* give back control to browser for screen refresh */
+        emscripten_sleep(0);
+    }
+
+    return 0;
+}
+
+void Emscripten_DestroyWindowFramebuffer(SDL_VideoDevice *_this, SDL_Window *window)
+{
+    SDL_WindowData *data = window->driverdata;
+
+    SDL_DestroySurface(data->surface);
+    data->surface = NULL;
+}
+
+#endif /* SDL_VIDEO_DRIVER_EMSCRIPTEN */

external/sdl/SDL/src/video/emscripten/SDL_emscriptenframebuffer.h

@@ -0,0 +1,30 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2023 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 int Emscripten_CreateWindowFramebuffer(SDL_VideoDevice *_this, SDL_Window *window, Uint32 *format, void **pixels, int *pitch);
+extern int 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_ */

external/sdl/SDL/src/video/emscripten/SDL_emscriptenmouse.c

@@ -0,0 +1,251 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2023 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 "../../events/SDL_mouse_c.h"
+
+static SDL_Cursor *Emscripten_CreateCursorFromString(const char *cursor_str, SDL_bool is_custom)
+{
+    SDL_Cursor *cursor;
+    Emscripten_CursorData *curdata;
+
+    cursor = SDL_calloc(1, sizeof(SDL_Cursor));
+    if (cursor) {
+        curdata = (Emscripten_CursorData *)SDL_calloc(1, sizeof(*curdata));
+        if (curdata == NULL) {
+            SDL_OutOfMemory();
+            SDL_free(cursor);
+            return NULL;
+        }
+
+        curdata->system_cursor = cursor_str;
+        curdata->is_custom = is_custom;
+        cursor->driverdata = curdata;
+    } else {
+        SDL_OutOfMemory();
+    }
+
+    return cursor;
+}
+
+static SDL_Cursor *Emscripten_CreateDefaultCursor()
+{
+    return Emscripten_CreateCursorFromString("default", SDL_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_ConvertSurfaceFormat(surface, SDL_PIXELFORMAT_ABGR8888);
+
+    if (conv_surf == NULL) {
+        return NULL;
+    }
+
+    /* *INDENT-OFF* */ /* clang-format off */
+    cursor_url = (const char *)MAIN_THREAD_EM_ASM_INT({
+        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 >> 2;
+
+        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 = _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, SDL_TRUE);
+}
+
+static SDL_Cursor *Emscripten_CreateSystemCursor(SDL_SystemCursor id)
+{
+    const char *cursor_name = NULL;
+
+    switch (id) {
+    case SDL_SYSTEM_CURSOR_ARROW:
+        cursor_name = "default";
+        break;
+    case SDL_SYSTEM_CURSOR_IBEAM:
+        cursor_name = "text";
+        break;
+    case SDL_SYSTEM_CURSOR_WAIT:
+        cursor_name = "wait";
+        break;
+    case SDL_SYSTEM_CURSOR_CROSSHAIR:
+        cursor_name = "crosshair";
+        break;
+    case SDL_SYSTEM_CURSOR_WAITARROW:
+        cursor_name = "progress";
+        break;
+    case SDL_SYSTEM_CURSOR_SIZENWSE:
+        cursor_name = "nwse-resize";
+        break;
+    case SDL_SYSTEM_CURSOR_SIZENESW:
+        cursor_name = "nesw-resize";
+        break;
+    case SDL_SYSTEM_CURSOR_SIZEWE:
+        cursor_name = "ew-resize";
+        break;
+    case SDL_SYSTEM_CURSOR_SIZENS:
+        cursor_name = "ns-resize";
+        break;
+    case SDL_SYSTEM_CURSOR_SIZEALL:
+        cursor_name = "move";
+        break;
+    case SDL_SYSTEM_CURSOR_NO:
+        cursor_name = "not-allowed";
+        break;
+    case SDL_SYSTEM_CURSOR_HAND:
+        cursor_name = "pointer";
+        break;
+    default:
+        SDL_assert(0);
+        return NULL;
+    }
+
+    return Emscripten_CreateCursorFromString(cursor_name, SDL_FALSE);
+}
+
+static void Emscripten_FreeCursor(SDL_Cursor *cursor)
+{
+    Emscripten_CursorData *curdata;
+    if (cursor) {
+        curdata = (Emscripten_CursorData *)cursor->driverdata;
+
+        if (curdata != NULL) {
+            if (curdata->is_custom) {
+                SDL_free((char *)curdata->system_cursor);
+            }
+            SDL_free(cursor->driverdata);
+        }
+
+        SDL_free(cursor);
+    }
+}
+
+static int Emscripten_ShowCursor(SDL_Cursor *cursor)
+{
+    Emscripten_CursorData *curdata;
+    if (SDL_GetMouseFocus() != NULL) {
+        if (cursor && cursor->driverdata) {
+            curdata = (Emscripten_CursorData *)cursor->driverdata;
+
+            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 0;
+}
+
+static int Emscripten_SetRelativeMouseMode(SDL_bool enabled)
+{
+    SDL_Window *window;
+    SDL_WindowData *window_data;
+
+    /* TODO: pointer lock isn't actually enabled yet */
+    if (enabled) {
+        window = SDL_GetMouseFocus();
+        if (window == NULL) {
+            return -1;
+        }
+
+        window_data = window->driverdata;
+
+        if (emscripten_request_pointerlock(window_data->canvas_id, 1) >= EMSCRIPTEN_RESULT_SUCCESS) {
+            return 0;
+        }
+    } else {
+        if (emscripten_exit_pointerlock() >= EMSCRIPTEN_RESULT_SUCCESS) {
+            return 0;
+        }
+    }
+    return -1;
+}
+
+void Emscripten_InitMouse()
+{
+    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_FiniMouse()
+{
+}
+
+#endif /* SDL_VIDEO_DRIVER_EMSCRIPTEN */

external/sdl/SDL/src/video/emscripten/SDL_emscriptenmouse.h

@@ -0,0 +1,37 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2023 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_
+
+typedef struct _Emscripten_CursorData
+{
+    const char *system_cursor;
+    SDL_bool is_custom;
+} Emscripten_CursorData;
+
+extern void
+Emscripten_InitMouse();
+
+extern void
+Emscripten_FiniMouse();
+
+#endif /* SDL_emscriptenmouse_h_ */

external/sdl/SDL/src/video/emscripten/SDL_emscriptenopengles.c

@@ -0,0 +1,158 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2023 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"
+
+int Emscripten_GLES_LoadLibrary(SDL_VideoDevice *_this, const char *path)
+{
+    return 0;
+}
+
+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);
+}
+
+int Emscripten_GLES_SetSwapInterval(SDL_VideoDevice *_this, int interval)
+{
+    if (interval < 0) {
+        return SDL_SetError("Late swap tearing currently unsupported");
+    } else if (interval == 0) {
+        emscripten_set_main_loop_timing(EM_TIMING_SETTIMEOUT, 0);
+    } else {
+        emscripten_set_main_loop_timing(EM_TIMING_RAF, interval);
+    }
+
+    return 0;
+}
+
+int 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 0;
+    } else {
+        *interval = 0;
+        return 0;
+    }
+}
+
+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->driverdata;
+
+    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;
+}
+
+int Emscripten_GLES_DeleteContext(SDL_VideoDevice *_this, SDL_GLContext context)
+{
+    SDL_Window *window;
+
+    /* remove the context from its window */
+    for (window = _this->windows; window != NULL; window = window->next) {
+        SDL_WindowData *window_data = window->driverdata;
+
+        if (window_data->gl_context == context) {
+            window_data->gl_context = NULL;
+        }
+    }
+
+    emscripten_webgl_destroy_context((EMSCRIPTEN_WEBGL_CONTEXT_HANDLE)context);
+    return 0;
+}
+
+int Emscripten_GLES_SwapWindow(SDL_VideoDevice *_this, SDL_Window *window)
+{
+    if (emscripten_has_asyncify() && SDL_GetHintBoolean(SDL_HINT_EMSCRIPTEN_ASYNCIFY, SDL_TRUE)) {
+        /* give back control to browser for screen refresh */
+        emscripten_sleep(0);
+    }
+    return 0;
+}
+
+int 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->driverdata;
+
+        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 0;
+}
+
+#endif /* SDL_VIDEO_DRIVER_EMSCRIPTEN */

external/sdl/SDL/src/video/emscripten/SDL_emscriptenopengles.h

@@ -0,0 +1,43 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2023 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 int 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 int Emscripten_GLES_SetSwapInterval(SDL_VideoDevice *_this, int interval);
+extern int Emscripten_GLES_GetSwapInterval(SDL_VideoDevice *_this, int *interval);
+extern SDL_GLContext Emscripten_GLES_CreateContext(SDL_VideoDevice *_this, SDL_Window *window);
+extern int Emscripten_GLES_DeleteContext(SDL_VideoDevice *_this, SDL_GLContext context);
+extern int Emscripten_GLES_SwapWindow(SDL_VideoDevice *_this, SDL_Window *window);
+extern int Emscripten_GLES_MakeCurrent(SDL_VideoDevice *_this, SDL_Window *window, SDL_GLContext context);
+
+#endif /* SDL_VIDEO_DRIVER_EMSCRIPTEN */
+
+#endif /* SDL_emscriptenopengles_h_ */

external/sdl/SDL/src/video/emscripten/SDL_emscriptenvideo.c

@@ -0,0 +1,332 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2023 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 int Emscripten_VideoInit(SDL_VideoDevice *_this);
+static int Emscripten_SetDisplayMode(SDL_VideoDevice *_this, SDL_VideoDisplay *display, SDL_DisplayMode *mode);
+static void Emscripten_VideoQuit(SDL_VideoDevice *_this);
+static int Emscripten_GetDisplayUsableBounds(SDL_VideoDevice *_this, SDL_VideoDisplay *display, SDL_Rect *rect);
+
+static int Emscripten_CreateWindow(SDL_VideoDevice *_this, SDL_Window *window);
+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 void Emscripten_SetWindowFullscreen(SDL_VideoDevice *_this, SDL_Window *window, SDL_VideoDisplay *display, SDL_bool fullscreen);
+static void Emscripten_PumpEvents(SDL_VideoDevice *_this);
+static void Emscripten_SetWindowTitle(SDL_VideoDevice *_this, SDL_Window *window);
+
+/* Emscripten driver bootstrap functions */
+
+static void Emscripten_DeleteDevice(SDL_VideoDevice *device)
+{
+    SDL_free(device);
+}
+
+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 == NULL) {
+        SDL_OutOfMemory();
+        return 0;
+    }
+
+    /* 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_DeleteContext = Emscripten_GLES_DeleteContext;
+
+    device->free = Emscripten_DeleteDevice;
+
+    return device;
+}
+
+VideoBootStrap Emscripten_bootstrap = {
+    EMSCRIPTENVID_DRIVER_NAME, "SDL emscripten video driver",
+    Emscripten_CreateDevice
+};
+
+int 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 -1;
+    }
+
+    Emscripten_InitMouse();
+
+    /* We're done! */
+    return 0;
+}
+
+static int Emscripten_SetDisplayMode(SDL_VideoDevice *_this, SDL_VideoDisplay *display, SDL_DisplayMode *mode)
+{
+    /* can't do this */
+    return 0;
+}
+
+static void Emscripten_VideoQuit(SDL_VideoDevice *_this)
+{
+    Emscripten_FiniMouse();
+}
+
+static int 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 0;
+}
+
+static void Emscripten_PumpEvents(SDL_VideoDevice *_this)
+{
+    /* do nothing. */
+}
+
+static int Emscripten_CreateWindow(SDL_VideoDevice *_this, SDL_Window *window)
+{
+    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 == NULL) {
+        return SDL_OutOfMemory();
+    }
+
+    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, css_w, css_h);
+    }
+    emscripten_set_canvas_element_size(wdata->canvas_id, scaled_w, 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->driverdata = wdata;
+
+    /* One window, it always has focus */
+    SDL_SetMouseFocus(window);
+    SDL_SetKeyboardFocus(window);
+
+    Emscripten_RegisterEventHandlers(wdata);
+
+    /* Window has been successfully created */
+    return 0;
+}
+
+static void Emscripten_SetWindowSize(SDL_VideoDevice *_this, SDL_Window *window)
+{
+    SDL_WindowData *data;
+
+    if (window->driverdata) {
+        data = window->driverdata;
+        /* 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, window->w * data->pixel_ratio, window->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->w, window->h);
+        }
+    }
+}
+
+static void Emscripten_GetWindowSizeInPixels(SDL_VideoDevice *_this, SDL_Window *window, int *w, int *h)
+{
+    SDL_WindowData *data;
+    if (window->driverdata) {
+        data = window->driverdata;
+        *w = window->w * data->pixel_ratio;
+        *h = window->h * data->pixel_ratio;
+    }
+}
+
+static void Emscripten_DestroyWindow(SDL_VideoDevice *_this, SDL_Window *window)
+{
+    SDL_WindowData *data;
+
+    if (window->driverdata) {
+        data = window->driverdata;
+
+        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->driverdata);
+        window->driverdata = NULL;
+    }
+}
+
+static void Emscripten_SetWindowFullscreen(SDL_VideoDevice *_this, SDL_Window *window, SDL_VideoDisplay *display, SDL_bool fullscreen)
+{
+    SDL_WindowData *data;
+    if (window->driverdata) {
+        data = window->driverdata;
+
+        if (fullscreen) {
+            EmscriptenFullscreenStrategy strategy;
+            SDL_bool is_fullscreen_desktop = window->fullscreen_exclusive ? SDL_FALSE : SDL_TRUE;
+            int res;
+
+            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);
+            if (res != EMSCRIPTEN_RESULT_SUCCESS && res != EMSCRIPTEN_RESULT_DEFERRED) {
+                /* unset flags, fullscreen failed */
+                window->flags &= ~SDL_WINDOW_FULLSCREEN;
+            }
+        } else
+            emscripten_exit_fullscreen();
+    }
+}
+
+static void Emscripten_SetWindowTitle(SDL_VideoDevice *_this, SDL_Window *window)
+{
+    emscripten_set_window_title(window->title);
+}
+
+#endif /* SDL_VIDEO_DRIVER_EMSCRIPTEN */

external/sdl/SDL/src/video/emscripten/SDL_emscriptenvideo.h

@@ -0,0 +1,50 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2023 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;
+
+    SDL_bool external_size;
+
+    Uint32 fullscreen_mode_flags;
+    SDL_bool fullscreen_resize;
+
+    SDL_bool has_pointer_lock;
+};
+
+#endif /* SDL_emscriptenvideo_h_ */