sdl

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

SDL_uikitopengles.m (8931B)

      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_UIKIT && (SDL_VIDEO_OPENGL_ES || SDL_VIDEO_OPENGL_ES2)
     24 
     25 #include "SDL_uikitopengles.h"
     26 #import "SDL_uikitopenglview.h"
     27 #include "SDL_uikitmodes.h"
     28 #include "SDL_uikitwindow.h"
     29 #include "SDL_uikitevents.h"
     30 #include "../SDL_sysvideo.h"
     31 #include "../../events/SDL_keyboard_c.h"
     32 #include "../../events/SDL_mouse_c.h"
     33 #include "../../power/uikit/SDL_syspower.h"
     34 #include "SDL_loadso.h"
     35 #include <dlfcn.h>
     36 
     37 @interface SDLEAGLContext : EAGLContext
     38 
     39 /* The OpenGL ES context owns a view / drawable. */
     40 @property (nonatomic, strong) SDL_uikitopenglview *sdlView;
     41 
     42 @end
     43 
     44 @implementation SDLEAGLContext
     45 
     46 - (void)dealloc
     47 {
     48     /* When the context is deallocated, its view should be removed from any
     49      * SDL window that it's attached to. */
     50     [self.sdlView setSDLWindow:NULL];
     51 }
     52 
     53 @end
     54 
     55 void *
     56 UIKit_GL_GetProcAddress(_THIS, const char *proc)
     57 {
     58     /* Look through all SO's for the proc symbol.  Here's why:
     59      * -Looking for the path to the OpenGL Library seems not to work in the iOS Simulator.
     60      * -We don't know that the path won't change in the future. */
     61     return dlsym(RTLD_DEFAULT, proc);
     62 }
     63 
     64 /*
     65   note that SDL_GL_DeleteContext makes it current without passing the window
     66 */
     67 int
     68 UIKit_GL_MakeCurrent(_THIS, SDL_Window * window, SDL_GLContext context)
     69 {
     70     @autoreleasepool {
     71         SDLEAGLContext *eaglcontext = (__bridge SDLEAGLContext *) context;
     72 
     73         if (![EAGLContext setCurrentContext:eaglcontext]) {
     74             return SDL_SetError("Could not make EAGL context current");
     75         }
     76 
     77         if (eaglcontext) {
     78             [eaglcontext.sdlView setSDLWindow:window];
     79         }
     80     }
     81 
     82     return 0;
     83 }
     84 
     85 void
     86 UIKit_GL_GetDrawableSize(_THIS, SDL_Window * window, int * w, int * h)
     87 {
     88     @autoreleasepool {
     89         SDL_WindowData *data = (__bridge SDL_WindowData *)window->driverdata;
     90         UIView *view = data.viewcontroller.view;
     91         if ([view isKindOfClass:[SDL_uikitopenglview class]]) {
     92             SDL_uikitopenglview *glview = (SDL_uikitopenglview *) view;
     93             if (w) {
     94                 *w = glview.backingWidth;
     95             }
     96             if (h) {
     97                 *h = glview.backingHeight;
     98             }
     99         } else {
    100             SDL_GetWindowSize(window, w, h);
    101         }
    102     }
    103 }
    104 
    105 int
    106 UIKit_GL_LoadLibrary(_THIS, const char *path)
    107 {
    108     /* We shouldn't pass a path to this function, since we've already loaded the
    109      * library. */
    110     if (path != NULL) {
    111         return SDL_SetError("iOS GL Load Library just here for compatibility");
    112     }
    113     return 0;
    114 }
    115 
    116 int UIKit_GL_SwapWindow(_THIS, SDL_Window * window)
    117 {
    118     @autoreleasepool {
    119         SDLEAGLContext *context = (__bridge SDLEAGLContext *) SDL_GL_GetCurrentContext();
    120 
    121 #if SDL_POWER_UIKIT
    122         /* Check once a frame to see if we should turn off the battery monitor. */
    123         SDL_UIKit_UpdateBatteryMonitoring();
    124 #endif
    125 
    126         [context.sdlView swapBuffers];
    127 
    128         /* You need to pump events in order for the OS to make changes visible.
    129          * We don't pump events here because we don't want iOS application events
    130          * (low memory, terminate, etc.) to happen inside low level rendering. */
    131     }
    132     return 0;
    133 }
    134 
    135 SDL_GLContext
    136 UIKit_GL_CreateContext(_THIS, SDL_Window * window)
    137 {
    138     @autoreleasepool {
    139         SDLEAGLContext *context = nil;
    140         SDL_uikitopenglview *view;
    141         SDL_WindowData *data = (__bridge SDL_WindowData *) window->driverdata;
    142         CGRect frame = UIKit_ComputeViewFrame(window, data.uiwindow.screen);
    143         EAGLSharegroup *sharegroup = nil;
    144         CGFloat scale = 1.0;
    145         int samples = 0;
    146         int major = _this->gl_config.major_version;
    147         int minor = _this->gl_config.minor_version;
    148 
    149         /* The EAGLRenderingAPI enum values currently map 1:1 to major GLES
    150          * versions. */
    151         EAGLRenderingAPI api = major;
    152 
    153         /* iOS currently doesn't support GLES >3.0. iOS 6 also only supports up
    154          * to GLES 2.0. */
    155         if (major > 3 || (major == 3 && (minor > 0 || !UIKit_IsSystemVersionAtLeast(7.0)))) {
    156             SDL_SetError("OpenGL ES %d.%d context could not be created", major, minor);
    157             return NULL;
    158         }
    159 
    160         if (_this->gl_config.multisamplebuffers > 0) {
    161             samples = _this->gl_config.multisamplesamples;
    162         }
    163 
    164         if (_this->gl_config.share_with_current_context) {
    165             EAGLContext *context = (__bridge EAGLContext *) SDL_GL_GetCurrentContext();
    166             sharegroup = context.sharegroup;
    167         }
    168 
    169         if (window->flags & SDL_WINDOW_ALLOW_HIGHDPI) {
    170             /* Set the scale to the natural scale factor of the screen - the
    171              * backing dimensions of the OpenGL view will match the pixel
    172              * dimensions of the screen rather than the dimensions in points. */
    173             if ([data.uiwindow.screen respondsToSelector:@selector(nativeScale)]) {
    174                 scale = data.uiwindow.screen.nativeScale;
    175             } else {
    176                 scale = data.uiwindow.screen.scale;
    177             }
    178         }
    179 
    180         context = [[SDLEAGLContext alloc] initWithAPI:api sharegroup:sharegroup];
    181         if (!context) {
    182             SDL_SetError("OpenGL ES %d context could not be created", _this->gl_config.major_version);
    183             return NULL;
    184         }
    185 
    186         /* construct our view, passing in SDL's OpenGL configuration data */
    187         view = [[SDL_uikitopenglview alloc] initWithFrame:frame
    188                                                     scale:scale
    189                                             retainBacking:_this->gl_config.retained_backing
    190                                                     rBits:_this->gl_config.red_size
    191                                                     gBits:_this->gl_config.green_size
    192                                                     bBits:_this->gl_config.blue_size
    193                                                     aBits:_this->gl_config.alpha_size
    194                                                 depthBits:_this->gl_config.depth_size
    195                                               stencilBits:_this->gl_config.stencil_size
    196                                                      sRGB:_this->gl_config.framebuffer_srgb_capable
    197                                              multisamples:samples
    198                                                   context:context];
    199 
    200         if (!view) {
    201             return NULL;
    202         }
    203 
    204         /* The context owns the view / drawable. */
    205         context.sdlView = view;
    206 
    207         if (UIKit_GL_MakeCurrent(_this, window, (__bridge SDL_GLContext) context) < 0) {
    208             UIKit_GL_DeleteContext(_this, (SDL_GLContext) CFBridgingRetain(context));
    209             return NULL;
    210         }
    211 
    212         /* We return a +1'd context. The window's driverdata owns the view (via
    213          * MakeCurrent.) */
    214         return (SDL_GLContext) CFBridgingRetain(context);
    215     }
    216 }
    217 
    218 void
    219 UIKit_GL_DeleteContext(_THIS, SDL_GLContext context)
    220 {
    221     @autoreleasepool {
    222         /* The context was retained in SDL_GL_CreateContext, so we release it
    223          * here. The context's view will be detached from its window when the
    224          * context is deallocated. */
    225         CFRelease(context);
    226     }
    227 }
    228 
    229 void
    230 UIKit_GL_RestoreCurrentContext(void)
    231 {
    232     @autoreleasepool {
    233         /* Some iOS system functionality (such as Dictation on the on-screen
    234          keyboard) uses its own OpenGL ES context but doesn't restore the
    235          previous one when it's done. This is a workaround to make sure the
    236          expected SDL-created OpenGL ES context is active after the OS is
    237          finished running its own code for the frame. If this isn't done, the
    238          app may crash or have other nasty symptoms when Dictation is used.
    239          */
    240         EAGLContext *context = (__bridge EAGLContext *) SDL_GL_GetCurrentContext();
    241         if (context != NULL && [EAGLContext currentContext] != context) {
    242             [EAGLContext setCurrentContext:context];
    243         }
    244     }
    245 }
    246 
    247 #endif /* SDL_VIDEO_DRIVER_UIKIT */
    248 
    249 /* vi: set ts=4 sw=4 expandtab: */