SDL: src/video/SDL_video.c@e1bd98b56e94

     1 /*

     2     SDL - Simple DirectMedia Layer

     3     Copyright (C) 1997-2009 Sam Lantinga

     5     This library is free software; you can redistribute it and/or

     6     modify it under the terms of the GNU Lesser General Public

     7     License as published by the Free Software Foundation; either

     8     version 2.1 of the License, or (at your option) any later version.

    10     This library is distributed in the hope that it will be useful,

    11     but WITHOUT ANY WARRANTY; without even the implied warranty of

    12     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

    13     Lesser General Public License for more details.

    15     You should have received a copy of the GNU Lesser General Public

    16     License along with this library; if not, write to the Free Software

    17     Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

    19     Sam Lantinga

    20     slouken@libsdl.org

    21 */

    22 #include "SDL_config.h"

    24 /* The high-level video driver subsystem */

    26 #include "SDL.h"

    27 #include "SDL_video.h"

    28 #include "SDL_sysvideo.h"

    29 #include "SDL_blit.h"

    30 #include "SDL_pixels_c.h"

    31 #include "SDL_renderer_gl.h"

    32 #include "SDL_renderer_gles.h"

    33 #include "SDL_renderer_sw.h"

    34 #include "../events/SDL_sysevents.h"

    35 #include "../events/SDL_events_c.h"

    37 #if SDL_VIDEO_OPENGL_ES

    38 #include "SDL_opengles.h"

    39 #endif /* SDL_VIDEO_OPENGL_ES */

    41 #if SDL_VIDEO_OPENGL

    42 #include "SDL_opengl.h"

    44 /* On Windows, windows.h defines CreateWindow */

    45 #ifdef CreateWindow

    46 #undef CreateWindow

    47 #endif

    48 #endif /* SDL_VIDEO_OPENGL */

    50 /* Available video drivers */

    51 static VideoBootStrap *bootstrap[] = {

    52 #if SDL_VIDEO_DRIVER_COCOA

    53     &COCOA_bootstrap,

    54 #endif

    55 #if SDL_VIDEO_DRIVER_X11

    56     &X11_bootstrap,

    57 #endif

    58 #if SDL_VIDEO_DRIVER_FBCON

    59     &FBCON_bootstrap,

    60 #endif

    61 #if SDL_VIDEO_DRIVER_DIRECTFB

    62     &DirectFB_bootstrap,

    63 #endif

    64 #if SDL_VIDEO_DRIVER_PS2GS

    65     &PS2GS_bootstrap,

    66 #endif

    67 #if SDL_VIDEO_DRIVER_PS3

    68     &PS3_bootstrap,

    69 #endif

    70 #if SDL_VIDEO_DRIVER_SVGALIB

    71     &SVGALIB_bootstrap,

    72 #endif

    73 #if SDL_VIDEO_DRIVER_GAPI

    74     &GAPI_bootstrap,

    75 #endif

    76 #if SDL_VIDEO_DRIVER_WIN32

    77     &WIN32_bootstrap,

    78 #endif

    79 #if SDL_VIDEO_DRIVER_BWINDOW

    80     &BWINDOW_bootstrap,

    81 #endif

    82 #if SDL_VIDEO_DRIVER_PHOTON

    83     &photon_bootstrap,

    84 #endif

    85 #if SDL_VIDEO_DRIVER_QNXGF

    86     &qnxgf_bootstrap,

    87 #endif

    88 #if SDL_VIDEO_DRIVER_EPOC

    89     &EPOC_bootstrap,

    90 #endif

    91 #if SDL_VIDEO_DRIVER_RISCOS

    92     &RISCOS_bootstrap,

    93 #endif

    94 #if SDL_VIDEO_DRIVER_NDS

    95     &NDS_bootstrap,

    96 #endif

    97 #if SDL_VIDEO_DRIVER_UIKIT

    98     &UIKIT_bootstrap,

    99 #endif

   100 #if SDL_VIDEO_DRIVER_DUMMY

   101     &DUMMY_bootstrap,

   102 #endif

   103 #if SDL_VIDEO_DRIVER_PANDORA

   104     &PND_bootstrap,

   105 #endif

   106     NULL

   107 };

   109 static SDL_VideoDevice *_this = NULL;

   111 /* Various local functions */

   112 static void SDL_UpdateWindowGrab(SDL_Window * window);

   114 static int

   115 cmpmodes(const void *A, const void *B)

   116 {

   117     SDL_DisplayMode a = *(const SDL_DisplayMode *) A;

   118     SDL_DisplayMode b = *(const SDL_DisplayMode *) B;

   120     if (a.w != b.w) {

   121         return b.w - a.w;

   122     }

   123     if (a.h != b.h) {

   124         return b.h - a.h;

   125     }

   126     if (SDL_BITSPERPIXEL(a.format) != SDL_BITSPERPIXEL(b.format)) {

   127         return SDL_BITSPERPIXEL(b.format) - SDL_BITSPERPIXEL(a.format);

   128     }

   129     if (SDL_PIXELLAYOUT(a.format) != SDL_PIXELLAYOUT(b.format)) {

   130         return SDL_PIXELLAYOUT(b.format) - SDL_PIXELLAYOUT(a.format);

   131     }

   132     if (a.refresh_rate != b.refresh_rate) {

   133         return b.refresh_rate - a.refresh_rate;

   134     }

   135     return 0;

   136 }

   138 static void

   139 SDL_UninitializedVideo()

   140 {

   141     SDL_SetError("Video subsystem has not been initialized");

   142 }

   144 int

   145 SDL_GetNumVideoDrivers(void)

   146 {

   147     return SDL_arraysize(bootstrap) - 1;

   148 }

   150 const char *

   151 SDL_GetVideoDriver(int index)

   152 {

   153     if (index >= 0 && index < SDL_GetNumVideoDrivers()) {

   154         return bootstrap[index]->name;

   155     }

   156     return NULL;

   157 }

   159 /*

   160  * Initialize the video and event subsystems -- determine native pixel format

   161  */

   162 int

   163 SDL_VideoInit(const char *driver_name, Uint32 flags)

   164 {

   165     SDL_VideoDevice *video;

   166     int index;

   167     int i;

   169     /* Toggle the event thread flags, based on OS requirements */

   170 #if defined(MUST_THREAD_EVENTS)

   171     flags |= SDL_INIT_EVENTTHREAD;

   172 #elif defined(CANT_THREAD_EVENTS)

   173     if ((flags & SDL_INIT_EVENTTHREAD) == SDL_INIT_EVENTTHREAD) {

   174         SDL_SetError("OS doesn't support threaded events");

   175         return -1;

   176     }

   177 #endif

   179     /* Start the event loop */

   180     if (SDL_StartEventLoop(flags) < 0) {

   181         return -1;

   182     }

   183     /* Check to make sure we don't overwrite '_this' */

   184     if (_this != NULL) {

   185         SDL_VideoQuit();

   186     }

   187     /* Select the proper video driver */

   188     index = 0;

   189     video = NULL;

   190     if (driver_name == NULL) {

   191         driver_name = SDL_getenv("SDL_VIDEODRIVER");

   192     }

   193     if (driver_name != NULL) {

   194         for (i = 0; bootstrap[i]; ++i) {

   195             if (SDL_strcasecmp(bootstrap[i]->name, driver_name) == 0) {

   196                 video = bootstrap[i]->create(index);

   197                 break;

   198             }

   199         }

   200     } else {

   201         for (i = 0; bootstrap[i]; ++i) {

   202             if (bootstrap[i]->available()) {

   203                 video = bootstrap[i]->create(index);

   204                 if (video != NULL) {

   205                     break;

   206                 }

   207             }

   208         }

   209     }

   210     if (video == NULL) {

   211         if (driver_name) {

   212             SDL_SetError("%s not available", driver_name);

   213         } else {

   214             SDL_SetError("No available video device");

   215         }

   216         return -1;

   217     }

   218     _this = video;

   219     _this->name = bootstrap[i]->name;

   220     _this->next_object_id = 1;

   223     /* Set some very sane GL defaults */

   224     _this->gl_config.driver_loaded = 0;

   225     _this->gl_config.dll_handle = NULL;

   226     _this->gl_config.red_size = 3;

   227     _this->gl_config.green_size = 3;

   228     _this->gl_config.blue_size = 2;

   229     _this->gl_config.alpha_size = 0;

   230     _this->gl_config.buffer_size = 0;

   231     _this->gl_config.depth_size = 16;

   232     _this->gl_config.stencil_size = 0;

   233     _this->gl_config.double_buffer = 1;

   234     _this->gl_config.accum_red_size = 0;

   235     _this->gl_config.accum_green_size = 0;

   236     _this->gl_config.accum_blue_size = 0;

   237     _this->gl_config.accum_alpha_size = 0;

   238     _this->gl_config.stereo = 0;

   239     _this->gl_config.multisamplebuffers = 0;

   240     _this->gl_config.multisamplesamples = 0;

   241     _this->gl_config.retained_backing = 1;

   242     _this->gl_config.accelerated = -1;  /* not known, don't set */

   243     _this->gl_config.major_version = 2;

   244     _this->gl_config.minor_version = 1;

   246     /* Initialize the video subsystem */

   247     if (_this->VideoInit(_this) < 0) {

   248         SDL_VideoQuit();

   249         return -1;

   250     }

   251     /* Make sure some displays were added */

   252     if (_this->num_displays == 0) {

   253         SDL_SetError("The video driver did not add any displays");

   254         SDL_VideoQuit();

   255         return (-1);

   256     }

   257     /* The software renderer is always available */

   258     for (i = 0; i < _this->num_displays; ++i) {

   259         if (_this->GL_CreateContext) {

   260 #if SDL_VIDEO_RENDER_OGL

   261             SDL_AddRenderDriver(i, &GL_RenderDriver);

   262 #endif

   263 #if SDL_VIDEO_RENDER_OGL_ES

   264             SDL_AddRenderDriver(i, &GL_ES_RenderDriver);

   265 #endif

   266         }

   267         if (_this->displays[i].num_render_drivers > 0) {

   268             SDL_AddRenderDriver(i, &SW_RenderDriver);

   269         }

   270     }

   272     /* We're ready to go! */

   273     return 0;

   274 }

   276 const char *

   277 SDL_GetCurrentVideoDriver()

   278 {

   279     if (!_this) {

   280         SDL_UninitializedVideo();

   281         return NULL;

   282     }

   283     return _this->name;

   284 }

   286 SDL_VideoDevice *

   287 SDL_GetVideoDevice()

   288 {

   289     return _this;

   290 }

   292 int

   293 SDL_AddBasicVideoDisplay(const SDL_DisplayMode * desktop_mode)

   294 {

   295     SDL_VideoDisplay display;

   297     SDL_zero(display);

   298     if (desktop_mode) {

   299         display.desktop_mode = *desktop_mode;

   300     }

   301     display.current_mode = display.desktop_mode;

   303     return SDL_AddVideoDisplay(&display);

   304 }

   306 int

   307 SDL_AddVideoDisplay(const SDL_VideoDisplay * display)

   308 {

   309     SDL_VideoDisplay *displays;

   310     int index = -1;

   312     displays =

   313         SDL_realloc(_this->displays,

   314                     (_this->num_displays + 1) * sizeof(*displays));

   315     if (displays) {

   316         index = _this->num_displays++;

   317         displays[index] = *display;

   318         displays[index].device = _this;

   319         _this->displays = displays;

   320     } else {

   321         SDL_OutOfMemory();

   322     }

   323     return index;

   324 }

   326 int

   327 SDL_GetNumVideoDisplays(void)

   328 {

   329     if (!_this) {

   330         SDL_UninitializedVideo();

   331         return 0;

   332     }

   333     return _this->num_displays;

   334 }

   336 int

   337 SDL_SelectVideoDisplay(int index)

   338 {

   339     if (!_this) {

   340         SDL_UninitializedVideo();

   341         return (-1);

   342     }

   343     if (index < 0 || index >= _this->num_displays) {

   344         SDL_SetError("index must be in the range 0 - %d",

   345                      _this->num_displays - 1);

   346         return -1;

   347     }

   348     _this->current_display = index;

   349     return 0;

   350 }

   352 int

   353 SDL_GetCurrentVideoDisplay(void)

   354 {

   355     if (!_this) {

   356         SDL_UninitializedVideo();

   357         return (-1);

   358     }

   359     return _this->current_display;

   360 }

   362 SDL_bool

   363 SDL_AddDisplayMode(int displayIndex, const SDL_DisplayMode * mode)

   364 {

   365     SDL_VideoDisplay *display = &_this->displays[displayIndex];

   366     SDL_DisplayMode *modes;

   367     int i, nmodes;

   369     /* Make sure we don't already have the mode in the list */

   370     modes = display->display_modes;

   371     nmodes = display->num_display_modes;

   372     for (i = nmodes; i--;) {

   373         if (SDL_memcmp(mode, &modes[i], sizeof(*mode)) == 0) {

   374             return SDL_FALSE;

   375         }

   376     }

   378     /* Go ahead and add the new mode */

   379     if (nmodes == display->max_display_modes) {

   380         modes =

   381             SDL_realloc(modes,

   382                         (display->max_display_modes + 32) * sizeof(*modes));

   383         if (!modes) {

   384             return SDL_FALSE;

   385         }

   386         display->display_modes = modes;

   387         display->max_display_modes += 32;

   388     }

   389     modes[nmodes] = *mode;

   390     display->num_display_modes++;

   392     /* Re-sort video modes */

   393     SDL_qsort(display->display_modes, display->num_display_modes,

   394               sizeof(SDL_DisplayMode), cmpmodes);

   396     return SDL_TRUE;

   397 }

   399 int

   400 SDL_GetNumDisplayModes()

   401 {

   402     if (_this) {

   403         SDL_VideoDisplay *display = &SDL_CurrentDisplay;

   404         if (!display->num_display_modes && _this->GetDisplayModes) {

   405             _this->GetDisplayModes(_this);

   406             SDL_qsort(display->display_modes, display->num_display_modes,

   407                       sizeof(SDL_DisplayMode), cmpmodes);

   408         }

   409         return display->num_display_modes;

   410     }

   411     return 0;

   412 }

   414 int

   415 SDL_GetDisplayMode(int index, SDL_DisplayMode * mode)

   416 {

   417     if (index < 0 || index >= SDL_GetNumDisplayModes()) {

   418         SDL_SetError("index must be in the range of 0 - %d",

   419                      SDL_GetNumDisplayModes() - 1);

   420         return -1;

   421     }

   422     if (mode) {

   423         *mode = SDL_CurrentDisplay.display_modes[index];

   424     }

   425     return 0;

   426 }

   428 int

   429 SDL_GetDesktopDisplayMode(SDL_DisplayMode * mode)

   430 {

   431     if (!_this) {

   432         SDL_UninitializedVideo();

   433         return -1;

   434     }

   435     if (mode) {

   436         *mode = SDL_CurrentDisplay.desktop_mode;

   437     }

   438     return 0;

   439 }

   441 int

   442 SDL_GetCurrentDisplayMode(SDL_DisplayMode * mode)

   443 {

   444     if (!_this) {

   445         SDL_UninitializedVideo();

   446         return -1;

   447     }

   448     if (mode) {

   449         *mode = SDL_CurrentDisplay.current_mode;

   450     }

   451     return 0;

   452 }

   454 SDL_DisplayMode *

   455 SDL_GetClosestDisplayMode(const SDL_DisplayMode * mode,

   456                           SDL_DisplayMode * closest)

   457 {

   458     Uint32 target_format;

   459     int target_refresh_rate;

   460     int i;

   461     SDL_DisplayMode *current, *match;

   463     if (!_this || !mode || !closest) {

   464         return NULL;

   465     }

   466     /* Default to the desktop format */

   467     if (mode->format) {

   468         target_format = mode->format;

   469     } else {

   470         target_format = SDL_CurrentDisplay.desktop_mode.format;

   471     }

   473     /* Default to the desktop refresh rate */

   474     if (mode->refresh_rate) {

   475         target_refresh_rate = mode->refresh_rate;

   476     } else {

   477         target_refresh_rate = SDL_CurrentDisplay.desktop_mode.refresh_rate;

   478     }

   480     match = NULL;

   481     for (i = 0; i < SDL_GetNumDisplayModes(); ++i) {

   482         current = &SDL_CurrentDisplay.display_modes[i];

   484         if (current->w && (current->w < mode->w)) {

   485             /* Out of sorted modes large enough here */

   486             break;

   487         }

   488         if (current->h && (current->h < mode->h)) {

   489             if (current->w && (current->w == mode->w)) {

   490                 /* Out of sorted modes large enough here */

   491                 break;

   492             }

   493             /* Wider, but not tall enough, due to a different

   494                aspect ratio. This mode must be skipped, but closer

   495                modes may still follow. */

   496             continue;

   497         }

   498         if (!match || current->w < match->w || current->h < match->h) {

   499             match = current;

   500             continue;

   501         }

   502         if (current->format != match->format) {

   503             /* Sorted highest depth to lowest */

   504             if (current->format == target_format ||

   505                 (SDL_BITSPERPIXEL(current->format) >=

   506                  SDL_BITSPERPIXEL(target_format)

   507                  && SDL_PIXELTYPE(current->format) ==

   508                  SDL_PIXELTYPE(target_format))) {

   509                 match = current;

   510             }

   511             continue;

   512         }

   513         if (current->refresh_rate != match->refresh_rate) {

   514             /* Sorted highest refresh to lowest */

   515             if (current->refresh_rate >= target_refresh_rate) {

   516                 match = current;

   517             }

   518         }

   519     }

   520     if (match) {

   521         if (match->format) {

   522             closest->format = match->format;

   523         } else {

   524             closest->format = mode->format;

   525         }

   526         if (match->w && match->h) {

   527             closest->w = match->w;

   528             closest->h = match->h;

   529         } else {

   530             closest->w = mode->w;

   531             closest->h = mode->h;

   532         }

   533         if (match->refresh_rate) {

   534             closest->refresh_rate = match->refresh_rate;

   535         } else {

   536             closest->refresh_rate = mode->refresh_rate;

   537         }

   538         closest->driverdata = match->driverdata;

   540         /*

   541          * Pick some reasonable defaults if the app and driver don't

   542          * care

   543          */

   544         if (!closest->format) {

   545             closest->format = SDL_PIXELFORMAT_RGB888;

   546         }

   547         if (!closest->w) {

   548             closest->w = 640;

   549         }

   550         if (!closest->h) {

   551             closest->h = 480;

   552         }

   553         return closest;

   554     }

   555     return NULL;

   556 }

   558 int

   559 SDL_SetDisplayMode(const SDL_DisplayMode * mode)

   560 {

   561     SDL_VideoDisplay *display;

   562     SDL_DisplayMode display_mode;

   563     SDL_DisplayMode current_mode;

   564     int i, ncolors;

   566     if (!_this) {

   567         SDL_UninitializedVideo();

   568         return -1;

   569     }

   570     display = &SDL_CurrentDisplay;

   571     if (!mode) {

   572         mode = &display->desktop_mode;

   573     }

   574     display_mode = *mode;

   576     /* Default to the current mode */

   577     if (!display_mode.format) {

   578         display_mode.format = display->current_mode.format;

   579     }

   580     if (!display_mode.w) {

   581         display_mode.w = display->current_mode.w;

   582     }

   583     if (!display_mode.h) {

   584         display_mode.h = display->current_mode.h;

   585     }

   586     if (!display_mode.refresh_rate) {

   587         display_mode.refresh_rate = display->current_mode.refresh_rate;

   588     }

   589     /* Get a good video mode, the closest one possible */

   590     if (!SDL_GetClosestDisplayMode(&display_mode, &display_mode)) {

   591         SDL_SetError("No video mode large enough for %dx%d",

   592                      display_mode.w, display_mode.h);

   593         return -1;

   594     }

   595     /* See if there's anything left to do */

   596     SDL_GetCurrentDisplayMode(&current_mode);

   597     if (SDL_memcmp(&display_mode, &current_mode, sizeof(display_mode)) == 0) {

   598         return 0;

   599     }

   600     /* Actually change the display mode */

   601     if (_this->SetDisplayMode(_this, &display_mode) < 0) {

   602         return -1;

   603     }

   604     display->current_mode = display_mode;

   606     /* Set up a palette, if necessary */

   607     if (SDL_ISPIXELFORMAT_INDEXED(display_mode.format)) {

   608         ncolors = (1 << SDL_BITSPERPIXEL(display_mode.format));

   609     } else {

   610         ncolors = 0;

   611     }

   612     if ((!ncolors && display->palette) || (ncolors && !display->palette)

   613         || (ncolors && ncolors != display->palette->ncolors)) {

   614         if (display->palette) {

   615             SDL_FreePalette(display->palette);

   616             display->palette = NULL;

   617         }

   618         if (ncolors) {

   619             display->palette = SDL_AllocPalette(ncolors);

   620             if (!display->palette) {

   621                 return -1;

   622             }

   623             SDL_DitherColors(display->palette->colors,

   624                              SDL_BITSPERPIXEL(display_mode.format));

   625         }

   626     }

   627     /* Move any fullscreen windows into position */

   628     for (i = 0; i < display->num_windows; ++i) {

   629         SDL_Window *window = &display->windows[i];

   630         if (FULLSCREEN_VISIBLE(window)) {

   631             SDL_SetWindowPosition(window->id, window->x, window->y);

   632         }

   633     }

   635     return 0;

   636 }

   638 int

   639 SDL_SetFullscreenDisplayMode(const SDL_DisplayMode * mode)

   640 {

   641     SDL_VideoDisplay *display;

   642     SDL_DisplayMode fullscreen_mode;

   643     int i;

   645     if (!_this) {

   646         SDL_UninitializedVideo();

   647         return -1;

   648     }

   649     display = &SDL_CurrentDisplay;

   650     if (!mode) {

   651         mode = &display->desktop_mode;

   652     }

   653     if (!SDL_GetClosestDisplayMode(mode, &fullscreen_mode)) {

   654         SDL_SetError("Couldn't find display mode match");

   655         return -1;

   656     }

   658     if (SDL_memcmp

   659         (&fullscreen_mode, &display->fullscreen_mode,

   660          sizeof(fullscreen_mode)) == 0) {

   661         /* Nothing to do... */

   662         return 0;

   663     }

   664     display->fullscreen_mode = fullscreen_mode;

   666     /* Actually set the mode if we have a fullscreen window visible */

   667     for (i = 0; i < display->num_windows; ++i) {

   668         SDL_Window *window = &display->windows[i];

   669         if (FULLSCREEN_VISIBLE(window)) {

   670             if (SDL_SetDisplayMode(&display->fullscreen_mode) < 0) {

   671                 return -1;

   672             }

   673         }

   674         if (window->flags & SDL_WINDOW_FULLSCREEN) {

   675             SDL_OnWindowResized(window);

   676         }

   677     }

   678     return 0;

   679 }

   681 int

   682 SDL_GetFullscreenDisplayMode(SDL_DisplayMode * mode)

   683 {

   684     if (!_this) {

   685         SDL_UninitializedVideo();

   686         return -1;

   687     }

   688     if (mode) {

   689         *mode = SDL_CurrentDisplay.fullscreen_mode;

   690     }

   691     return 0;

   692 }

   694 int

   695 SDL_SetDisplayPalette(const SDL_Color * colors, int firstcolor, int ncolors)

   696 {

   697     SDL_Palette *palette;

   698     int status = 0;

   700     if (!_this) {

   701         SDL_UninitializedVideo();

   702         return -1;

   703     }

   704     palette = SDL_CurrentDisplay.palette;

   705     if (!palette) {

   706         SDL_SetError("Display mode does not have a palette");

   707         return -1;

   708     }

   709     status = SDL_SetPaletteColors(palette, colors, firstcolor, ncolors);

   711     if (_this->SetDisplayPalette) {

   712         if (_this->SetDisplayPalette(_this, palette) < 0) {

   713             status = -1;

   714         }

   715     }

   716     return status;

   717 }

   719 int

   720 SDL_GetDisplayPalette(SDL_Color * colors, int firstcolor, int ncolors)

   721 {

   722     SDL_Palette *palette;

   724     if (!_this) {

   725         SDL_UninitializedVideo();

   726         return -1;

   727     }

   728     palette = SDL_CurrentDisplay.palette;

   729     if (!palette->ncolors) {

   730         SDL_SetError("Display mode does not have a palette");

   731         return -1;

   732     }

   733     if (firstcolor < 0 || (firstcolor + ncolors) > palette->ncolors) {

   734         SDL_SetError("Palette indices are out of range");

   735         return -1;

   736     }

   737     SDL_memcpy(colors, &palette->colors[firstcolor],

   738                ncolors * sizeof(*colors));

   739     return 0;

   740 }

   742 SDL_WindowID

   743 SDL_CreateWindow(const char *title, int x, int y, int w, int h, Uint32 flags)

   744 {

   745     const Uint32 allowed_flags = (SDL_WINDOW_FULLSCREEN |

   746                                   SDL_WINDOW_OPENGL |

   747                                   SDL_WINDOW_BORDERLESS |

   748                                   SDL_WINDOW_RESIZABLE |

   749                                   SDL_WINDOW_INPUT_GRABBED);

   750     SDL_VideoDisplay *display;

   751     SDL_Window window;

   752     int num_windows;

   753     SDL_Window *windows;

   755     if (!_this) {

   756         /* Initialize the video system if needed */

   757         if (SDL_VideoInit(NULL, 0) < 0) {

   758             return 0;

   759         }

   760     }

   761     if (flags & SDL_WINDOW_OPENGL) {

   762         if (!_this->GL_CreateContext) {

   763             SDL_SetError("No OpenGL support in video driver");

   764             return 0;

   765         }

   766         SDL_GL_LoadLibrary(NULL);

   767     }

   768     SDL_zero(window);

   769     window.id = _this->next_object_id++;

   770     window.x = x;

   771     window.y = y;

   772     window.w = w;

   773     window.h = h;

   774     window.flags = (flags & allowed_flags);

   775     window.display = _this->current_display;

   777     if (_this->CreateWindow && _this->CreateWindow(_this, &window) < 0) {

   778         if (flags & SDL_WINDOW_OPENGL) {

   779             SDL_GL_UnloadLibrary();

   780         }

   781         return 0;

   782     }

   783     display = &SDL_CurrentDisplay;

   784     num_windows = display->num_windows;

   785     windows =

   786         SDL_realloc(display->windows, (num_windows + 1) * sizeof(*windows));

   787     if (!windows) {

   788         if (_this->DestroyWindow) {

   789             _this->DestroyWindow(_this, &window);

   790         }

   791         if (flags & SDL_WINDOW_OPENGL) {

   792             SDL_GL_UnloadLibrary();

   793         }

   794         return 0;

   795     }

   796     windows[num_windows] = window;

   797     display->windows = windows;

   798     display->num_windows++;

   800     if (title) {

   801         SDL_SetWindowTitle(window.id, title);

   802     }

   803     if (flags & SDL_WINDOW_MAXIMIZED) {

   804         SDL_MaximizeWindow(window.id);

   805     }

   806     if (flags & SDL_WINDOW_MINIMIZED) {

   807         SDL_MinimizeWindow(window.id);

   808     }

   809     if (flags & SDL_WINDOW_SHOWN) {

   810         SDL_ShowWindow(window.id);

   811     }

   812     SDL_UpdateWindowGrab(&window);

   814     return window.id;

   815 }

   817 SDL_WindowID

   818 SDL_CreateWindowFrom(const void *data)

   819 {

   820     SDL_VideoDisplay *display;

   821     SDL_Window window;

   822     int num_windows;

   823     SDL_Window *windows;

   825     if (!_this) {

   826         SDL_UninitializedVideo();

   827         return (0);

   828     }

   829     SDL_zero(window);

   830     window.id = _this->next_object_id++;

   831     window.display = _this->current_display;

   832     window.flags = SDL_WINDOW_FOREIGN;

   834     if (!_this->CreateWindowFrom ||

   835         _this->CreateWindowFrom(_this, &window, data) < 0) {

   836         return 0;

   837     }

   838     display = &SDL_CurrentDisplay;

   839     num_windows = display->num_windows;

   840     windows =

   841         SDL_realloc(display->windows, (num_windows + 1) * sizeof(*windows));

   842     if (!windows) {

   843         if (_this->DestroyWindow) {

   844             _this->DestroyWindow(_this, &window);

   845         }

   846         if (window.title) {

   847             SDL_free(window.title);

   848         }

   849         return 0;

   850     }

   851     windows[num_windows] = window;

   852     display->windows = windows;

   853     display->num_windows++;

   855     return window.id;

   856 }

   858 int

   859 SDL_RecreateWindow(SDL_Window * window, Uint32 flags)

   860 {

   861     const Uint32 allowed_flags = (SDL_WINDOW_FULLSCREEN |

   862                                   SDL_WINDOW_OPENGL |

   863                                   SDL_WINDOW_BORDERLESS |

   864                                   SDL_WINDOW_RESIZABLE |

   865                                   SDL_WINDOW_INPUT_GRABBED |

   866                                   SDL_WINDOW_FOREIGN);

   867     char *title = window->title;

   869     if ((flags & SDL_WINDOW_OPENGL) && !_this->GL_CreateContext) {

   870         SDL_SetError("No OpenGL support in video driver");

   871         return -1;

   872     }

   873     if ((window->flags & SDL_WINDOW_OPENGL) != (flags & SDL_WINDOW_OPENGL)) {

   874         if (flags & SDL_WINDOW_OPENGL) {

   875             SDL_GL_LoadLibrary(NULL);

   876         } else {

   877             SDL_GL_UnloadLibrary();

   878         }

   879     }

   881     if (window->flags & SDL_WINDOW_FOREIGN) {

   882         /* Can't destroy and re-create foreign windows, hrm */

   883         flags |= SDL_WINDOW_FOREIGN;

   884     } else {

   885         flags &= ~SDL_WINDOW_FOREIGN;

   886     }

   888     if (_this->DestroyWindow && !(flags & SDL_WINDOW_FOREIGN)) {

   889         _this->DestroyWindow(_this, window);

   890     }

   892     window->title = NULL;

   893     window->flags = (flags & allowed_flags);

   895     if (_this->CreateWindow && !(flags & SDL_WINDOW_FOREIGN)) {

   896         if (_this->CreateWindow(_this, window) < 0) {

   897             if (flags & SDL_WINDOW_OPENGL) {

   898                 SDL_GL_UnloadLibrary();

   899             }

   900             return -1;

   901         }

   902     }

   904     if (title) {

   905         SDL_SetWindowTitle(window->id, title);

   906         SDL_free(title);

   907     }

   908     if (flags & SDL_WINDOW_MAXIMIZED) {

   909         SDL_MaximizeWindow(window->id);

   910     }

   911     if (flags & SDL_WINDOW_MINIMIZED) {

   912         SDL_MinimizeWindow(window->id);

   913     }

   914     if (flags & SDL_WINDOW_SHOWN) {

   915         SDL_ShowWindow(window->id);

   916     }

   917     SDL_UpdateWindowGrab(window);

   919     return 0;

   920 }

   922 SDL_Window *

   923 SDL_GetWindowFromID(SDL_WindowID windowID)

   924 {

   925     int i, j;

   927     if (!_this) {

   928         SDL_UninitializedVideo();

   929         return NULL;

   930     }

   931     if (windowID) {

   932         for (i = 0; i < _this->num_displays; ++i) {

   933             SDL_VideoDisplay *display = &_this->displays[i];

   934             for (j = 0; j < display->num_windows; ++j) {

   935                 SDL_Window *window = &display->windows[j];

   936                 if (window->id == windowID) {

   937                     return window;

   938                 }

   939             }

   940         }

   941     } else {

   942         /* Just return the first active window */

   943         for (i = 0; i < _this->num_displays; ++i) {

   944             SDL_VideoDisplay *display = &_this->displays[i];

   945             for (j = 0; j < display->num_windows; ++j) {

   946                 SDL_Window *window = &display->windows[j];

   947                 return window;

   948             }

   949         }

   950     }

   951     /* Couldn't find the window with the requested ID */

   952     SDL_SetError("Invalid window ID");

   953     return NULL;

   954 }

   956 SDL_VideoDisplay *

   957 SDL_GetDisplayFromWindow(SDL_Window * window)

   958 {

   959     if (!_this) {

   960         SDL_UninitializedVideo();

   961         return NULL;

   962     }

   963     if (!window) {

   964         return NULL;

   965     }

   966     return &_this->displays[window->display];

   967 }

   969 static __inline__ SDL_Renderer *

   970 SDL_GetCurrentRenderer(SDL_bool create)

   971 {

   972     if (!_this) {

   973         SDL_UninitializedVideo();

   974         return NULL;

   975     }

   976     if (!SDL_CurrentRenderer) {

   977         if (!create) {

   978             SDL_SetError("Use SDL_CreateRenderer() to create a renderer");

   979             return NULL;

   980         }

   981         if (SDL_CreateRenderer(0, -1, 0) < 0) {

   982             return NULL;

   983         }

   984     }

   985     return SDL_CurrentRenderer;

   986 }

   988 Uint32

   989 SDL_GetWindowFlags(SDL_WindowID windowID)

   990 {

   991     SDL_Window *window = SDL_GetWindowFromID(windowID);

   993     if (!window) {

   994         return 0;

   995     }

   996     return window->flags;

   997 }

   999 void

  1000 SDL_SetWindowTitle(SDL_WindowID windowID, const char *title)

  1001 {

  1002     SDL_Window *window = SDL_GetWindowFromID(windowID);

  1004     if (!window || title == window->title) {

  1005         return;

  1006     }

  1007     if (window->title) {

  1008         SDL_free(window->title);

  1009     }

  1010     if (title) {

  1011         window->title = SDL_strdup(title);

  1012     } else {

  1013         window->title = NULL;

  1014     }

  1016     if (_this->SetWindowTitle) {

  1017         _this->SetWindowTitle(_this, window);

  1018     }

  1019 }

  1021 const char *

  1022 SDL_GetWindowTitle(SDL_WindowID windowID)

  1023 {

  1024     SDL_Window *window = SDL_GetWindowFromID(windowID);

  1026     if (!window) {

  1027         return NULL;

  1028     }

  1029     return window->title;

  1030 }

  1032 void

  1033 SDL_SetWindowIcon(SDL_WindowID windowID, SDL_Surface * icon)

  1034 {

  1035     SDL_Window *window = SDL_GetWindowFromID(windowID);

  1037     if (!window) {

  1038         return;

  1039     }

  1040     if (_this->SetWindowIcon) {

  1041         _this->SetWindowIcon(_this, window, icon);

  1042     }

  1043 }

  1045 void

  1046 SDL_SetWindowData(SDL_WindowID windowID, void *userdata)

  1047 {

  1048     SDL_Window *window = SDL_GetWindowFromID(windowID);

  1050     if (!window) {

  1051         return;

  1052     }

  1053     window->userdata = userdata;

  1054 }

  1056 void *

  1057 SDL_GetWindowData(SDL_WindowID windowID)

  1058 {

  1059     SDL_Window *window = SDL_GetWindowFromID(windowID);

  1061     if (!window) {

  1062         return NULL;

  1063     }

  1064     return window->userdata;

  1065 }

  1067 void

  1068 SDL_SetWindowPosition(SDL_WindowID windowID, int x, int y)

  1069 {

  1070     SDL_Window *window = SDL_GetWindowFromID(windowID);

  1071     SDL_VideoDisplay *display = SDL_GetDisplayFromWindow(window);

  1073     if (!window) {

  1074         return;

  1075     }

  1076     if (x != SDL_WINDOWPOS_UNDEFINED) {

  1077         window->x = x;

  1078     }

  1079     if (y != SDL_WINDOWPOS_UNDEFINED) {

  1080         window->y = y;

  1081     }

  1082     if (_this->SetWindowPosition) {

  1083         _this->SetWindowPosition(_this, window);

  1084     }

  1085     SDL_SendWindowEvent(window->id, SDL_WINDOWEVENT_MOVED, x, y);

  1086 }

  1088 void

  1089 SDL_GetWindowPosition(SDL_WindowID windowID, int *x, int *y)

  1090 {

  1091     SDL_Window *window = SDL_GetWindowFromID(windowID);

  1093     if (!window) {

  1094         return;

  1095     }

  1096     if (x) {

  1097         *x = window->x;

  1098     }

  1099     if (y) {

  1100         *y = window->y;

  1101     }

  1102 }

  1104 void

  1105 SDL_SetWindowSize(SDL_WindowID windowID, int w, int h)

  1106 {

  1107     SDL_Window *window = SDL_GetWindowFromID(windowID);

  1109     if (!window) {

  1110         return;

  1111     }

  1112     window->w = w;

  1113     window->h = h;

  1115     if (_this->SetWindowSize) {

  1116         _this->SetWindowSize(_this, window);

  1117     }

  1118     SDL_OnWindowResized(window);

  1119 }

  1121 void

  1122 SDL_GetWindowSize(SDL_WindowID windowID, int *w, int *h)

  1123 {

  1124     SDL_Window *window = SDL_GetWindowFromID(windowID);

  1126     if (window) {

  1127         if (w) {

  1128             *w = window->w;

  1129         }

  1130         if (h) {

  1131             *h = window->h;

  1132         }

  1133     } else {

  1134         if (w) {

  1135             *w = 0;

  1136         }

  1137         if (h) {

  1138             *h = 0;

  1139         }

  1140     }

  1141 }

  1143 void

  1144 SDL_ShowWindow(SDL_WindowID windowID)

  1145 {

  1146     SDL_Window *window = SDL_GetWindowFromID(windowID);

  1148     if (!window || (window->flags & SDL_WINDOW_SHOWN)) {

  1149         return;

  1150     }

  1152     if (_this->ShowWindow) {

  1153         _this->ShowWindow(_this, window);

  1154     }

  1155     SDL_SendWindowEvent(window->id, SDL_WINDOWEVENT_SHOWN, 0, 0);

  1156 }

  1158 void

  1159 SDL_HideWindow(SDL_WindowID windowID)

  1160 {

  1161     SDL_Window *window = SDL_GetWindowFromID(windowID);

  1163     if (!window || !(window->flags & SDL_WINDOW_SHOWN)) {

  1164         return;

  1165     }

  1167     if (_this->HideWindow) {

  1168         _this->HideWindow(_this, window);

  1169     }

  1170     SDL_SendWindowEvent(window->id, SDL_WINDOWEVENT_HIDDEN, 0, 0);

  1171 }

  1173 void

  1174 SDL_RaiseWindow(SDL_WindowID windowID)

  1175 {

  1176     SDL_Window *window = SDL_GetWindowFromID(windowID);

  1178     if (!window || !(window->flags & SDL_WINDOW_SHOWN)) {

  1179         return;

  1180     }

  1181     if (_this->RaiseWindow) {

  1182         _this->RaiseWindow(_this, window);

  1183     }

  1184 }

  1186 void

  1187 SDL_MaximizeWindow(SDL_WindowID windowID)

  1188 {

  1189     SDL_Window *window = SDL_GetWindowFromID(windowID);

  1191     if (!window || (window->flags & SDL_WINDOW_MAXIMIZED)) {

  1192         return;

  1193     }

  1195     if (_this->MaximizeWindow) {

  1196         _this->MaximizeWindow(_this, window);

  1197     }

  1198     SDL_SendWindowEvent(window->id, SDL_WINDOWEVENT_MAXIMIZED, 0, 0);

  1199 }

  1201 void

  1202 SDL_MinimizeWindow(SDL_WindowID windowID)

  1203 {

  1204     SDL_Window *window = SDL_GetWindowFromID(windowID);

  1206     if (!window || (window->flags & SDL_WINDOW_MINIMIZED)) {

  1207         return;

  1208     }

  1210     if (_this->MinimizeWindow) {

  1211         _this->MinimizeWindow(_this, window);

  1212     }

  1213     SDL_SendWindowEvent(window->id, SDL_WINDOWEVENT_MINIMIZED, 0, 0);

  1214 }

  1216 void

  1217 SDL_RestoreWindow(SDL_WindowID windowID)

  1218 {

  1219     SDL_Window *window = SDL_GetWindowFromID(windowID);

  1221     if (!window

  1222         || !(window->flags & (SDL_WINDOW_MAXIMIZED | SDL_WINDOW_MINIMIZED))) {

  1223         return;

  1224     }

  1226     if (_this->RestoreWindow) {

  1227         _this->RestoreWindow(_this, window);

  1228     }

  1229     SDL_SendWindowEvent(window->id, SDL_WINDOWEVENT_RESTORED, 0, 0);

  1230 }

  1232 int

  1233 SDL_SetWindowFullscreen(SDL_WindowID windowID, int fullscreen)

  1234 {

  1235     SDL_Window *window = SDL_GetWindowFromID(windowID);

  1237     if (!window) {

  1238         return -1;

  1239     }

  1240     if (fullscreen) {

  1241         fullscreen = SDL_WINDOW_FULLSCREEN;

  1242     }

  1243     if ((window->flags & SDL_WINDOW_FULLSCREEN) == fullscreen) {

  1244         return 0;

  1245     }

  1246     if (fullscreen) {

  1247         window->flags |= SDL_WINDOW_FULLSCREEN;

  1249         if (FULLSCREEN_VISIBLE(window)) {

  1250             SDL_VideoDisplay *display = SDL_GetDisplayFromWindow(window);

  1252             /* Hide any other fullscreen windows */

  1253             int i;

  1254             for (i = 0; i < display->num_windows; ++i) {

  1255                 SDL_Window *other = &display->windows[i];

  1256                 if (other->id != windowID && FULLSCREEN_VISIBLE(other)) {

  1257                     SDL_MinimizeWindow(other->id);

  1258                 }

  1259             }

  1261             SDL_SetDisplayMode(&display->fullscreen_mode);

  1262         }

  1263     } else {

  1264         window->flags &= ~SDL_WINDOW_FULLSCREEN;

  1266         if (FULLSCREEN_VISIBLE(window)) {

  1267             SDL_SetDisplayMode(NULL);

  1268         }

  1269     }

  1270     return 0;

  1271 }

  1273 void

  1274 SDL_SetWindowGrab(SDL_WindowID windowID, int mode)

  1275 {

  1276     SDL_Window *window = SDL_GetWindowFromID(windowID);

  1278     if (!window || (!!mode == !!(window->flags & SDL_WINDOW_INPUT_GRABBED))) {

  1279         return;

  1280     }

  1281     if (mode) {

  1282         window->flags |= SDL_WINDOW_INPUT_GRABBED;

  1283     } else {

  1284         window->flags &= ~SDL_WINDOW_INPUT_GRABBED;

  1285     }

  1286     SDL_UpdateWindowGrab(window);

  1287 }

  1289 static void

  1290 SDL_UpdateWindowGrab(SDL_Window * window)

  1291 {

  1292     if ((window->flags & SDL_WINDOW_INPUT_FOCUS) && _this->SetWindowGrab) {

  1293         _this->SetWindowGrab(_this, window);

  1294     }

  1295 }

  1297 int

  1298 SDL_GetWindowGrab(SDL_WindowID windowID)

  1299 {

  1300     SDL_Window *window = SDL_GetWindowFromID(windowID);

  1302     if (!window) {

  1303         return 0;

  1304     }

  1305     return ((window->flags & SDL_WINDOW_INPUT_GRABBED) != 0);

  1306 }

  1308 void

  1309 SDL_OnWindowShown(SDL_Window * window)

  1310 {

  1311     if (window->flags & SDL_WINDOW_FULLSCREEN) {

  1312         SDL_SendWindowEvent(window->id, SDL_WINDOWEVENT_FOCUS_GAINED, 0, 0);

  1313     }

  1314 }

  1316 void

  1317 SDL_OnWindowHidden(SDL_Window * window)

  1318 {

  1319     if (window->flags & SDL_WINDOW_FULLSCREEN) {

  1320         SDL_SendWindowEvent(window->id, SDL_WINDOWEVENT_FOCUS_LOST, 0, 0);

  1321     }

  1322 }

  1324 void

  1325 SDL_OnWindowResized(SDL_Window * window)

  1326 {

  1327     SDL_Renderer *renderer = window->renderer;

  1329     if (renderer && renderer->DisplayModeChanged) {

  1330         renderer->DisplayModeChanged(renderer);

  1331     }

  1332 }

  1334 void

  1335 SDL_OnWindowFocusGained(SDL_Window * window)

  1336 {

  1337     SDL_VideoDisplay *display = SDL_GetDisplayFromWindow(window);

  1339     if (window->flags & SDL_WINDOW_FULLSCREEN) {

  1340         SDL_SetDisplayMode(&display->fullscreen_mode);

  1341     }

  1342     if (display->gamma && _this->SetDisplayGammaRamp) {

  1343         _this->SetDisplayGammaRamp(_this, display->gamma);

  1344     }

  1345     if ((window->flags & (SDL_WINDOW_INPUT_GRABBED | SDL_WINDOW_FULLSCREEN))

  1346         && _this->SetWindowGrab) {

  1347         _this->SetWindowGrab(_this, window);

  1348     }

  1349 }

  1351 void

  1352 SDL_OnWindowFocusLost(SDL_Window * window)

  1353 {

  1354     SDL_VideoDisplay *display = SDL_GetDisplayFromWindow(window);

  1356     if (window->flags & SDL_WINDOW_FULLSCREEN) {

  1357         SDL_MinimizeWindow(window->id);

  1358         SDL_SetDisplayMode(NULL);

  1359     }

  1360     if (display->gamma && _this->SetDisplayGammaRamp) {

  1361         _this->SetDisplayGammaRamp(_this, display->saved_gamma);

  1362     }

  1363     if ((window->flags & (SDL_WINDOW_INPUT_GRABBED | SDL_WINDOW_FULLSCREEN))

  1364         && _this->SetWindowGrab) {

  1365         _this->SetWindowGrab(_this, window);

  1366     }

  1367 }

  1369 SDL_WindowID

  1370 SDL_GetFocusWindow(void)

  1371 {

  1372     SDL_VideoDisplay *display;

  1373     int i;

  1375     if (!_this) {

  1376         return 0;

  1377     }

  1378     display = &SDL_CurrentDisplay;

  1379     for (i = 0; i < display->num_windows; ++i) {

  1380         SDL_Window *window = &display->windows[i];

  1382         if (window->flags & SDL_WINDOW_INPUT_FOCUS) {

  1383             return window->id;

  1384         }

  1385     }

  1386     return 0;

  1387 }

  1389 void

  1390 SDL_DestroyWindow(SDL_WindowID windowID)

  1391 {

  1392     int i, j;

  1394     if (!_this) {

  1395         return;

  1396     }

  1397     /* Restore video mode, etc. */

  1398     SDL_SendWindowEvent(windowID, SDL_WINDOWEVENT_FOCUS_LOST, 0, 0);

  1400     for (i = 0; i < _this->num_displays; ++i) {

  1401         SDL_VideoDisplay *display = &_this->displays[i];

  1402         for (j = 0; j < display->num_windows; ++j) {

  1403             SDL_Window *window = &display->windows[j];

  1404             if (window->id != windowID) {

  1405                 continue;

  1406             }

  1407             if (window->title) {

  1408                 SDL_free(window->title);

  1409                 window->title = NULL;

  1410             }

  1411             if (window->renderer) {

  1412                 SDL_DestroyRenderer(window->id);

  1413                 window->renderer = NULL;

  1414             }

  1415             if (_this->DestroyWindow) {

  1416                 _this->DestroyWindow(_this, window);

  1417             }

  1418             if (window->flags & SDL_WINDOW_OPENGL) {

  1419                 SDL_GL_UnloadLibrary();

  1420             }

  1421             if (j != display->num_windows - 1) {

  1422                 SDL_memcpy(&display->windows[i],

  1423                            &display->windows[i + 1],

  1424                            (display->num_windows - i - 1) * sizeof(*window));

  1425             }

  1426             --display->num_windows;

  1427             return;

  1428         }

  1429     }

  1430 }

  1432 void

  1433 SDL_AddRenderDriver(int displayIndex, const SDL_RenderDriver * driver)

  1434 {

  1435     SDL_VideoDisplay *display;

  1436     SDL_RenderDriver *render_drivers;

  1438     if (displayIndex >= _this->num_displays) {

  1439         return;

  1440     }

  1441     display = &_this->displays[displayIndex];

  1443     render_drivers =

  1444         SDL_realloc(display->render_drivers,

  1445                     (display->num_render_drivers +

  1446                      1) * sizeof(*render_drivers));

  1447     if (render_drivers) {

  1448         render_drivers[display->num_render_drivers] = *driver;

  1449         display->render_drivers = render_drivers;

  1450         display->num_render_drivers++;

  1451     }

  1452 }

  1454 int

  1455 SDL_GetNumRenderDrivers(void)

  1456 {

  1457     if (_this) {

  1458         return SDL_CurrentDisplay.num_render_drivers;

  1459     }

  1460     return 0;

  1461 }

  1463 int

  1464 SDL_GetRenderDriverInfo(int index, SDL_RendererInfo * info)

  1465 {

  1466     if (!_this) {

  1467         SDL_UninitializedVideo();

  1468         return -1;

  1469     }

  1470     if (index < 0 || index >= SDL_GetNumRenderDrivers()) {

  1471         SDL_SetError("index must be in the range of 0 - %d",

  1472                      SDL_GetNumRenderDrivers() - 1);

  1473         return -1;

  1474     }

  1475     *info = SDL_CurrentDisplay.render_drivers[index].info;

  1476     return 0;

  1477 }

  1479 int

  1480 SDL_CreateRenderer(SDL_WindowID windowID, int index, Uint32 flags)

  1481 {

  1482     SDL_Window *window = SDL_GetWindowFromID(windowID);

  1484     if (!window) {

  1485         SDL_SetError("Invalid window ID");

  1486         return -1;

  1487     }

  1489     /* Free any existing renderer */

  1490     SDL_DestroyRenderer(windowID);

  1492     if (index < 0) {

  1493         char *override = SDL_getenv("SDL_VIDEO_RENDERER");

  1494         int n = SDL_GetNumRenderDrivers();

  1496 #if SDL_VIDEO_RENDER_OGL

  1497         if (!override && (window->flags & SDL_WINDOW_OPENGL)) {

  1498             override = "opengl";

  1499         }

  1500 #endif /* SDL_VIDEO_RENDER_OGL */

  1501 #if SDL_VIDEO_RENDER_OGL_ES

  1502         if (!override && (window->flags & SDL_WINDOW_OPENGL)) {

  1503             override = "opengl_es";

  1504         }

  1505 #endif /* SDL_VIDEO_RENDER_OGL_ES */

  1506         if (override) {

  1507             for (index = 0; index < n; ++index) {

  1508                 SDL_RenderDriver *driver =

  1509                     &SDL_CurrentDisplay.render_drivers[index];

  1511                 if (SDL_strcasecmp(override, driver->info.name) == 0) {

  1512                     /* Create a new renderer instance */

  1513                     window->renderer = driver->CreateRenderer(window, flags);

  1514                     break;

  1515                 }

  1516             }

  1517         } else {

  1518             for (index = 0; index < n; ++index) {

  1519                 SDL_RenderDriver *driver =

  1520                     &SDL_CurrentDisplay.render_drivers[index];

  1522                 if ((driver->info.flags & flags) == flags) {

  1523                     /* Create a new renderer instance */

  1524                     window->renderer = driver->CreateRenderer(window, flags);

  1525                     if (window->renderer) {

  1526                         /* Yay, we got one! */

  1527                         break;

  1528                     }

  1529                 }

  1530             }

  1531         }

  1532         if (index == n) {

  1533             SDL_SetError("Couldn't find matching render driver");

  1534             return -1;

  1535         }

  1536     } else {

  1537         if (index >= SDL_GetNumRenderDrivers()) {

  1538             SDL_SetError("index must be -1 or in the range of 0 - %d",

  1539                          SDL_GetNumRenderDrivers() - 1);

  1540             return -1;

  1541         }

  1542         /* Create a new renderer instance */

  1543         window->renderer = SDL_CurrentDisplay.render_drivers[index].CreateRenderer(window, flags);

  1544     }

  1546     if (window->renderer == NULL) {

  1547         /* Assuming renderer set its error */

  1548         return -1;

  1549     }

  1551     SDL_SelectRenderer(window->id);

  1553     return 0;

  1554 }

  1556 int

  1557 SDL_SelectRenderer(SDL_WindowID windowID)

  1558 {

  1559     SDL_Window *window = SDL_GetWindowFromID(windowID);

  1560     SDL_Renderer *renderer;

  1562     if (!window) {

  1563         SDL_SetError("Invalid window ID");

  1564         return -1;

  1565     }

  1566     renderer = window->renderer;

  1567     if (!renderer) {

  1568         SDL_SetError("Use SDL_CreateRenderer() to create a renderer");

  1569         return -1;

  1570     }

  1571     if (renderer->ActivateRenderer) {

  1572         if (renderer->ActivateRenderer(renderer) < 0) {

  1573             return -1;

  1574         }

  1575     }

  1576     SDL_CurrentDisplay.current_renderer = renderer;

  1577     return 0;

  1578 }

  1580 int

  1581 SDL_GetRendererInfo(SDL_RendererInfo * info)

  1582 {

  1583     SDL_Renderer *renderer = SDL_GetCurrentRenderer(SDL_FALSE);

  1584     if (!renderer) {

  1585         return -1;

  1586     }

  1587     *info = renderer->info;

  1588     return 0;

  1589 }

  1591 SDL_TextureID

  1592 SDL_CreateTexture(Uint32 format, int access, int w, int h)

  1593 {

  1594     int hash;

  1595     SDL_Renderer *renderer;

  1596     SDL_Texture *texture;

  1598     renderer = SDL_GetCurrentRenderer(SDL_TRUE);

  1599     if (!renderer) {

  1600         return 0;

  1601     }

  1602     if (!renderer->CreateTexture) {

  1603         SDL_Unsupported();

  1604         return 0;

  1605     }

  1606     texture = (SDL_Texture *) SDL_calloc(1, sizeof(*texture));

  1607     if (!texture) {

  1608         SDL_OutOfMemory();

  1609         return 0;

  1610     }

  1611     texture->id = _this->next_object_id++;

  1612     texture->format = format;

  1613     texture->access = access;

  1614     texture->w = w;

  1615     texture->h = h;

  1616     texture->r = 255;

  1617     texture->g = 255;

  1618     texture->b = 255;

  1619     texture->a = 255;

  1620     texture->renderer = renderer;

  1622     if (renderer->CreateTexture(renderer, texture) < 0) {

  1623         if (renderer->DestroyTexture) {

  1624             renderer->DestroyTexture(renderer, texture);

  1625         }

  1626         SDL_free(texture);

  1627         return 0;

  1628     }

  1629     hash = (texture->id % SDL_arraysize(SDL_CurrentDisplay.textures));

  1630     texture->next = SDL_CurrentDisplay.textures[hash];

  1631     SDL_CurrentDisplay.textures[hash] = texture;

  1633     return texture->id;

  1634 }

  1636 SDL_TextureID

  1637 SDL_CreateTextureFromSurface(Uint32 format, SDL_Surface * surface)

  1638 {

  1639     SDL_TextureID textureID;

  1640     Uint32 requested_format = format;

  1641     SDL_PixelFormat *fmt;

  1642     SDL_Renderer *renderer;

  1643     int bpp;

  1644     Uint32 Rmask, Gmask, Bmask, Amask;

  1646     if (!surface) {

  1647         SDL_SetError("SDL_CreateTextureFromSurface() passed NULL surface");

  1648         return 0;

  1649     }

  1650     fmt = surface->format;

  1652     renderer = SDL_GetCurrentRenderer(SDL_TRUE);

  1653     if (!renderer) {

  1654         return 0;

  1655     }

  1657     if (format) {

  1658         if (!SDL_PixelFormatEnumToMasks

  1659             (format, &bpp, &Rmask, &Gmask, &Bmask, &Amask)) {

  1660             SDL_SetError("Unknown pixel format");

  1661             return 0;

  1662         }

  1663     } else {

  1664         if (surface->format->Amask

  1665             || !(surface->map->info.flags &

  1666                  (SDL_COPY_COLORKEY | SDL_COPY_MASK | SDL_COPY_BLEND))) {

  1667             Uint32 it;

  1668             int pfmt;

  1670             /* Pixel formats, sorted by best first */

  1671             static const Uint32 sdl_pformats[] = {

  1672                 SDL_PIXELFORMAT_ARGB8888,

  1673                 SDL_PIXELFORMAT_RGBA8888,

  1674                 SDL_PIXELFORMAT_ABGR8888,

  1675                 SDL_PIXELFORMAT_BGRA8888,

  1676                 SDL_PIXELFORMAT_RGB888,

  1677                 SDL_PIXELFORMAT_BGR888,

  1678                 SDL_PIXELFORMAT_RGB24,

  1679                 SDL_PIXELFORMAT_BGR24,

  1680                 SDL_PIXELFORMAT_RGB565,

  1681                 SDL_PIXELFORMAT_BGR565,

  1682                 SDL_PIXELFORMAT_ARGB1555,

  1683                 SDL_PIXELFORMAT_ABGR1555,

  1684                 SDL_PIXELFORMAT_RGB555,

  1685                 SDL_PIXELFORMAT_BGR555,

  1686                 SDL_PIXELFORMAT_ARGB4444,

  1687                 SDL_PIXELFORMAT_ABGR4444,

  1688                 SDL_PIXELFORMAT_RGB444,

  1689                 SDL_PIXELFORMAT_ARGB2101010,

  1690                 SDL_PIXELFORMAT_INDEX8,

  1691                 SDL_PIXELFORMAT_INDEX4LSB,

  1692                 SDL_PIXELFORMAT_INDEX4MSB,

  1693                 SDL_PIXELFORMAT_RGB332,

  1694                 SDL_PIXELFORMAT_INDEX1LSB,

  1695                 SDL_PIXELFORMAT_INDEX1MSB,

  1696                 SDL_PIXELFORMAT_UNKNOWN

  1697             };

  1699             bpp = fmt->BitsPerPixel;

  1700             Rmask = fmt->Rmask;

  1701             Gmask = fmt->Gmask;

  1702             Bmask = fmt->Bmask;

  1703             Amask = fmt->Amask;

  1705             format =

  1706                 SDL_MasksToPixelFormatEnum(bpp, Rmask, Gmask, Bmask, Amask);

  1707             if (!format) {

  1708                 SDL_SetError("Unknown pixel format");

  1709                 return 0;

  1710             }

  1712             /* Search requested format in the supported texture */

  1713             /* formats by current renderer                      */

  1714             for (it = 0; it < renderer->info.num_texture_formats; it++) {

  1715                 if (renderer->info.texture_formats[it] == format) {

  1716                     break;

  1717                 }

  1718             }

  1720             /* If requested format can't be found, search any best */

  1721             /* format which renderer provides                      */

  1722             if (it == renderer->info.num_texture_formats) {

  1723                 pfmt = 0;

  1724                 for (;;) {

  1725                     if (sdl_pformats[pfmt] == SDL_PIXELFORMAT_UNKNOWN) {

  1726                         break;

  1727                     }

  1729                     for (it = 0; it < renderer->info.num_texture_formats;

  1730                          it++) {

  1731                         if (renderer->info.texture_formats[it] ==

  1732                             sdl_pformats[pfmt]) {

  1733                             break;

  1734                         }

  1735                     }

  1737                     if (it != renderer->info.num_texture_formats) {

  1738                         /* The best format has been found */

  1739                         break;

  1740                     }

  1741                     pfmt++;

  1742                 }

  1744                 /* If any format can't be found, then return an error */

  1745                 if (it == renderer->info.num_texture_formats) {

  1746                     SDL_SetError

  1747                         ("Any of the supported pixel formats can't be found");

  1748                     return 0;

  1749                 }

  1751                 /* Convert found pixel format back to color masks */

  1752                 if (SDL_PixelFormatEnumToMasks

  1753                     (renderer->info.texture_formats[it], &bpp, &Rmask, &Gmask,

  1754                      &Bmask, &Amask) != SDL_TRUE) {

  1755                     SDL_SetError("Unknown pixel format");

  1756                     return 0;

  1757                 }

  1758             }

  1759         } else {

  1760             /* Need a format with alpha */

  1761             Uint32 it;

  1762             int apfmt;

  1764             /* Pixel formats with alpha, sorted by best first */

  1765             static const Uint32 sdl_alpha_pformats[] = {

  1766                 SDL_PIXELFORMAT_ARGB8888,

  1767                 SDL_PIXELFORMAT_RGBA8888,

  1768                 SDL_PIXELFORMAT_ABGR8888,

  1769                 SDL_PIXELFORMAT_BGRA8888,

  1770                 SDL_PIXELFORMAT_ARGB1555,

  1771                 SDL_PIXELFORMAT_ABGR1555,

  1772                 SDL_PIXELFORMAT_ARGB4444,

  1773                 SDL_PIXELFORMAT_ABGR4444,

  1774                 SDL_PIXELFORMAT_ARGB2101010,

  1775                 SDL_PIXELFORMAT_UNKNOWN

  1776             };

  1778             if (surface->format->Amask) {

  1779                 /* If surface already has alpha, then try an original */

  1780                 /* surface format first                               */

  1781                 bpp = fmt->BitsPerPixel;

  1782                 Rmask = fmt->Rmask;

  1783                 Gmask = fmt->Gmask;

  1784                 Bmask = fmt->Bmask;

  1785                 Amask = fmt->Amask;

  1786             } else {

  1787                 bpp = 32;

  1788                 Rmask = 0x00FF0000;

  1789                 Gmask = 0x0000FF00;

  1790                 Bmask = 0x000000FF;

  1791                 Amask = 0xFF000000;

  1792             }

  1794             format =

  1795                 SDL_MasksToPixelFormatEnum(bpp, Rmask, Gmask, Bmask, Amask);

  1796             if (!format) {

  1797                 SDL_SetError("Unknown pixel format");

  1798                 return 0;

  1799             }

  1801             /* Search this format in the supported texture formats */

  1802             /* by current renderer                                 */

  1803             for (it = 0; it < renderer->info.num_texture_formats; it++) {

  1804                 if (renderer->info.texture_formats[it] == format) {

  1805                     break;

  1806                 }

  1807             }

  1809             /* If this format can't be found, search any best       */

  1810             /* compatible format with alpha which renderer provides */

  1811             if (it == renderer->info.num_texture_formats) {

  1812                 apfmt = 0;

  1813                 for (;;) {

  1814                     if (sdl_alpha_pformats[apfmt] == SDL_PIXELFORMAT_UNKNOWN) {

  1815                         break;

  1816                     }

  1818                     for (it = 0; it < renderer->info.num_texture_formats;

  1819                          it++) {

  1820                         if (renderer->info.texture_formats[it] ==

  1821                             sdl_alpha_pformats[apfmt]) {

  1822                             break;

  1823                         }

  1824                     }

  1826                     if (it != renderer->info.num_texture_formats) {

  1827                         /* Compatible format has been found */

  1828                         break;

  1829                     }

  1830                     apfmt++;

  1831                 }

  1833                 /* If compatible format can't be found, then return an error */

  1834                 if (it == renderer->info.num_texture_formats) {

  1835                     SDL_SetError("Compatible pixel format can't be found");

  1836                     return 0;

  1837                 }

  1839                 /* Convert found pixel format back to color masks */

  1840                 if (SDL_PixelFormatEnumToMasks

  1841                     (renderer->info.texture_formats[it], &bpp, &Rmask, &Gmask,

  1842                      &Bmask, &Amask) != SDL_TRUE) {

  1843                     SDL_SetError("Unknown pixel format");

  1844                     return 0;

  1845                 }

  1846             }

  1847         }

  1849         format = SDL_MasksToPixelFormatEnum(bpp, Rmask, Gmask, Bmask, Amask);

  1850         if (!format) {

  1851             SDL_SetError("Unknown pixel format");

  1852             return 0;

  1853         }

  1854     }

  1856     textureID =

  1857         SDL_CreateTexture(format, SDL_TEXTUREACCESS_STATIC, surface->w,

  1858                           surface->h);

  1859     if (!textureID && !requested_format) {

  1860         SDL_DisplayMode desktop_mode;

  1861         SDL_GetDesktopDisplayMode(&desktop_mode);

  1862         format = desktop_mode.format;

  1863         textureID =

  1864             SDL_CreateTexture(format, SDL_TEXTUREACCESS_STATIC, surface->w,

  1865                               surface->h);

  1866     }

  1867     if (!textureID) {

  1868         return 0;

  1869     }

  1870     if (bpp == fmt->BitsPerPixel && Rmask == fmt->Rmask && Gmask == fmt->Gmask

  1871         && Bmask == fmt->Bmask && Amask == fmt->Amask) {

  1872         if (SDL_MUSTLOCK(surface)) {

  1873             SDL_LockSurface(surface);

  1874             SDL_UpdateTexture(textureID, NULL, surface->pixels,

  1875                               surface->pitch);

  1876             SDL_UnlockSurface(surface);

  1877         } else {

  1878             SDL_UpdateTexture(textureID, NULL, surface->pixels,

  1879                               surface->pitch);

  1880         }

  1881     } else {

  1882         SDL_PixelFormat dst_fmt;

  1883         SDL_Surface *dst = NULL;

  1885         /* Set up a destination surface for the texture update */

  1886         SDL_InitFormat(&dst_fmt, bpp, Rmask, Gmask, Bmask, Amask);

  1887         if (SDL_ISPIXELFORMAT_INDEXED(format)) {

  1888             dst_fmt.palette =

  1889                 SDL_AllocPalette((1 << SDL_BITSPERPIXEL(format)));

  1890             if (dst_fmt.palette) {

  1891                 /*

  1892                  * FIXME: Should we try to copy

  1893                  * fmt->palette?

  1894                  */

  1895                 SDL_DitherColors(dst_fmt.palette->colors,

  1896                                  SDL_BITSPERPIXEL(format));

  1897             }

  1898         }

  1899         dst = SDL_ConvertSurface(surface, &dst_fmt, 0);

  1900         if (dst) {

  1901             SDL_UpdateTexture(textureID, NULL, dst->pixels, dst->pitch);

  1902             SDL_FreeSurface(dst);

  1903         }

  1904         if (dst_fmt.palette) {

  1905             SDL_FreePalette(dst_fmt.palette);

  1906         }

  1907         if (!dst) {

  1908             SDL_DestroyTexture(textureID);

  1909             return 0;

  1910         }

  1911     }

  1913     {

  1914         Uint8 r, g, b, a;

  1915         int blendMode;

  1916         int scaleMode;

  1918         SDL_GetSurfaceColorMod(surface, &r, &g, &b);

  1919         SDL_SetTextureColorMod(textureID, r, g, b);

  1921         SDL_GetSurfaceAlphaMod(surface, &a);

  1922         SDL_SetTextureAlphaMod(textureID, a);

  1924         SDL_GetSurfaceBlendMode(surface, &blendMode);

  1925         SDL_SetTextureBlendMode(textureID, blendMode);

  1927         SDL_GetSurfaceScaleMode(surface, &scaleMode);

  1928         SDL_SetTextureScaleMode(textureID, scaleMode);

  1929     }

  1931     if (SDL_ISPIXELFORMAT_INDEXED(format) && fmt->palette) {

  1932         SDL_SetTexturePalette(textureID, fmt->palette->colors, 0,

  1933                               fmt->palette->ncolors);

  1934     }

  1935     return textureID;

  1936 }

  1938 static __inline__ SDL_Texture *

  1939 SDL_GetTextureFromID(SDL_TextureID textureID)

  1940 {

  1941     int hash;

  1942     SDL_Texture *texture;

  1944     if (!_this) {

  1945         return NULL;

  1946     }

  1947     hash = (textureID % SDL_arraysize(SDL_CurrentDisplay.textures));

  1948     for (texture = SDL_CurrentDisplay.textures[hash]; texture;

  1949          texture = texture->next) {

  1950         if (texture->id == textureID) {

  1951             return texture;

  1952         }

  1953     }

  1954     return NULL;

  1955 }

  1957 int

  1958 SDL_QueryTexture(SDL_TextureID textureID, Uint32 * format, int *access,

  1959                  int *w, int *h)

  1960 {

  1961     SDL_Texture *texture = SDL_GetTextureFromID(textureID);

  1963     if (!texture) {

  1964         return -1;

  1965     }

  1966     if (format) {

  1967         *format = texture->format;

  1968     }

  1969     if (access) {

  1970         *access = texture->access;

  1971     }

  1972     if (w) {

  1973         *w = texture->w;

  1974     }

  1975     if (h) {

  1976         *h = texture->h;

  1977     }

  1978     return 0;

  1979 }

  1981 int

  1982 SDL_QueryTexturePixels(SDL_TextureID textureID, void **pixels, int *pitch)

  1983 {

  1984     SDL_Texture *texture = SDL_GetTextureFromID(textureID);

  1985     SDL_Renderer *renderer;

  1987     if (!texture) {

  1988         return -1;

  1989     }

  1990     renderer = texture->renderer;

  1991     if (!renderer->QueryTexturePixels) {

  1992         SDL_Unsupported();

  1993         return -1;

  1994     }

  1995     return renderer->QueryTexturePixels(renderer, texture, pixels, pitch);

  1996 }

  1998 int

  1999 SDL_SetTexturePalette(SDL_TextureID textureID, const SDL_Color * colors,

  2000                       int firstcolor, int ncolors)

  2001 {

  2002     SDL_Texture *texture = SDL_GetTextureFromID(textureID);

  2003     SDL_Renderer *renderer;

  2005     if (!texture) {

  2006         return -1;

  2007     }

  2008     renderer = texture->renderer;

  2009     if (!renderer->SetTexturePalette) {

  2010         SDL_Unsupported();

  2011         return -1;

  2012     }

  2013     return renderer->SetTexturePalette(renderer, texture, colors, firstcolor,

  2014                                        ncolors);

  2015 }

  2017 int

  2018 SDL_GetTexturePalette(SDL_TextureID textureID, SDL_Color * colors,

  2019                       int firstcolor, int ncolors)

  2020 {

  2021     SDL_Texture *texture = SDL_GetTextureFromID(textureID);

  2022     SDL_Renderer *renderer;

  2024     if (!texture) {

  2025         return -1;

  2026     }

  2027     renderer = texture->renderer;

  2028     if (!renderer->GetTexturePalette) {

  2029         SDL_Unsupported();

  2030         return -1;

  2031     }

  2032     return renderer->GetTexturePalette(renderer, texture, colors, firstcolor,

  2033                                        ncolors);

  2034 }

  2036 int

  2037 SDL_SetTextureColorMod(SDL_TextureID textureID, Uint8 r, Uint8 g, Uint8 b)

  2038 {

  2039     SDL_Texture *texture = SDL_GetTextureFromID(textureID);

  2040     SDL_Renderer *renderer;

  2042     if (!texture) {

  2043         return -1;

  2044     }

  2045     renderer = texture->renderer;

  2046     if (!renderer->SetTextureColorMod) {

  2047         SDL_Unsupported();

  2048         return -1;

  2049     }

  2050     if (r < 255 || g < 255 || b < 255) {

  2051         texture->modMode |= SDL_TEXTUREMODULATE_COLOR;

  2052     } else {

  2053         texture->modMode &= ~SDL_TEXTUREMODULATE_COLOR;

  2054     }

  2055     texture->r = r;

  2056     texture->g = g;

  2057     texture->b = b;

  2058     return renderer->SetTextureColorMod(renderer, texture);

  2059 }

  2061 int

  2062 SDL_GetTextureColorMod(SDL_TextureID textureID, Uint8 * r, Uint8 * g,

  2063                        Uint8 * b)

  2064 {

  2065     SDL_Texture *texture = SDL_GetTextureFromID(textureID);

  2066     SDL_Renderer *renderer;

  2068     if (!texture) {

  2069         return -1;

  2070     }

  2071     renderer = texture->renderer;

  2072     if (r) {

  2073         *r = texture->r;

  2074     }

  2075     if (g) {

  2076         *g = texture->g;

  2077     }

  2078     if (b) {

  2079         *b = texture->b;

  2080     }

  2081     return 0;

  2082 }

  2084 int

  2085 SDL_SetTextureAlphaMod(SDL_TextureID textureID, Uint8 alpha)

  2086 {

  2087     SDL_Texture *texture = SDL_GetTextureFromID(textureID);

  2088     SDL_Renderer *renderer;

  2090     if (!texture) {

  2091         return -1;

  2092     }

  2093     renderer = texture->renderer;

  2094     if (!renderer->SetTextureAlphaMod) {

  2095         SDL_Unsupported();

  2096         return -1;

  2097     }

  2098     if (alpha < 255) {

  2099         texture->modMode |= SDL_TEXTUREMODULATE_ALPHA;

  2100     } else {

  2101         texture->modMode &= ~SDL_TEXTUREMODULATE_ALPHA;

  2102     }

  2103     texture->a = alpha;

  2104     return renderer->SetTextureAlphaMod(renderer, texture);

  2105 }

  2107 int

  2108 SDL_GetTextureAlphaMod(SDL_TextureID textureID, Uint8 * alpha)

  2109 {

  2110     SDL_Texture *texture = SDL_GetTextureFromID(textureID);

  2112     if (!texture) {

  2113         return -1;

  2114     }

  2115     if (alpha) {

  2116         *alpha = texture->a;

  2117     }

  2118     return 0;

  2119 }

  2121 int

  2122 SDL_SetTextureBlendMode(SDL_TextureID textureID, int blendMode)

  2123 {

  2124     SDL_Texture *texture = SDL_GetTextureFromID(textureID);

  2125     SDL_Renderer *renderer;

  2127     if (!texture) {

  2128         return -1;

  2129     }

  2130     renderer = texture->renderer;

  2131     if (!renderer->SetTextureBlendMode) {

  2132         SDL_Unsupported();

  2133         return -1;

  2134     }

  2135     texture->blendMode = blendMode;

  2136     return renderer->SetTextureBlendMode(renderer, texture);

  2137 }

  2139 int

  2140 SDL_GetTextureBlendMode(SDL_TextureID textureID, int *blendMode)

  2141 {

  2142     SDL_Texture *texture = SDL_GetTextureFromID(textureID);

  2144     if (!texture) {

  2145         return -1;

  2146     }

  2147     if (blendMode) {

  2148         *blendMode = texture->blendMode;

  2149     }

  2150     return 0;

  2151 }

  2153 int

  2154 SDL_SetTextureScaleMode(SDL_TextureID textureID, int scaleMode)

  2155 {

  2156     SDL_Texture *texture = SDL_GetTextureFromID(textureID);

  2157     SDL_Renderer *renderer;

  2159     if (!texture) {

  2160         return -1;

  2161     }

  2162     renderer = texture->renderer;

  2163     if (!renderer->SetTextureScaleMode) {

  2164         SDL_Unsupported();

  2165         return -1;

  2166     }

  2167     texture->scaleMode = scaleMode;

  2168     return renderer->SetTextureScaleMode(renderer, texture);

  2169 }

  2171 int

  2172 SDL_GetTextureScaleMode(SDL_TextureID textureID, int *scaleMode)

  2173 {

  2174     SDL_Texture *texture = SDL_GetTextureFromID(textureID);

  2176     if (!texture) {

  2177         return -1;

  2178     }

  2179     if (scaleMode) {

  2180         *scaleMode = texture->scaleMode;

  2181     }

  2182     return 0;

  2183 }

  2185 int

  2186 SDL_UpdateTexture(SDL_TextureID textureID, const SDL_Rect * rect,

  2187                   const void *pixels, int pitch)

  2188 {

  2189     SDL_Texture *texture = SDL_GetTextureFromID(textureID);

  2190     SDL_Renderer *renderer;

  2191     SDL_Rect full_rect;

  2193     if (!texture) {

  2194         return -1;

  2195     }

  2196     renderer = texture->renderer;

  2197     if (!renderer->UpdateTexture) {

  2198         SDL_Unsupported();

  2199         return -1;

  2200     }

  2201     if (!rect) {

  2202         full_rect.x = 0;

  2203         full_rect.y = 0;

  2204         full_rect.w = texture->w;

  2205         full_rect.h = texture->h;

  2206         rect = &full_rect;

  2207     }

  2208     return renderer->UpdateTexture(renderer, texture, rect, pixels, pitch);

  2209 }

  2211 int

  2212 SDL_LockTexture(SDL_TextureID textureID, const SDL_Rect * rect, int markDirty,

  2213                 void **pixels, int *pitch)

  2214 {

  2215     SDL_Texture *texture = SDL_GetTextureFromID(textureID);

  2216     SDL_Renderer *renderer;

  2217     SDL_Rect full_rect;

  2219     if (!texture) {

  2220         return -1;

  2221     }

  2222     if (texture->access != SDL_TEXTUREACCESS_STREAMING) {

  2223         SDL_SetError("SDL_LockTexture(): texture must be streaming");

  2224         return -1;

  2225     }

  2226     renderer = texture->renderer;

  2227     if (!renderer->LockTexture) {

  2228         SDL_Unsupported();

  2229         return -1;

  2230     }

  2231     if (!rect) {

  2232         full_rect.x = 0;

  2233         full_rect.y = 0;

  2234         full_rect.w = texture->w;

  2235         full_rect.h = texture->h;

  2236         rect = &full_rect;

  2237     }

  2238     return renderer->LockTexture(renderer, texture, rect, markDirty, pixels,

  2239                                  pitch);

  2240 }

  2242 void

  2243 SDL_UnlockTexture(SDL_TextureID textureID)

  2244 {

  2245     SDL_Texture *texture = SDL_GetTextureFromID(textureID);

  2246     SDL_Renderer *renderer;

  2248     if (!texture) {

  2249         return;

  2250     }

  2251     if (texture->access != SDL_TEXTUREACCESS_STREAMING) {

  2252         return;

  2253     }

  2254     renderer = texture->renderer;

  2255     if (!renderer->UnlockTexture) {

  2256         return;

  2257     }

  2258     renderer->UnlockTexture(renderer, texture);

  2259 }

  2261 void

  2262 SDL_DirtyTexture(SDL_TextureID textureID, int numrects,

  2263                  const SDL_Rect * rects)

  2264 {

  2265     SDL_Texture *texture = SDL_GetTextureFromID(textureID);

  2266     SDL_Renderer *renderer;

  2268     if (!texture) {

  2269         return;

  2270     }

  2271     if (texture->access != SDL_TEXTUREACCESS_STREAMING) {

  2272         return;

  2273     }

  2274     renderer = texture->renderer;

  2275     if (!renderer->DirtyTexture) {

  2276         return;

  2277     }

  2278     renderer->DirtyTexture(renderer, texture, numrects, rects);

  2279 }

  2281 int

  2282 SDL_SetRenderDrawColor(Uint8 r, Uint8 g, Uint8 b, Uint8 a)

  2283 {

  2284     SDL_Renderer *renderer;

  2286     renderer = SDL_GetCurrentRenderer(SDL_TRUE);

  2287     if (!renderer) {

  2288         return -1;

  2289     }

  2290     renderer->r = r;

  2291     renderer->g = g;

  2292     renderer->b = b;

  2293     renderer->a = a;

  2294     if (renderer->SetDrawColor) {

  2295         return renderer->SetDrawColor(renderer);

  2296     } else {

  2297         return 0;

  2298     }

  2299 }

  2301 int

  2302 SDL_GetRenderDrawColor(Uint8 * r, Uint8 * g, Uint8 * b, Uint8 * a)

  2303 {

  2304     SDL_Renderer *renderer;

  2306     renderer = SDL_GetCurrentRenderer(SDL_TRUE);

  2307     if (!renderer) {

  2308         return -1;

  2309     }

  2310     if (r) {

  2311         *r = renderer->r;

  2312     }

  2313     if (g) {

  2314         *g = renderer->g;

  2315     }

  2316     if (b) {

  2317         *b = renderer->b;

  2318     }

  2319     if (a) {

  2320         *a = renderer->a;

  2321     }

  2322     return 0;

  2323 }

  2325 int

  2326 SDL_SetRenderDrawBlendMode(int blendMode)

  2327 {

  2328     SDL_Renderer *renderer;

  2330     renderer = SDL_GetCurrentRenderer(SDL_TRUE);

  2331     if (!renderer) {

  2332         return -1;

  2333     }

  2334     renderer->blendMode = blendMode;

  2335     if (renderer->SetDrawBlendMode) {

  2336         return renderer->SetDrawBlendMode(renderer);

  2337     } else {

  2338         return 0;

  2339     }

  2340 }

  2342 int

  2343 SDL_GetRenderDrawBlendMode(int *blendMode)

  2344 {

  2345     SDL_Renderer *renderer;

  2347     renderer = SDL_GetCurrentRenderer(SDL_TRUE);

  2348     if (!renderer) {

  2349         return -1;

  2350     }

  2351     *blendMode = renderer->blendMode;

  2352     return 0;

  2353 }

  2355 int

  2356 SDL_RenderPoint(int x, int y)

  2357 {

  2358     SDL_Renderer *renderer;

  2359     SDL_Window *window;

  2361     renderer = SDL_GetCurrentRenderer(SDL_TRUE);

  2362     if (!renderer) {

  2363         return -1;

  2364     }

  2365     if (!renderer->RenderPoint) {

  2366         SDL_Unsupported();

  2367         return -1;

  2368     }

  2369     window = SDL_GetWindowFromID(renderer->window);

  2370     if (x < 0 || y < 0 || x >= window->w || y >= window->h) {

  2371         return 0;

  2372     }

  2373     return renderer->RenderPoint(renderer, x, y);

  2374 }

  2376 int

  2377 SDL_RenderLine(int x1, int y1, int x2, int y2)

  2378 {

  2379     SDL_Renderer *renderer;

  2380     SDL_Window *window;

  2381     SDL_Rect real_rect;

  2383     if (x1 == x2 && y1 == y2) {

  2384         return SDL_RenderPoint(x1, y1);

  2385     }

  2387     renderer = SDL_GetCurrentRenderer(SDL_TRUE);

  2388     if (!renderer) {

  2389         return -1;

  2390     }

  2391     if (!renderer->RenderLine) {

  2392         SDL_Unsupported();

  2393         return -1;

  2394     }

  2395     window = SDL_GetWindowFromID(renderer->window);

  2397     real_rect.x = 0;

  2398     real_rect.y = 0;

  2399     real_rect.w = window->w;

  2400     real_rect.h = window->h;

  2401     if (!SDL_IntersectRectAndLine(&real_rect, &x1, &y1, &x2, &y2)) {

  2402         return (0);

  2403     }

  2404     return renderer->RenderLine(renderer, x1, y1, x2, y2);

  2405 }

  2407 int

  2408 SDL_RenderFill(const SDL_Rect * rect)

  2409 {

  2410     SDL_Renderer *renderer;

  2411     SDL_Window *window;

  2412     SDL_Rect real_rect;

  2414     renderer = SDL_GetCurrentRenderer(SDL_TRUE);

  2415     if (!renderer) {

  2416         return -1;

  2417     }

  2418     if (!renderer->RenderFill) {

  2419         SDL_Unsupported();

  2420         return -1;

  2421     }

  2422     window = SDL_GetWindowFromID(renderer->window);

  2424     real_rect.x = 0;

  2425     real_rect.y = 0;

  2426     real_rect.w = window->w;

  2427     real_rect.h = window->h;

  2428     if (rect) {

  2429         if (!SDL_IntersectRect(rect, &real_rect, &real_rect)) {

  2430             return 0;

  2431         }

  2432     }

  2433     return renderer->RenderFill(renderer, &real_rect);

  2434 }

  2436 int

  2437 SDL_RenderCopy(SDL_TextureID textureID, const SDL_Rect * srcrect,

  2438                const SDL_Rect * dstrect)

  2439 {

  2440     SDL_Texture *texture = SDL_GetTextureFromID(textureID);

  2441     SDL_Renderer *renderer;

  2442     SDL_Window *window;

  2443     SDL_Rect real_srcrect;

  2444     SDL_Rect real_dstrect;

  2446     renderer = SDL_GetCurrentRenderer(SDL_TRUE);

  2447     if (!renderer) {

  2448         return -1;

  2449     }

  2450     if (!texture) {

  2451         SDL_SetError("Texture not found");

  2452         return -1;

  2453     }

  2454     if (texture->renderer != renderer) {

  2455         SDL_SetError("Texture was not created with this renderer");

  2456         return -1;

  2457     }

  2458     if (!renderer->RenderCopy) {

  2459         SDL_Unsupported();

  2460         return -1;

  2461     }

  2462     window = SDL_GetWindowFromID(renderer->window);

  2464     real_srcrect.x = 0;

  2465     real_srcrect.y = 0;

  2466     real_srcrect.w = texture->w;

  2467     real_srcrect.h = texture->h;

  2468     if (srcrect) {

  2469         if (!SDL_IntersectRect(srcrect, &real_srcrect, &real_srcrect)) {

  2470             return 0;

  2471         }

  2472     }

  2474     real_dstrect.x = 0;

  2475     real_dstrect.y = 0;

  2476     real_dstrect.w = window->w;

  2477     real_dstrect.h = window->h;

  2478     if (dstrect) {

  2479         if (!SDL_IntersectRect(dstrect, &real_dstrect, &real_dstrect)) {

  2480             return 0;

  2481         }

  2482         /* Clip srcrect by the same amount as dstrect was clipped */

  2483         if (dstrect->w != real_dstrect.w) {

  2484             int deltax = (real_dstrect.x - dstrect->x);

  2485             int deltaw = (real_dstrect.w - dstrect->w);

  2486             real_srcrect.x += (deltax * real_srcrect.w) / dstrect->w;

  2487             real_srcrect.w += (deltaw * real_srcrect.w) / dstrect->w;

  2488         }

  2489         if (dstrect->h != real_dstrect.h) {

  2490             int deltay = (real_dstrect.y - dstrect->y);

  2491             int deltah = (real_dstrect.h - dstrect->h);

  2492             real_srcrect.y += (deltay * real_srcrect.h) / dstrect->h;

  2493             real_srcrect.h += (deltah * real_srcrect.h) / dstrect->h;

  2494         }

  2495     }

  2497     return renderer->RenderCopy(renderer, texture, &real_srcrect,

  2498                                 &real_dstrect);

  2499 }

  2501 int

  2502 SDL_RenderReadPixels(const SDL_Rect * rect, Uint32 format,

  2503                      void * pixels, int pitch)

  2504 {

  2505     SDL_Renderer *renderer;

  2506     SDL_Window *window;

  2507     SDL_Rect real_rect;

  2509     renderer = SDL_GetCurrentRenderer(SDL_TRUE);

  2510     if (!renderer) {

  2511         return -1;

  2512     }

  2513     if (!renderer->RenderReadPixels) {

  2514         SDL_Unsupported();

  2515         return -1;

  2516     }

  2517     window = SDL_GetWindowFromID(renderer->window);

  2519     if (!format) {

  2520         format = SDL_GetDisplayFromWindow(window)->current_mode.format;

  2521     }

  2523     real_rect.x = 0;

  2524     real_rect.y = 0;

  2525     real_rect.w = window->w;

  2526     real_rect.h = window->h;

  2527     if (rect) {

  2528         if (!SDL_IntersectRect(rect, &real_rect, &real_rect)) {

  2529             return 0;

  2530         }

  2531         if (real_rect.y > rect->y) {

  2532             pixels = (Uint8 *)pixels + pitch * (real_rect.y - rect->y);

  2533         }

  2534         if (real_rect.x > rect->x) {

  2535             Uint32 format = SDL_CurrentDisplay.current_mode.format;

  2536             int bpp = SDL_BYTESPERPIXEL(format);

  2537             pixels = (Uint8 *)pixels + bpp * (real_rect.x - rect->x);

  2538         }

  2539     }

  2541     return renderer->RenderReadPixels(renderer, &real_rect,

  2542                                       format, pixels, pitch);

  2543 }

  2545 int

  2546 SDL_RenderWritePixels(const SDL_Rect * rect, Uint32 format,

  2547                       const void * pixels, int pitch)

  2548 {

  2549     SDL_Renderer *renderer;

  2550     SDL_Window *window;

  2551     SDL_Rect real_rect;

  2553     renderer = SDL_GetCurrentRenderer(SDL_TRUE);

  2554     if (!renderer) {

  2555         return -1;

  2556     }

  2557     if (!renderer->RenderWritePixels) {

  2558         SDL_Unsupported();

  2559         return -1;

  2560     }

  2561     window = SDL_GetWindowFromID(renderer->window);

  2563     if (!format) {

  2564         format = SDL_GetDisplayFromWindow(window)->current_mode.format;

  2565     }

  2567     real_rect.x = 0;

  2568     real_rect.y = 0;

  2569     real_rect.w = window->w;

  2570     real_rect.h = window->h;

  2571     if (rect) {

  2572         if (!SDL_IntersectRect(rect, &real_rect, &real_rect)) {

  2573             return 0;

  2574         }

  2575         if (real_rect.y > rect->y) {

  2576             pixels = (const Uint8 *)pixels + pitch * (real_rect.y - rect->y);

  2577         }

  2578         if (real_rect.x > rect->x) {

  2579             Uint32 format = SDL_CurrentDisplay.current_mode.format;

  2580             int bpp = SDL_BYTESPERPIXEL(format);

  2581             pixels = (const Uint8 *)pixels + bpp * (real_rect.x - rect->x);

  2582         }

  2583     }

  2585     return renderer->RenderWritePixels(renderer, &real_rect,

  2586                                        format, pixels, pitch);

  2587 }

  2589 void

  2590 SDL_RenderPresent(void)

  2591 {

  2592     SDL_Renderer *renderer;

  2594     renderer = SDL_GetCurrentRenderer(SDL_TRUE);

  2595     if (!renderer || !renderer->RenderPresent) {

  2596         return;

  2597     }

  2598     renderer->RenderPresent(renderer);

  2599 }

  2601 void

  2602 SDL_DestroyTexture(SDL_TextureID textureID)

  2603 {

  2604     int hash;

  2605     SDL_Texture *prev, *texture;

  2606     SDL_Renderer *renderer;

  2608     if (!_this) {

  2609         SDL_UninitializedVideo();

  2610         return;

  2611     }

  2612     /* Look up the texture in the hash table */

  2613     hash = (textureID % SDL_arraysize(SDL_CurrentDisplay.textures));

  2614     prev = NULL;

  2615     for (texture = SDL_CurrentDisplay.textures[hash]; texture;

  2616          prev = texture, texture = texture->next) {

  2617         if (texture->id == textureID) {

  2618             break;

  2619         }

  2620     }

  2621     if (!texture) {

  2622         return;

  2623     }

  2624     /* Unlink the texture from the list */

  2625     if (prev) {

  2626         prev->next = texture->next;

  2627     } else {

  2628         SDL_CurrentDisplay.textures[hash] = texture->next;

  2629     }

  2631     /* Free the texture */

  2632     renderer = texture->renderer;

  2633     renderer->DestroyTexture(renderer, texture);

  2634     SDL_free(texture);

  2635 }

  2637 void

  2638 SDL_DestroyRenderer(SDL_WindowID windowID)

  2639 {

  2640     SDL_Window *window = SDL_GetWindowFromID(windowID);

  2641     SDL_Renderer *renderer;

  2642     int i;

  2644     if (!window) {

  2645         return;

  2646     }

  2647     renderer = window->renderer;

  2648     if (!renderer) {

  2649         return;

  2650     }

  2651     /* Free existing textures for this renderer */

  2652     for (i = 0; i < SDL_arraysize(SDL_CurrentDisplay.textures); ++i) {

  2653         SDL_Texture *texture;

  2654         SDL_Texture *prev = NULL;

  2655         SDL_Texture *next;

  2656         for (texture = SDL_CurrentDisplay.textures[i]; texture;

  2657              texture = next) {

  2658             next = texture->next;

  2659             if (texture->renderer == renderer) {

  2660                 if (prev) {

  2661                     prev->next = next;

  2662                 } else {

  2663                     SDL_CurrentDisplay.textures[i] = next;

  2664                 }

  2665                 renderer->DestroyTexture(renderer, texture);

  2666                 SDL_free(texture);

  2667             } else {

  2668                 prev = texture;

  2669             }

  2670         }

  2671     }

  2673     /* Free the renderer instance */

  2674     renderer->DestroyRenderer(renderer);

  2676     /* Clear references */

  2677     window->renderer = NULL;

  2678     if (SDL_CurrentDisplay.current_renderer == renderer) {

  2679         SDL_CurrentDisplay.current_renderer = NULL;

  2680     }

  2681 }

  2683 SDL_bool

  2684 SDL_IsScreenSaverEnabled()

  2685 {

  2686     if (!_this) {

  2687         return SDL_TRUE;

  2688     }

  2689     return _this->suspend_screensaver ? SDL_FALSE : SDL_TRUE;

  2690 }

  2692 void

  2693 SDL_EnableScreenSaver()

  2694 {

  2695     if (!_this) {

  2696         return;

  2697     }

  2698     if (!_this->suspend_screensaver) {

  2699         return;

  2700     }

  2701     _this->suspend_screensaver = SDL_FALSE;

  2702     if (_this->SuspendScreenSaver) {

  2703         _this->SuspendScreenSaver(_this);

  2704     }

  2705 }

  2707 void

  2708 SDL_DisableScreenSaver()

  2709 {

  2710     if (!_this) {

  2711         return;

  2712     }

  2713     if (_this->suspend_screensaver) {

  2714         return;

  2715     }

  2716     _this->suspend_screensaver = SDL_TRUE;

  2717     if (_this->SuspendScreenSaver) {

  2718         _this->SuspendScreenSaver(_this);

  2719     }

  2720 }

  2722 void

  2723 SDL_VideoQuit(void)

  2724 {

  2725     int i, j;

  2727     if (!_this) {

  2728         return;

  2729     }

  2730     /* Halt event processing before doing anything else */

  2731     SDL_StopEventLoop();

  2732     SDL_EnableScreenSaver();

  2734     /* Clean up the system video */

  2735     for (i = _this->num_displays; i--;) {

  2736         SDL_VideoDisplay *display = &_this->displays[i];

  2737         for (j = display->num_windows; j--;) {

  2738             SDL_DestroyWindow(display->windows[i].id);

  2739         }

  2740         if (display->windows) {

  2741             SDL_free(display->windows);

  2742             display->windows = NULL;

  2743         }

  2744         display->num_windows = 0;

  2745         if (display->render_drivers) {

  2746             SDL_free(display->render_drivers);

  2747             display->render_drivers = NULL;

  2748         }

  2749         display->num_render_drivers = 0;

  2750     }

  2751     _this->VideoQuit(_this);

  2753     for (i = _this->num_displays; i--;) {

  2754         SDL_VideoDisplay *display = &_this->displays[i];

  2755         for (j = display->num_display_modes; j--;) {

  2756             if (display->display_modes[j].driverdata) {

  2757                 SDL_free(display->display_modes[j].driverdata);

  2758                 display->display_modes[j].driverdata = NULL;

  2759             }

  2760         }

  2761         if (display->display_modes) {

  2762             SDL_free(display->display_modes);

  2763             display->display_modes = NULL;

  2764         }

  2765         if (display->desktop_mode.driverdata) {

  2766             SDL_free(display->desktop_mode.driverdata);

  2767             display->desktop_mode.driverdata = NULL;

  2768         }

  2769         if (display->palette) {

  2770             SDL_FreePalette(display->palette);

  2771             display->palette = NULL;

  2772         }

  2773         if (display->gamma) {

  2774             SDL_free(display->gamma);

  2775             display->gamma = NULL;

  2776         }

  2777         if (display->driverdata) {

  2778             SDL_free(display->driverdata);

  2779             display->driverdata = NULL;

  2780         }

  2781     }

  2782     if (_this->displays) {

  2783         SDL_free(_this->displays);

  2784         _this->displays = NULL;

  2785     }

  2786     _this->free(_this);

  2787     _this = NULL;

  2788 }

  2790 int

  2791 SDL_GL_LoadLibrary(const char *path)

  2792 {

  2793     int retval;

  2795     if (!_this) {

  2796         SDL_UninitializedVideo();

  2797         return -1;

  2798     }

  2799     if (_this->gl_config.driver_loaded) {

  2800         if (path && SDL_strcmp(path, _this->gl_config.driver_path) != 0) {

  2801             SDL_SetError("OpenGL library already loaded");

  2802             return -1;

  2803         }

  2804         retval = 0;

  2805     } else {

  2806         if (!_this->GL_LoadLibrary) {

  2807             SDL_SetError("No dynamic GL support in video driver");

  2808             return -1;

  2809         }

  2810         retval = _this->GL_LoadLibrary(_this, path);

  2811     }

  2812     if (retval == 0) {

  2813         ++_this->gl_config.driver_loaded;

  2814     }

  2815     return (retval);

  2816 }

  2818 void *

  2819 SDL_GL_GetProcAddress(const char *proc)

  2820 {

  2821     void *func;

  2823     if (!_this) {

  2824         SDL_UninitializedVideo();

  2825         return NULL;

  2826     }

  2827     func = NULL;

  2828     if (_this->GL_GetProcAddress) {

  2829         if (_this->gl_config.driver_loaded) {

  2830             func = _this->GL_GetProcAddress(_this, proc);

  2831         } else {

  2832             SDL_SetError("No GL driver has been loaded");

  2833         }

  2834     } else {

  2835         SDL_SetError("No dynamic GL support in video driver");

  2836     }

  2837     return func;

  2838 }

  2840 void

  2841 SDL_GL_UnloadLibrary(void)

  2842 {

  2843     if (!_this) {

  2844         SDL_UninitializedVideo();

  2845         return;

  2846     }

  2847     if (_this->gl_config.driver_loaded > 0) {

  2848         if (--_this->gl_config.driver_loaded > 0) {

  2849             return;

  2850         }

  2851         if (_this->GL_UnloadLibrary) {

  2852             _this->GL_UnloadLibrary(_this);

  2853         }

  2854     }

  2855 }

  2857 SDL_bool

  2858 SDL_GL_ExtensionSupported(const char *extension)

  2859 {

  2860 #if SDL_VIDEO_OPENGL || SDL_VIDEO_OPENGL_ES

  2861     const GLubyte *(APIENTRY * glGetStringFunc) (GLenum);

  2862     const char *extensions;

  2863     const char *start;

  2864     const char *where, *terminator;

  2866     /* Extension names should not have spaces. */

  2867     where = SDL_strchr(extension, ' ');

  2868     if (where || *extension == '\0') {

  2869         return SDL_FALSE;

  2870     }

  2871     /* See if there's an environment variable override */

  2872     start = SDL_getenv(extension);

  2873     if (start && *start == '0') {

  2874         return SDL_FALSE;

  2875     }

  2876     /* Lookup the available extensions */

  2877     glGetStringFunc = SDL_GL_GetProcAddress("glGetString");

  2878     if (glGetStringFunc) {

  2879         extensions = (const char *) glGetStringFunc(GL_EXTENSIONS);

  2880     } else {

  2881         extensions = NULL;

  2882     }

  2883     if (!extensions) {

  2884         return SDL_FALSE;

  2885     }

  2886     /*

  2887      * It takes a bit of care to be fool-proof about parsing the OpenGL

  2888      * extensions string. Don't be fooled by sub-strings, etc.

  2889      */

  2891     start = extensions;

  2893     for (;;) {

  2894         where = SDL_strstr(start, extension);

  2895         if (!where)

  2896             break;

  2898         terminator = where + SDL_strlen(extension);

  2899         if (where == start || *(where - 1) == ' ')

  2900             if (*terminator == ' ' || *terminator == '\0')

  2901                 return SDL_TRUE;

  2903         start = terminator;

  2904     }

  2905     return SDL_FALSE;

  2906 #else

  2907     return SDL_FALSE;

  2908 #endif

  2909 }

  2911 int

  2912 SDL_GL_SetAttribute(SDL_GLattr attr, int value)

  2913 {

  2914 #if SDL_VIDEO_OPENGL || SDL_VIDEO_OPENGL_ES

  2915     int retval;

  2917     if (!_this) {

  2918         SDL_UninitializedVideo();

  2919         return -1;

  2920     }

  2921     retval = 0;

  2922     switch (attr) {

  2923     case SDL_GL_RED_SIZE:

  2924         _this->gl_config.red_size = value;

  2925         break;

  2926     case SDL_GL_GREEN_SIZE:

  2927         _this->gl_config.green_size = value;

  2928         break;

  2929     case SDL_GL_BLUE_SIZE:

  2930         _this->gl_config.blue_size = value;

  2931         break;

  2932     case SDL_GL_ALPHA_SIZE:

  2933         _this->gl_config.alpha_size = value;

  2934         break;

  2935     case SDL_GL_DOUBLEBUFFER:

  2936         _this->gl_config.double_buffer = value;

  2937         break;

  2938     case SDL_GL_BUFFER_SIZE:

  2939         _this->gl_config.buffer_size = value;

  2940         break;

  2941     case SDL_GL_DEPTH_SIZE:

  2942         _this->gl_config.depth_size = value;

  2943         break;

  2944     case SDL_GL_STENCIL_SIZE:

  2945         _this->gl_config.stencil_size = value;

  2946         break;

  2947     case SDL_GL_ACCUM_RED_SIZE:

  2948         _this->gl_config.accum_red_size = value;

  2949         break;

  2950     case SDL_GL_ACCUM_GREEN_SIZE:

  2951         _this->gl_config.accum_green_size = value;

  2952         break;

  2953     case SDL_GL_ACCUM_BLUE_SIZE:

  2954         _this->gl_config.accum_blue_size = value;

  2955         break;

  2956     case SDL_GL_ACCUM_ALPHA_SIZE:

  2957         _this->gl_config.accum_alpha_size = value;

  2958         break;

  2959     case SDL_GL_STEREO:

  2960         _this->gl_config.stereo = value;

  2961         break;

  2962     case SDL_GL_MULTISAMPLEBUFFERS:

  2963         _this->gl_config.multisamplebuffers = value;

  2964         break;

  2965     case SDL_GL_MULTISAMPLESAMPLES:

  2966         _this->gl_config.multisamplesamples = value;

  2967         break;

  2968     case SDL_GL_ACCELERATED_VISUAL:

  2969         _this->gl_config.accelerated = value;

  2970         break;

  2971     case SDL_GL_RETAINED_BACKING:

  2972         _this->gl_config.retained_backing = value;

  2973         break;

  2974     case SDL_GL_CONTEXT_MAJOR_VERSION:

  2975         _this->gl_config.major_version = value;

  2976         break;

  2977     case SDL_GL_CONTEXT_MINOR_VERSION:

  2978         _this->gl_config.minor_version = value;

  2979         break;

  2980     default:

  2981         SDL_SetError("Unknown OpenGL attribute");

  2982         retval = -1;

  2983         break;

  2984     }

  2985     return retval;

  2986 #else

  2987     SDL_Unsupported();

  2988     return -1;

  2989 #endif /* SDL_VIDEO_OPENGL */

  2990 }

  2992 int

  2993 SDL_GL_GetAttribute(SDL_GLattr attr, int *value)

  2994 {

  2995 #if SDL_VIDEO_OPENGL || SDL_VIDEO_OPENGL_ES

  2996     void (APIENTRY * glGetIntegervFunc) (GLenum pname, GLint * params);

  2997     GLenum(APIENTRY * glGetErrorFunc) (void);

  2998     GLenum attrib = 0;

  2999     GLenum error = 0;

  3001     glGetIntegervFunc = SDL_GL_GetProcAddress("glGetIntegerv");

  3002     if (!glGetIntegervFunc) {

  3003         return -1;

  3004     }

  3006     glGetErrorFunc = SDL_GL_GetProcAddress("glGetError");

  3007     if (!glGetErrorFunc) {

  3008         return -1;

  3009     }

  3011     /* Clear value in any case */

  3012     *value = 0;

  3014     switch (attr) {

  3015     case SDL_GL_RETAINED_BACKING:

  3016         *value = _this->gl_config.retained_backing;

  3017         return 0;

  3018     case SDL_GL_RED_SIZE:

  3019         attrib = GL_RED_BITS;

  3020         break;

  3021     case SDL_GL_BLUE_SIZE:

  3022         attrib = GL_BLUE_BITS;

  3023         break;

  3024     case SDL_GL_GREEN_SIZE:

  3025         attrib = GL_GREEN_BITS;

  3026         break;

  3027     case SDL_GL_ALPHA_SIZE:

  3028         attrib = GL_ALPHA_BITS;

  3029         break;

  3030     case SDL_GL_DOUBLEBUFFER:

  3031 #ifndef SDL_VIDEO_OPENGL_ES

  3032         attrib = GL_DOUBLEBUFFER;

  3033         break;

  3034 #else

  3035         /* OpenGL ES 1.0 and above specifications have EGL_SINGLE_BUFFER      */

  3036         /* parameter which switches double buffer to single buffer. OpenGL ES */

  3037         /* SDL driver must set proper value after initialization              */

  3038         *value = _this->gl_config.double_buffer;

  3039         return 0;

  3040 #endif

  3041     case SDL_GL_DEPTH_SIZE:

  3042         attrib = GL_DEPTH_BITS;

  3043         break;

  3044     case SDL_GL_STENCIL_SIZE:

  3045         attrib = GL_STENCIL_BITS;

  3046         break;

  3047 #ifndef SDL_VIDEO_OPENGL_ES

  3048     case SDL_GL_ACCUM_RED_SIZE:

  3049         attrib = GL_ACCUM_RED_BITS;

  3050         break;

  3051     case SDL_GL_ACCUM_GREEN_SIZE:

  3052         attrib = GL_ACCUM_GREEN_BITS;

  3053         break;

  3054     case SDL_GL_ACCUM_BLUE_SIZE:

  3055         attrib = GL_ACCUM_BLUE_BITS;

  3056         break;

  3057     case SDL_GL_ACCUM_ALPHA_SIZE:

  3058         attrib = GL_ACCUM_ALPHA_BITS;

  3059         break;

  3060     case SDL_GL_STEREO:

  3061         attrib = GL_STEREO;

  3062         break;

  3063 #else

  3064     case SDL_GL_ACCUM_RED_SIZE:

  3065     case SDL_GL_ACCUM_GREEN_SIZE:

  3066     case SDL_GL_ACCUM_BLUE_SIZE:

  3067     case SDL_GL_ACCUM_ALPHA_SIZE:

  3068     case SDL_GL_STEREO:

  3069         /* none of these are supported in OpenGL ES */

  3070         *value = 0;

  3071         return 0;

  3072 #endif

  3073     case SDL_GL_MULTISAMPLEBUFFERS:

  3074 #ifndef SDL_VIDEO_OPENGL_ES

  3075         attrib = GL_SAMPLE_BUFFERS_ARB;

  3076 #else

  3077         attrib = GL_SAMPLE_BUFFERS;

  3078 #endif

  3079         break;

  3080     case SDL_GL_MULTISAMPLESAMPLES:

  3081 #ifndef SDL_VIDEO_OPENGL_ES

  3082         attrib = GL_SAMPLES_ARB;

  3083 #else

  3084         attrib = GL_SAMPLES;

  3085 #endif

  3086         break;

  3087     case SDL_GL_BUFFER_SIZE:

  3088         {

  3089             GLint bits = 0;

  3090             GLint component;

  3092             /*

  3093              * there doesn't seem to be a single flag in OpenGL

  3094              * for this!

  3095              */

  3096             glGetIntegervFunc(GL_RED_BITS, &component);

  3097             bits += component;

  3098             glGetIntegervFunc(GL_GREEN_BITS, &component);

  3099             bits += component;

  3100             glGetIntegervFunc(GL_BLUE_BITS, &component);

  3101             bits += component;

  3102             glGetIntegervFunc(GL_ALPHA_BITS, &component);

  3103             bits += component;

  3105             *value = bits;

  3106             return 0;

  3107         }

  3108     case SDL_GL_ACCELERATED_VISUAL:

  3109         {

  3110             /* FIXME: How do we get this information? */

  3111             *value = (_this->gl_config.accelerated != 0);

  3112             return 0;

  3113         }

  3114     default:

  3115         SDL_SetError("Unknown OpenGL attribute");

  3116         return -1;

  3117     }

  3119     glGetIntegervFunc(attrib, (GLint *) value);

  3120     error = glGetErrorFunc();

  3121     if (error != GL_NO_ERROR) {

  3122         switch (error) {

  3123         case GL_INVALID_ENUM:

  3124             {

  3125                 SDL_SetError("OpenGL error: GL_INVALID_ENUM");

  3126             }

  3127             break;

  3128         case GL_INVALID_VALUE:

  3129             {

  3130                 SDL_SetError("OpenGL error: GL_INVALID_VALUE");

  3131             }

  3132             break;

  3133         default:

  3134             {

  3135                 SDL_SetError("OpenGL error: %08X", error);

  3136             }

  3137             break;

  3138         }

  3139         return -1;

  3140     }

  3141     return 0;

  3142 #else

  3143     SDL_Unsupported();

  3144     return -1;

  3145 #endif /* SDL_VIDEO_OPENGL */

  3146 }

  3148 SDL_GLContext

  3149 SDL_GL_CreateContext(SDL_WindowID windowID)

  3150 {

  3151     SDL_Window *window = SDL_GetWindowFromID(windowID);

  3153     if (!window) {

  3154         return NULL;

  3155     }

  3156     if (!(window->flags & SDL_WINDOW_OPENGL)) {

  3157         SDL_SetError("The specified window isn't an OpenGL window");

  3158         return NULL;

  3159     }

  3160     return _this->GL_CreateContext(_this, window);

  3161 }

  3163 int

  3164 SDL_GL_MakeCurrent(SDL_WindowID windowID, SDL_GLContext context)

  3165 {

  3166     SDL_Window *window = SDL_GetWindowFromID(windowID);

  3168     if (window && !(window->flags & SDL_WINDOW_OPENGL)) {

  3169         SDL_SetError("The specified window isn't an OpenGL window");

  3170         return -1;

  3171     }

  3172     if (!context) {

  3173         window = NULL;

  3174     }

  3175     return _this->GL_MakeCurrent(_this, window, context);

  3176 }

  3178 int

  3179 SDL_GL_SetSwapInterval(int interval)

  3180 {

  3181     if (!_this) {

  3182         SDL_UninitializedVideo();

  3183         return -1;

  3184     }

  3185     if (_this->GL_SetSwapInterval) {

  3186         return _this->GL_SetSwapInterval(_this, interval);

  3187     } else {

  3188         SDL_SetError("Setting the swap interval is not supported");

  3189         return -1;

  3190     }

  3191 }

  3193 int

  3194 SDL_GL_GetSwapInterval(void)

  3195 {

  3196     if (!_this) {

  3197         SDL_UninitializedVideo();

  3198         return -1;

  3199     }

  3200     if (_this->GL_GetSwapInterval) {

  3201         return _this->GL_GetSwapInterval(_this);

  3202     } else {

  3203         SDL_SetError("Getting the swap interval is not supported");

  3204         return -1;

  3205     }

  3206 }

  3208 void

  3209 SDL_GL_SwapWindow(SDL_WindowID windowID)

  3210 {

  3211     SDL_Window *window = SDL_GetWindowFromID(windowID);

  3213     if (!window) {

  3214         return;

  3215     }

  3216     if (!(window->flags & SDL_WINDOW_OPENGL)) {

  3217         SDL_SetError("The specified window isn't an OpenGL window");

  3218         return;

  3219     }

  3220     _this->GL_SwapWindow(_this, window);

  3221 }

  3223 void

  3224 SDL_GL_DeleteContext(SDL_GLContext context)

  3225 {

  3226     if (!_this || !context) {

  3227         return;

  3228     }

  3229     _this->GL_MakeCurrent(_this, NULL, NULL);

  3230     _this->GL_DeleteContext(_this, context);

  3231 }

  3233 #if 0                           // FIXME

  3234 /*

  3235  * Utility function used by SDL_WM_SetIcon(); flags & 1 for color key, flags

  3236  * & 2 for alpha channel.

  3237  */

  3238 static void

  3239 CreateMaskFromColorKeyOrAlpha(SDL_Surface * icon, Uint8 * mask, int flags)

  3240 {

  3241     int x, y;

  3242     Uint32 colorkey;

  3243 #define SET_MASKBIT(icon, x, y, mask) \

  3244 	mask[(y*((icon->w+7)/8))+(x/8)] &= ~(0x01<<(7-(x%8)))

  3246     colorkey = icon->format->colorkey;

  3247     switch (icon->format->BytesPerPixel) {

  3248     case 1:

  3249         {

  3250             Uint8 *pixels;

  3251             for (y = 0; y < icon->h; ++y) {

  3252                 pixels = (Uint8 *) icon->pixels + y * icon->pitch;

  3253                 for (x = 0; x < icon->w; ++x) {

  3254                     if (*pixels++ == colorkey) {

  3255                         SET_MASKBIT(icon, x, y, mask);

  3256                     }

  3257                 }

  3258             }

  3259         }

  3260         break;

  3262     case 2:

  3263         {

  3264             Uint16 *pixels;

  3265             for (y = 0; y < icon->h; ++y) {

  3266                 pixels = (Uint16 *) icon->pixels + y * icon->pitch / 2;

  3267                 for (x = 0; x < icon->w; ++x) {

  3268                     if ((flags & 1) && *pixels == colorkey) {

  3269                         SET_MASKBIT(icon, x, y, mask);

  3270                     } else if ((flags & 2)

  3271                                && (*pixels & icon->format->Amask) == 0) {

  3272                         SET_MASKBIT(icon, x, y, mask);

  3273                     }

  3274                     pixels++;

  3275                 }

  3276             }

  3277         }

  3278         break;

  3280     case 4:

  3281         {

  3282             Uint32 *pixels;

  3283             for (y = 0; y < icon->h; ++y) {

  3284                 pixels = (Uint32 *) icon->pixels + y * icon->pitch / 4;

  3285                 for (x = 0; x < icon->w; ++x) {

  3286                     if ((flags & 1) && *pixels == colorkey) {

  3287                         SET_MASKBIT(icon, x, y, mask);

  3288                     } else if ((flags & 2)

  3289                                && (*pixels & icon->format->Amask) == 0) {

  3290                         SET_MASKBIT(icon, x, y, mask);

  3291                     }

  3292                     pixels++;

  3293                 }

  3294             }

  3295         }

  3296         break;

  3297     }

  3298 }

  3300 /*

  3301  * Sets the window manager icon for the display window.

  3302  */

  3303 void

  3304 SDL_WM_SetIcon(SDL_Surface * icon, Uint8 * mask)

  3305 {

  3306     if (icon && _this->SetIcon) {

  3307         /* Generate a mask if necessary, and create the icon! */

  3308         if (mask == NULL) {

  3309             int mask_len = icon->h * (icon->w + 7) / 8;

  3310             int flags = 0;

  3311             mask = (Uint8 *) SDL_malloc(mask_len);

  3312             if (mask == NULL) {

  3313                 return;

  3314             }

  3315             SDL_memset(mask, ~0, mask_len);

  3316             if (icon->flags & SDL_SRCCOLORKEY)

  3317                 flags |= 1;

  3318             if (icon->flags & SDL_SRCALPHA)

  3319                 flags |= 2;

  3320             if (flags) {

  3321                 CreateMaskFromColorKeyOrAlpha(icon, mask, flags);

  3322             }

  3323             _this->SetIcon(_this, icon, mask);

  3324             SDL_free(mask);

  3325         } else {

  3326             _this->SetIcon(_this, icon, mask);

  3327         }

  3328     }

  3329 }

  3330 #endif

  3332 SDL_bool

  3333 SDL_GetWindowWMInfo(SDL_WindowID windowID, struct SDL_SysWMinfo *info)

  3334 {

  3335     SDL_Window *window = SDL_GetWindowFromID(windowID);

  3337     if (!window || !_this->GetWindowWMInfo) {

  3338         return SDL_FALSE;

  3339     }

  3340     return (_this->GetWindowWMInfo(_this, window, info));

  3341 }

  3343 void

  3344 SDL_StartTextInput(void)

  3345 {

  3346     if (_this->StartTextInput) {

  3347         _this->StartTextInput(_this);

  3348     }

  3349     SDL_EventState(SDL_TEXTINPUT, SDL_ENABLE);

  3350     SDL_EventState(SDL_TEXTEDITING, SDL_ENABLE);

  3351 }

  3353 void

  3354 SDL_StopTextInput(void)

  3355 {

  3356     if (_this->StopTextInput) {

  3357         _this->StopTextInput(_this);

  3358     }

  3359     SDL_EventState(SDL_TEXTINPUT, SDL_DISABLE);

  3360     SDL_EventState(SDL_TEXTEDITING, SDL_DISABLE);

  3361 }

  3363 void

  3364 SDL_SetTextInputRect(SDL_Rect *rect)

  3365 {

  3366     if (_this->SetTextInputRect) {

  3367         _this->SetTextInputRect(_this, rect);

  3368     }

  3369 }

  3371 /* vi: set ts=4 sw=4 expandtab: */

author	Mike Gorchak <lestat@i.com.ua>
	Tue, 24 Nov 2009 19:28:27 +0000
changeset 3489	e1bd98b56e94
parent 3488	3d2f42580488
child 3500	4b594623401b
permissions	-rw-r--r--