sdl

FORK: Simple Directmedia Layer
git clone https://git.neptards.moe/neptards/sdl.git
Log | Files | Refs

SDL_emscriptenvideo.c (12011B)

      1 /*
      2   Simple DirectMedia Layer
      3   Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
      4 
      5   This software is provided 'as-is', without any express or implied
      6   warranty.  In no event will the authors be held liable for any damages
      7   arising from the use of this software.
      8 
      9   Permission is granted to anyone to use this software for any purpose,
     10   including commercial applications, and to alter it and redistribute it
     11   freely, subject to the following restrictions:
     12 
     13   1. The origin of this software must not be misrepresented; you must not
     14      claim that you wrote the original software. If you use this software
     15      in a product, an acknowledgment in the product documentation would be
     16      appreciated but is not required.
     17   2. Altered source versions must be plainly marked as such, and must not be
     18      misrepresented as being the original software.
     19   3. This notice may not be removed or altered from any source distribution.
     20 */
     21 #include "../../SDL_internal.h"
     22 
     23 #if SDL_VIDEO_DRIVER_EMSCRIPTEN
     24 
     25 #include "SDL_video.h"
     26 #include "SDL_mouse.h"
     27 #include "SDL_hints.h"
     28 #include "../SDL_sysvideo.h"
     29 #include "../SDL_pixels_c.h"
     30 #include "../SDL_egl_c.h"
     31 #include "../../events/SDL_events_c.h"
     32 
     33 #include "SDL_emscriptenvideo.h"
     34 #include "SDL_emscriptenopengles.h"
     35 #include "SDL_emscriptenframebuffer.h"
     36 #include "SDL_emscriptenevents.h"
     37 #include "SDL_emscriptenmouse.h"
     38 
     39 #define EMSCRIPTENVID_DRIVER_NAME "emscripten"
     40 
     41 /* Initialization/Query functions */
     42 static int Emscripten_VideoInit(_THIS);
     43 static int Emscripten_SetDisplayMode(_THIS, SDL_VideoDisplay * display, SDL_DisplayMode * mode);
     44 static void Emscripten_VideoQuit(_THIS);
     45 static int Emscripten_GetDisplayUsableBounds(_THIS, SDL_VideoDisplay * display, SDL_Rect * rect);
     46 
     47 static int Emscripten_CreateWindow(_THIS, SDL_Window * window);
     48 static void Emscripten_SetWindowSize(_THIS, SDL_Window * window);
     49 static void Emscripten_DestroyWindow(_THIS, SDL_Window * window);
     50 static void Emscripten_SetWindowFullscreen(_THIS, SDL_Window * window, SDL_VideoDisplay * display, SDL_bool fullscreen);
     51 static void Emscripten_PumpEvents(_THIS);
     52 static void Emscripten_SetWindowTitle(_THIS, SDL_Window * window);
     53 
     54 
     55 /* Emscripten driver bootstrap functions */
     56 
     57 static void
     58 Emscripten_DeleteDevice(SDL_VideoDevice * device)
     59 {
     60     SDL_free(device);
     61 }
     62 
     63 static SDL_VideoDevice *
     64 Emscripten_CreateDevice(int devindex)
     65 {
     66     SDL_VideoDevice *device;
     67 
     68     /* Initialize all variables that we clean on shutdown */
     69     device = (SDL_VideoDevice *) SDL_calloc(1, sizeof(SDL_VideoDevice));
     70     if (!device) {
     71         SDL_OutOfMemory();
     72         return (0);
     73     }
     74 
     75     /* Firefox sends blur event which would otherwise prevent full screen
     76      * when the user clicks to allow full screen.
     77      * See https://bugzilla.mozilla.org/show_bug.cgi?id=1144964
     78     */
     79     SDL_SetHint(SDL_HINT_VIDEO_MINIMIZE_ON_FOCUS_LOSS, "0");
     80 
     81     /* Set the function pointers */
     82     device->VideoInit = Emscripten_VideoInit;
     83     device->VideoQuit = Emscripten_VideoQuit;
     84     device->GetDisplayUsableBounds = Emscripten_GetDisplayUsableBounds;
     85     device->SetDisplayMode = Emscripten_SetDisplayMode;
     86 
     87 
     88     device->PumpEvents = Emscripten_PumpEvents;
     89 
     90     device->CreateSDLWindow = Emscripten_CreateWindow;
     91     device->SetWindowTitle = Emscripten_SetWindowTitle;
     92     /*device->SetWindowIcon = Emscripten_SetWindowIcon;
     93     device->SetWindowPosition = Emscripten_SetWindowPosition;*/
     94     device->SetWindowSize = Emscripten_SetWindowSize;
     95     /*device->ShowWindow = Emscripten_ShowWindow;
     96     device->HideWindow = Emscripten_HideWindow;
     97     device->RaiseWindow = Emscripten_RaiseWindow;
     98     device->MaximizeWindow = Emscripten_MaximizeWindow;
     99     device->MinimizeWindow = Emscripten_MinimizeWindow;
    100     device->RestoreWindow = Emscripten_RestoreWindow;
    101     device->SetWindowGrab = Emscripten_SetWindowGrab;*/
    102     device->DestroyWindow = Emscripten_DestroyWindow;
    103     device->SetWindowFullscreen = Emscripten_SetWindowFullscreen;
    104 
    105     device->CreateWindowFramebuffer = Emscripten_CreateWindowFramebuffer;
    106     device->UpdateWindowFramebuffer = Emscripten_UpdateWindowFramebuffer;
    107     device->DestroyWindowFramebuffer = Emscripten_DestroyWindowFramebuffer;
    108 
    109 #if SDL_VIDEO_OPENGL_EGL
    110     device->GL_LoadLibrary = Emscripten_GLES_LoadLibrary;
    111     device->GL_GetProcAddress = Emscripten_GLES_GetProcAddress;
    112     device->GL_UnloadLibrary = Emscripten_GLES_UnloadLibrary;
    113     device->GL_CreateContext = Emscripten_GLES_CreateContext;
    114     device->GL_MakeCurrent = Emscripten_GLES_MakeCurrent;
    115     device->GL_SetSwapInterval = Emscripten_GLES_SetSwapInterval;
    116     device->GL_GetSwapInterval = Emscripten_GLES_GetSwapInterval;
    117     device->GL_SwapWindow = Emscripten_GLES_SwapWindow;
    118     device->GL_DeleteContext = Emscripten_GLES_DeleteContext;
    119     device->GL_GetDrawableSize = Emscripten_GLES_GetDrawableSize;
    120 #endif
    121 
    122     device->free = Emscripten_DeleteDevice;
    123 
    124     return device;
    125 }
    126 
    127 VideoBootStrap Emscripten_bootstrap = {
    128     EMSCRIPTENVID_DRIVER_NAME, "SDL emscripten video driver",
    129     Emscripten_CreateDevice
    130 };
    131 
    132 
    133 int
    134 Emscripten_VideoInit(_THIS)
    135 {
    136     SDL_DisplayMode mode;
    137 
    138     /* Use a fake 32-bpp desktop mode */
    139     mode.format = SDL_PIXELFORMAT_RGB888;
    140 
    141     mode.w = EM_ASM_INT_V({
    142         return screen.width;
    143     });
    144 
    145     mode.h = EM_ASM_INT_V({
    146         return screen.height;
    147     });
    148 
    149     mode.refresh_rate = 0;
    150     mode.driverdata = NULL;
    151     if (SDL_AddBasicVideoDisplay(&mode) < 0) {
    152         return -1;
    153     }
    154 
    155     SDL_AddDisplayMode(&_this->displays[0], &mode);
    156 
    157     Emscripten_InitMouse();
    158 
    159     /* We're done! */
    160     return 0;
    161 }
    162 
    163 static int
    164 Emscripten_SetDisplayMode(_THIS, SDL_VideoDisplay * display, SDL_DisplayMode * mode)
    165 {
    166     /* can't do this */
    167     return 0;
    168 }
    169 
    170 static void
    171 Emscripten_VideoQuit(_THIS)
    172 {
    173     Emscripten_FiniMouse();
    174 }
    175 
    176 static int
    177 Emscripten_GetDisplayUsableBounds(_THIS, SDL_VideoDisplay * display, SDL_Rect * rect)
    178 {
    179     if (rect) {
    180         rect->x = 0;
    181         rect->y = 0;
    182         rect->w = EM_ASM_INT_V({
    183             return window.innerWidth;
    184         });
    185         rect->h = EM_ASM_INT_V({
    186             return window.innerHeight;
    187         });
    188     }
    189     return 0;
    190 }
    191 
    192 static void
    193 Emscripten_PumpEvents(_THIS)
    194 {
    195     /* do nothing. */
    196 }
    197 
    198 static int
    199 Emscripten_CreateWindow(_THIS, SDL_Window * window)
    200 {
    201     SDL_WindowData *wdata;
    202     double scaled_w, scaled_h;
    203     double css_w, css_h;
    204 
    205     /* Allocate window internal data */
    206     wdata = (SDL_WindowData *) SDL_calloc(1, sizeof(SDL_WindowData));
    207     if (wdata == NULL) {
    208         return SDL_OutOfMemory();
    209     }
    210 
    211     wdata->canvas_id = SDL_strdup("#canvas");
    212 
    213     if (window->flags & SDL_WINDOW_ALLOW_HIGHDPI) {
    214         wdata->pixel_ratio = emscripten_get_device_pixel_ratio();
    215     } else {
    216         wdata->pixel_ratio = 1.0f;
    217     }
    218 
    219     scaled_w = SDL_floor(window->w * wdata->pixel_ratio);
    220     scaled_h = SDL_floor(window->h * wdata->pixel_ratio);
    221 
    222     /* set a fake size to check if there is any CSS sizing the canvas */
    223     emscripten_set_canvas_element_size(wdata->canvas_id, 1, 1);
    224     emscripten_get_element_css_size(wdata->canvas_id, &css_w, &css_h);
    225 
    226     wdata->external_size = SDL_floor(css_w) != 1 || SDL_floor(css_h) != 1;
    227 
    228     if ((window->flags & SDL_WINDOW_RESIZABLE) && wdata->external_size) {
    229         /* external css has resized us */
    230         scaled_w = css_w * wdata->pixel_ratio;
    231         scaled_h = css_h * wdata->pixel_ratio;
    232 
    233         SDL_SendWindowEvent(window, SDL_WINDOWEVENT_RESIZED, css_w, css_h);
    234     }
    235     emscripten_set_canvas_element_size(wdata->canvas_id, scaled_w, scaled_h);
    236 
    237     /* if the size is not being controlled by css, we need to scale down for hidpi */
    238     if (!wdata->external_size) {
    239         if (wdata->pixel_ratio != 1.0f) {
    240             /*scale canvas down*/
    241             emscripten_set_element_css_size(wdata->canvas_id, window->w, window->h);
    242         }
    243     }
    244 
    245 #if SDL_VIDEO_OPENGL_EGL
    246     if (window->flags & SDL_WINDOW_OPENGL) {
    247         if (!_this->egl_data) {
    248             if (SDL_GL_LoadLibrary(NULL) < 0) {
    249                 return -1;
    250             }
    251         }
    252         wdata->egl_surface = SDL_EGL_CreateSurface(_this, 0);
    253 
    254         if (wdata->egl_surface == EGL_NO_SURFACE) {
    255             return SDL_SetError("Could not create GLES window surface");
    256         }
    257     }
    258 #endif
    259 
    260     wdata->window = window;
    261 
    262     /* Setup driver data for this window */
    263     window->driverdata = wdata;
    264 
    265     /* One window, it always has focus */
    266     SDL_SetMouseFocus(window);
    267     SDL_SetKeyboardFocus(window);
    268 
    269     Emscripten_RegisterEventHandlers(wdata);
    270 
    271     /* Window has been successfully created */
    272     return 0;
    273 }
    274 
    275 static void Emscripten_SetWindowSize(_THIS, SDL_Window * window)
    276 {
    277     SDL_WindowData *data;
    278 
    279     if (window->driverdata) {
    280         data = (SDL_WindowData *) window->driverdata;
    281         /* update pixel ratio */
    282         if (window->flags & SDL_WINDOW_ALLOW_HIGHDPI) {
    283             data->pixel_ratio = emscripten_get_device_pixel_ratio();
    284         }
    285         emscripten_set_canvas_element_size(data->canvas_id, window->w * data->pixel_ratio, window->h * data->pixel_ratio);
    286 
    287         /*scale canvas down*/
    288         if (!data->external_size && data->pixel_ratio != 1.0f) {
    289             emscripten_set_element_css_size(data->canvas_id, window->w, window->h);
    290         }
    291     }
    292 }
    293 
    294 static void
    295 Emscripten_DestroyWindow(_THIS, SDL_Window * window)
    296 {
    297     SDL_WindowData *data;
    298 
    299     if(window->driverdata) {
    300         data = (SDL_WindowData *) window->driverdata;
    301 
    302         Emscripten_UnregisterEventHandlers(data);
    303 #if SDL_VIDEO_OPENGL_EGL
    304         if (data->egl_surface != EGL_NO_SURFACE) {
    305             SDL_EGL_DestroySurface(_this, data->egl_surface);
    306             data->egl_surface = EGL_NO_SURFACE;
    307         }
    308 #endif
    309 
    310         /* We can't destroy the canvas, so resize it to zero instead */
    311         emscripten_set_canvas_element_size(data->canvas_id, 0, 0);
    312         SDL_free(data->canvas_id);
    313 
    314         SDL_free(window->driverdata);
    315         window->driverdata = NULL;
    316     }
    317 }
    318 
    319 static void
    320 Emscripten_SetWindowFullscreen(_THIS, SDL_Window * window, SDL_VideoDisplay * display, SDL_bool fullscreen)
    321 {
    322     SDL_WindowData *data;
    323     if(window->driverdata) {
    324         data = (SDL_WindowData *) window->driverdata;
    325 
    326         if(fullscreen) {
    327             EmscriptenFullscreenStrategy strategy;
    328             SDL_bool is_desktop_fullscreen = (window->flags & SDL_WINDOW_FULLSCREEN_DESKTOP) == SDL_WINDOW_FULLSCREEN_DESKTOP;
    329             int res;
    330 
    331             strategy.scaleMode = is_desktop_fullscreen ? EMSCRIPTEN_FULLSCREEN_SCALE_STRETCH : EMSCRIPTEN_FULLSCREEN_SCALE_ASPECT;
    332 
    333             if(!is_desktop_fullscreen) {
    334                 strategy.canvasResolutionScaleMode = EMSCRIPTEN_FULLSCREEN_CANVAS_SCALE_NONE;
    335             } else if(window->flags & SDL_WINDOW_ALLOW_HIGHDPI) {
    336                 strategy.canvasResolutionScaleMode = EMSCRIPTEN_FULLSCREEN_CANVAS_SCALE_HIDEF;
    337             } else {
    338                 strategy.canvasResolutionScaleMode = EMSCRIPTEN_FULLSCREEN_CANVAS_SCALE_STDDEF;
    339             }
    340 
    341             strategy.filteringMode = EMSCRIPTEN_FULLSCREEN_FILTERING_DEFAULT;
    342 
    343             strategy.canvasResizedCallback = Emscripten_HandleCanvasResize;
    344             strategy.canvasResizedCallbackUserData = data;
    345 
    346             data->requested_fullscreen_mode = window->flags & (SDL_WINDOW_FULLSCREEN_DESKTOP | SDL_WINDOW_FULLSCREEN);
    347             data->fullscreen_resize = is_desktop_fullscreen;
    348 
    349             res = emscripten_request_fullscreen_strategy(data->canvas_id, 1, &strategy);
    350             if(res != EMSCRIPTEN_RESULT_SUCCESS && res != EMSCRIPTEN_RESULT_DEFERRED) {
    351                 /* unset flags, fullscreen failed */
    352                 window->flags &= ~(SDL_WINDOW_FULLSCREEN_DESKTOP | SDL_WINDOW_FULLSCREEN);
    353             }
    354         }
    355         else
    356             emscripten_exit_fullscreen();
    357     }
    358 }
    359 
    360 static void
    361 Emscripten_SetWindowTitle(_THIS, SDL_Window * window) {
    362     EM_ASM_INT({
    363       if (typeof setWindowTitle !== 'undefined') {
    364         setWindowTitle(UTF8ToString($0));
    365       }
    366       return 0;
    367     }, window->title);
    368 }
    369 
    370 #endif /* SDL_VIDEO_DRIVER_EMSCRIPTEN */
    371 
    372 /* vi: set ts=4 sw=4 expandtab: */