include/SDL_video.h
author Sam Lantinga <slouken@libsdl.org>
Sat, 20 Dec 2008 12:00:00 +0000
changeset 2884 9dde605c7540
parent 2859 99210400e8b9
child 2886 633ce79b7a5b
permissions -rw-r--r--
Date: Fri, 19 Dec 2008 20:17:35 +0100
From: Couriersud
Subject: Re: Aw: Experience using SDL1.3 in sdlmame/Proposal for api additions

> For consistency you'd probably want:
> SDL_SetRenderDrawColor(Uint8 r, Uint8 g, Uint8 b, Uint8 a);
> SDL_SetRenderDrawBlendMode(SDL_BlendMode blendMode);
> SDL_RenderLine(int x1, int y1, int x2, int y2);
> SDL_RenderFill(SDL_Rect *rect);
>
> You probably also want to add API functions query the current state.
>

I have implemented the above api for the opengl, x11, directfb and
software renderers. I have also renamed *TEXTUREBLENDMODE* constants to
BLENDMODE*. The unix build compiles. The windows renderer still needs to
be updated, but I have no windows development machine at hand. Have a
look at the x11 renderer for a sample.

Vector games now run at 90% both on opengl and directfb in comparison to
sdlmame's own opengl renderer. The same applies to raster games.

The diff also includes

a) Changed XDrawRect to XFillRect in x11 renderer
b) A number of changes to fix blending and modulation issues in the
directfb renderer.
     1 /*
     2     SDL - Simple DirectMedia Layer
     3     Copyright (C) 1997-2009 Sam Lantinga
     4 
     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.
     9 
    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.
    14 
    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
    18 
    19     Sam Lantinga
    20     slouken@libsdl.org
    21 */
    22 
    23 /**
    24  * \file SDL_video.h
    25  *
    26  * Header file for SDL video functions.
    27  */
    28 
    29 #ifndef _SDL_video_h
    30 #define _SDL_video_h
    31 
    32 #include "SDL_stdinc.h"
    33 #include "SDL_pixels.h"
    34 #include "SDL_rect.h"
    35 #include "SDL_surface.h"
    36 
    37 #include "begin_code.h"
    38 /* Set up for C function definitions, even when using C++ */
    39 #ifdef __cplusplus
    40 /* *INDENT-OFF* */
    41 extern "C" {
    42 /* *INDENT-ON* */
    43 #endif
    44 
    45 /**
    46  * \struct SDL_DisplayMode
    47  *
    48  * \brief  The structure that defines a display mode
    49  *
    50  * \sa SDL_GetNumDisplayModes()
    51  * \sa SDL_GetDisplayMode()
    52  * \sa SDL_GetDesktopDisplayMode()
    53  * \sa SDL_GetCurrentDisplayMode()
    54  * \sa SDL_GetClosestDisplayMode()
    55  * \sa SDL_SetDisplayMode()
    56  */
    57 typedef struct
    58 {
    59     Uint32 format;              /**< pixel format */
    60     int w;                      /**< width */
    61     int h;                      /**< height */
    62     int refresh_rate;           /**< refresh rate (or zero for unspecified) */
    63     void *driverdata;           /**< driver-specific data, initialize to 0 */
    64 } SDL_DisplayMode;
    65 
    66 /**
    67  * \typedef SDL_WindowID
    68  *
    69  * \brief The type used to identify a window
    70  *
    71  * \sa SDL_CreateWindow()
    72  * \sa SDL_CreateWindowFrom()
    73  * \sa SDL_DestroyWindow()
    74  * \sa SDL_GetWindowData()
    75  * \sa SDL_GetWindowFlags()
    76  * \sa SDL_GetWindowGrab()
    77  * \sa SDL_GetWindowPosition()
    78  * \sa SDL_GetWindowSize()
    79  * \sa SDL_GetWindowTitle()
    80  * \sa SDL_HideWindow()
    81  * \sa SDL_MaximizeWindow()
    82  * \sa SDL_MinimizeWindow()
    83  * \sa SDL_RaiseWindow()
    84  * \sa SDL_RestoreWindow()
    85  * \sa SDL_SetWindowData()
    86  * \sa SDL_SetWindowFullscreen()
    87  * \sa SDL_SetWindowGrab()
    88  * \sa SDL_SetWindowIcon()
    89  * \sa SDL_SetWindowPosition()
    90  * \sa SDL_SetWindowSize()
    91  * \sa SDL_SetWindowTitle()
    92  * \sa SDL_ShowWindow()
    93  */
    94 typedef Uint32 SDL_WindowID;
    95 
    96 /**
    97  * \enum SDL_WindowFlags
    98  *
    99  * \brief The flags on a window
   100  *
   101  * \sa SDL_GetWindowFlags()
   102  */
   103 typedef enum
   104 {
   105     SDL_WINDOW_FULLSCREEN = 0x00000001,         /**< fullscreen window, implies borderless */
   106     SDL_WINDOW_OPENGL = 0x00000002,             /**< window usable with OpenGL context */
   107     SDL_WINDOW_SHOWN = 0x00000004,              /**< window is visible */
   108     SDL_WINDOW_BORDERLESS = 0x00000008,         /**< no window decoration */
   109     SDL_WINDOW_RESIZABLE = 0x00000010,          /**< window can be resized */
   110     SDL_WINDOW_MINIMIZED = 0x00000020,          /**< minimized */
   111     SDL_WINDOW_MAXIMIZED = 0x00000040,          /**< maximized */
   112     SDL_WINDOW_INPUT_GRABBED = 0x00000100,      /**< window has grabbed input focus */
   113     SDL_WINDOW_INPUT_FOCUS = 0x00000200,        /**< window has input focus */
   114     SDL_WINDOW_MOUSE_FOCUS = 0x00000400         /**< window has mouse focus */
   115 } SDL_WindowFlags;
   116 
   117 /**
   118  * \def SDL_WINDOWPOS_UNDEFINED
   119  * \brief Used to indicate that you don't care what the window position is.
   120  */
   121 #define SDL_WINDOWPOS_UNDEFINED 0x7FFFFFF
   122 /**
   123  * \def SDL_WINDOWPOS_CENTERED
   124  * \brief Used to indicate that the window position should be centered.
   125  */
   126 #define SDL_WINDOWPOS_CENTERED  0x7FFFFFE
   127 
   128 /**
   129  * \enum SDL_WindowEventID
   130  *
   131  * \brief Event subtype for window events
   132  */
   133 typedef enum
   134 {
   135     SDL_WINDOWEVENT_NONE,               /**< Never used */
   136     SDL_WINDOWEVENT_SHOWN,              /**< Window has been shown */
   137     SDL_WINDOWEVENT_HIDDEN,             /**< Window has been hidden */
   138     SDL_WINDOWEVENT_EXPOSED,            /**< Window has been exposed and should be redrawn */
   139     SDL_WINDOWEVENT_MOVED,              /**< Window has been moved to data1,data2 */
   140     SDL_WINDOWEVENT_RESIZED,            /**< Window size changed to data1xdata2 */
   141     SDL_WINDOWEVENT_MINIMIZED,          /**< Window has been minimized */
   142     SDL_WINDOWEVENT_MAXIMIZED,          /**< Window has been maximized */
   143     SDL_WINDOWEVENT_RESTORED,           /**< Window has been restored to normal size and position */
   144     SDL_WINDOWEVENT_ENTER,              /**< The window has gained mouse focus */
   145     SDL_WINDOWEVENT_LEAVE,              /**< The window has lost mouse focus */
   146     SDL_WINDOWEVENT_FOCUS_GAINED,       /**< The window has gained keyboard focus */
   147     SDL_WINDOWEVENT_FOCUS_LOST,         /**< The window has lost keyboard focus */
   148     SDL_WINDOWEVENT_CLOSE               /**< The window manager requests that the window be closed */
   149 } SDL_WindowEventID;
   150 
   151 /**
   152  * \enum SDL_RendererFlags
   153  *
   154  * \brief Flags used when creating a rendering context
   155  */
   156 typedef enum
   157 {
   158     SDL_RENDERER_SINGLEBUFFER = 0x00000001,     /**< Render directly to the window, if possible */
   159     SDL_RENDERER_PRESENTCOPY = 0x00000002,      /**< Present uses a copy from back buffer to the front buffer */
   160     SDL_RENDERER_PRESENTFLIP2 = 0x00000004,     /**< Present uses a flip, swapping back buffer and front buffer */
   161     SDL_RENDERER_PRESENTFLIP3 = 0x00000008,     /**< Present uses a flip, rotating between two back buffers and a front buffer */
   162     SDL_RENDERER_PRESENTDISCARD = 0x00000010,   /**< Present leaves the contents of the backbuffer undefined */
   163     SDL_RENDERER_PRESENTVSYNC = 0x00000020,     /**< Present is synchronized with the refresh rate */
   164     SDL_RENDERER_ACCELERATED = 0x00000040       /**< The renderer uses hardware acceleration */
   165 } SDL_RendererFlags;
   166 
   167 /**
   168  * \struct SDL_RendererInfo
   169  *
   170  * \brief Information on the capabilities of a render driver or context
   171  */
   172 typedef struct SDL_RendererInfo
   173 {
   174     const char *name;           /**< The name of the renderer */
   175     Uint32 flags;               /**< Supported SDL_RendererFlags */
   176     Uint32 mod_modes;           /**< A mask of supported channel modulation */
   177     Uint32 blend_modes;         /**< A mask of supported blend modes */
   178     Uint32 scale_modes;         /**< A mask of supported scale modes */
   179     Uint32 num_texture_formats; /**< The number of available texture formats */
   180     Uint32 texture_formats[20]; /**< The available texture formats */
   181     int max_texture_width;      /**< The maximimum texture width */
   182     int max_texture_height;     /**< The maximimum texture height */
   183 } SDL_RendererInfo;
   184 
   185 /**
   186  * \enum SDL_TextureAccess
   187  *
   188  * \brief The access pattern allowed for a texture
   189  */
   190 typedef enum
   191 {
   192     SDL_TEXTUREACCESS_STATIC,    /**< Changes rarely, not lockable */
   193     SDL_TEXTUREACCESS_STREAMING  /**< Changes frequently, lockable */
   194 } SDL_TextureAccess;
   195 
   196 /**
   197  * \enum SDL_TextureModulate
   198  *
   199  * \brief The texture channel modulation used in SDL_RenderCopy()
   200  */
   201 typedef enum
   202 {
   203     SDL_TEXTUREMODULATE_NONE = 0x00000000,     /**< No modulation */
   204     SDL_TEXTUREMODULATE_COLOR = 0x00000001,    /**< srcC = srcC * color */
   205     SDL_TEXTUREMODULATE_ALPHA = 0x00000002     /**< srcA = srcA * alpha */
   206 } SDL_TextureModulate;
   207 
   208 /**
   209  * \enum SDL_BlendMode
   210  *
   211  * \brief The blend mode used in SDL_RenderCopy() and drawing operations
   212  */
   213 typedef enum
   214 {
   215     SDL_BLENDMODE_NONE = 0x00000000,     /**< No blending */
   216     SDL_BLENDMODE_MASK = 0x00000001,     /**< dst = A ? src : dst (alpha is mask) */
   217     SDL_BLENDMODE_BLEND = 0x00000002,    /**< dst = (src * A) + (dst * (1-A)) */
   218     SDL_BLENDMODE_ADD = 0x00000004,      /**< dst = (src * A) + dst */
   219     SDL_BLENDMODE_MOD = 0x00000008       /**< dst = src * dst */
   220 } SDL_BlendMode;
   221 
   222 /**
   223  * \enum SDL_TextureScaleMode
   224  *
   225  * \brief The texture scale mode used in SDL_RenderCopy()
   226  */
   227 typedef enum
   228 {
   229     SDL_TEXTURESCALEMODE_NONE = 0x00000000,     /**< No scaling, rectangles must match dimensions */
   230     SDL_TEXTURESCALEMODE_FAST = 0x00000001,     /**< Point sampling or equivalent algorithm */
   231     SDL_TEXTURESCALEMODE_SLOW = 0x00000002,     /**< Linear filtering or equivalent algorithm */
   232     SDL_TEXTURESCALEMODE_BEST = 0x00000004      /**< Bicubic filtering or equivalent algorithm */
   233 } SDL_TextureScaleMode;
   234 
   235 /**
   236  * \typedef SDL_TextureID
   237  *
   238  * \brief An efficient driver-specific representation of pixel data
   239  */
   240 typedef Uint32 SDL_TextureID;
   241 
   242 /**
   243  * \typedef SDL_GLContext
   244  *
   245  * \brief An opaque handle to an OpenGL context.
   246  */
   247 typedef void *SDL_GLContext;
   248 
   249 /**
   250  * \enum SDL_GLattr
   251  *
   252  * \brief OpenGL configuration attributes
   253  */
   254 typedef enum
   255 {
   256     SDL_GL_RED_SIZE,
   257     SDL_GL_GREEN_SIZE,
   258     SDL_GL_BLUE_SIZE,
   259     SDL_GL_ALPHA_SIZE,
   260     SDL_GL_BUFFER_SIZE,
   261     SDL_GL_DOUBLEBUFFER,
   262     SDL_GL_DEPTH_SIZE,
   263     SDL_GL_STENCIL_SIZE,
   264     SDL_GL_ACCUM_RED_SIZE,
   265     SDL_GL_ACCUM_GREEN_SIZE,
   266     SDL_GL_ACCUM_BLUE_SIZE,
   267     SDL_GL_ACCUM_ALPHA_SIZE,
   268     SDL_GL_STEREO,
   269     SDL_GL_MULTISAMPLEBUFFERS,
   270     SDL_GL_MULTISAMPLESAMPLES,
   271     SDL_GL_ACCELERATED_VISUAL,
   272     SDL_GL_RETAINED_BACKING
   273 } SDL_GLattr;
   274 
   275 
   276 /* Function prototypes */
   277 
   278 /**
   279  * \fn int SDL_GetNumVideoDrivers(void)
   280  *
   281  * \brief Get the number of video drivers compiled into SDL
   282  *
   283  * \sa SDL_GetVideoDriver()
   284  */
   285 extern DECLSPEC int SDLCALL SDL_GetNumVideoDrivers(void);
   286 
   287 /**
   288  * \fn const char *SDL_GetVideoDriver(int index)
   289  *
   290  * \brief Get the name of a built in video driver.
   291  *
   292  * \note The video drivers are presented in the order in which they are
   293  * normally checked during initialization.
   294  *
   295  * \sa SDL_GetNumVideoDrivers()
   296  */
   297 extern DECLSPEC const char *SDLCALL SDL_GetVideoDriver(int index);
   298 
   299 /**
   300  * \fn int SDL_VideoInit(const char *driver_name, Uint32 flags)
   301  *
   302  * \brief Initialize the video subsystem, optionally specifying a video driver.
   303  *
   304  * \param driver_name Initialize a specific driver by name, or NULL for the default video driver.
   305  * \param flags FIXME: Still needed?
   306  *
   307  * \return 0 on success, -1 on error
   308  *
   309  * This function initializes the video subsystem; setting up a connection
   310  * to the window manager, etc, and determines the available display modes
   311  * and pixel formats, but does not initialize a window or graphics mode.
   312  *
   313  * \sa SDL_VideoQuit()
   314  */
   315 extern DECLSPEC int SDLCALL SDL_VideoInit(const char *driver_name,
   316                                           Uint32 flags);
   317 
   318 /**
   319  * \fn void SDL_VideoQuit(void)
   320  *
   321  * \brief Shuts down the video subsystem.
   322  *
   323  * This function closes all windows, and restores the original video mode.
   324  *
   325  * \sa SDL_VideoInit()
   326  */
   327 extern DECLSPEC void SDLCALL SDL_VideoQuit(void);
   328 
   329 /**
   330  * \fn const char *SDL_GetCurrentVideoDriver(void)
   331  *
   332  * \brief Returns the name of the currently initialized video driver.
   333  *
   334  * \return The name of the current video driver or NULL if no driver
   335  *         has been initialized
   336  *
   337  * \sa SDL_GetNumVideoDrivers()
   338  * \sa SDL_GetVideoDriver()
   339  */
   340 extern DECLSPEC const char *SDLCALL SDL_GetCurrentVideoDriver(void);
   341 
   342 /**
   343  * \fn int SDL_GetNumVideoDisplays(void)
   344  *
   345  * \brief Returns the number of available video displays.
   346  *
   347  * \sa SDL_SelectVideoDisplay()
   348  */
   349 extern DECLSPEC int SDLCALL SDL_GetNumVideoDisplays(void);
   350 
   351 /**
   352  * \fn int SDL_SelectVideoDisplay(int index)
   353  *
   354  * \brief Set the index of the currently selected display.
   355  *
   356  * \return 0 on success, or -1 if the index is out of range.
   357  *
   358  * \sa SDL_GetNumVideoDisplays()
   359  * \sa SDL_GetCurrentVideoDisplay()
   360  */
   361 extern DECLSPEC int SDLCALL SDL_SelectVideoDisplay(int index);
   362 
   363 /**
   364  * \fn int SDL_GetCurrentVideoDisplay(void)
   365  *
   366  * \brief Get the index of the currently selected display.
   367  *
   368  * \return The index of the currently selected display.
   369  *
   370  * \sa SDL_GetNumVideoDisplays()
   371  * \sa SDL_SelectVideoDisplay()
   372  */
   373 extern DECLSPEC int SDLCALL SDL_GetCurrentVideoDisplay(void);
   374 
   375 /**
   376  * \fn int SDL_GetNumDisplayModes(void)
   377  *
   378  * \brief Returns the number of available display modes for the current display.
   379  *
   380  * \sa SDL_GetDisplayMode()
   381  */
   382 extern DECLSPEC int SDLCALL SDL_GetNumDisplayModes(void);
   383 
   384 /**
   385  * \fn int SDL_GetDisplayMode(int index, SDL_DisplayMode *mode)
   386  *
   387  * \brief Fill in information about a specific display mode.
   388  *
   389  * \note The display modes are sorted in this priority:
   390  *       \li bits per pixel -> more colors to fewer colors
   391  *       \li width -> largest to smallest
   392  *       \li height -> largest to smallest
   393  *       \li refresh rate -> highest to lowest
   394  *
   395  * \sa SDL_GetNumDisplayModes()
   396  */
   397 extern DECLSPEC int SDLCALL SDL_GetDisplayMode(int index,
   398                                                SDL_DisplayMode * mode);
   399 
   400 /**
   401  * \fn int SDL_GetDesktopDisplayMode(SDL_DisplayMode *mode)
   402  *
   403  * \brief Fill in information about the desktop display mode for the current display.
   404  */
   405 extern DECLSPEC int SDLCALL SDL_GetDesktopDisplayMode(SDL_DisplayMode * mode);
   406 
   407 /**
   408  * \fn int SDL_GetCurrentDisplayMode(SDL_DisplayMode *mode)
   409  *
   410  * \brief Fill in information about the current display mode.
   411  */
   412 extern DECLSPEC int SDLCALL SDL_GetCurrentDisplayMode(SDL_DisplayMode * mode);
   413 
   414 /**
   415  * \fn SDL_DisplayMode *SDL_GetClosestDisplayMode(const SDL_DisplayMode *mode, SDL_DisplayMode *closest)
   416  *
   417  * \brief Get the closest match to the requested display mode.
   418  *
   419  * \param mode The desired display mode
   420  * \param closest A pointer to a display mode to be filled in with the closest match of the available display modes.
   421  *
   422  * \return The passed in value 'closest', or NULL if no matching video mode was available.
   423  *
   424  * The available display modes are scanned, and 'closest' is filled in with the closest mode matching the requested mode and returned.  The mode format and refresh_rate default to the desktop mode if they are 0.  The modes are scanned with size being first priority, format being second priority, and finally checking the refresh_rate.  If all the available modes are too small, then NULL is returned.
   425  *
   426  * \sa SDL_GetNumDisplayModes()
   427  * \sa SDL_GetDisplayMode()
   428  */
   429 extern DECLSPEC SDL_DisplayMode *SDLCALL SDL_GetClosestDisplayMode(const
   430                                                                    SDL_DisplayMode
   431                                                                    * mode,
   432                                                                    SDL_DisplayMode
   433                                                                    * closest);
   434 
   435 /**
   436  * \fn int SDL_SetFullscreenDisplayMode(const SDL_DisplayMode *mode)
   437  *
   438  * \brief Set the display mode used when a fullscreen window is visible
   439  *        on the currently selected display.
   440  *
   441  * \param mode The mode to use, or NULL for the desktop mode.
   442  *
   443  * \return 0 on success, or -1 if setting the display mode failed.
   444  *
   445  * \sa SDL_SetWindowFullscreen()
   446  */
   447 extern DECLSPEC int SDLCALL SDL_SetFullscreenDisplayMode(const SDL_DisplayMode
   448                                                          * mode);
   449 
   450 /**
   451  * \fn int SDL_GetFullscreenDisplayMode(SDL_DisplayMode *mode)
   452  *
   453  * \brief Fill in information about the display mode used when a fullscreen
   454  *        window is visible on the currently selected display.
   455  */
   456 extern DECLSPEC int SDLCALL SDL_GetFullscreenDisplayMode(SDL_DisplayMode *
   457                                                          mode);
   458 
   459 /**
   460  * \fn int SDL_SetDisplayPalette(const SDL_Color *colors, int firstcolor, int ncolors)
   461  *
   462  * \brief Set the palette entries for indexed display modes.
   463  *
   464  * \return 0 on success, or -1 if the display mode isn't palettized or the colors couldn't be set.
   465  */
   466 extern DECLSPEC int SDLCALL SDL_SetDisplayPalette(const SDL_Color * colors,
   467                                                   int firstcolor,
   468                                                   int ncolors);
   469 
   470 /**
   471  * \fn int SDL_GetDisplayPalette(SDL_Color *colors, int firstcolor, int ncolors)
   472  *
   473  * \brief Gets the palette entries for indexed display modes.
   474  *
   475  * \return 0 on success, or -1 if the display mode isn't palettized
   476  */
   477 extern DECLSPEC int SDLCALL SDL_GetDisplayPalette(SDL_Color * colors,
   478                                                   int firstcolor,
   479                                                   int ncolors);
   480 
   481 /**
   482  * \fn int SDL_SetGamma(float red, float green, float blue)
   483  *
   484  * \brief Set the gamma correction for each of the color channels on the currently selected display.
   485  *
   486  * \return 0 on success, or -1 if setting the gamma isn't supported.
   487  *
   488  * \sa SDL_SetGammaRamp()
   489  */
   490 extern DECLSPEC int SDLCALL SDL_SetGamma(float red, float green, float blue);
   491 
   492 /**
   493  * \fn int SDL_SetGammaRamp(const Uint16 * red, const Uint16 * green, const Uint16 * blue)
   494  *
   495  * \brief Set the gamma ramp for the currently selected display.
   496  *
   497  * \param red The translation table for the red channel, or NULL
   498  * \param green The translation table for the green channel, or NULL
   499  * \param blue The translation table for the blue channel, or NULL
   500  *
   501  * \return 0 on success, or -1 if gamma ramps are unsupported.
   502  *
   503  * Set the gamma translation table for the red, green, and blue channels
   504  * of the video hardware.  Each table is an array of 256 16-bit quantities,
   505  * representing a mapping between the input and output for that channel.
   506  * The input is the index into the array, and the output is the 16-bit
   507  * gamma value at that index, scaled to the output color precision.
   508  * 
   509  * \sa SDL_GetGammaRamp()
   510  */
   511 extern DECLSPEC int SDLCALL SDL_SetGammaRamp(const Uint16 * red,
   512                                              const Uint16 * green,
   513                                              const Uint16 * blue);
   514 
   515 /**
   516  * \fn int SDL_GetGammaRamp(Uint16 * red, Uint16 * green, Uint16 * blue)
   517  *
   518  * \brief Get the gamma ramp for the currently selected display.
   519  *
   520  * \param red A pointer to a 256 element array of 16-bit quantities to hold the translation table for the red channel, or NULL.
   521  * \param green A pointer to a 256 element array of 16-bit quantities to hold the translation table for the green channel, or NULL.
   522  * \param blue A pointer to a 256 element array of 16-bit quantities to hold the translation table for the blue channel, or NULL.
   523  * 
   524  * \return 0 on success, or -1 if gamma ramps are unsupported.
   525  *
   526  * \sa SDL_SetGammaRamp()
   527  */
   528 extern DECLSPEC int SDLCALL SDL_GetGammaRamp(Uint16 * red, Uint16 * green,
   529                                              Uint16 * blue);
   530 
   531 
   532 /**
   533  * \fn SDL_WindowID SDL_CreateWindow(const char *title, int x, int y, int w, int h, Uint32 flags)
   534  *
   535  * \brief Create a window with the specified position, dimensions, and flags.
   536  *
   537  * \param title The title of the window, in UTF-8 encoding
   538  * \param x The x position of the window, SDL_WINDOWPOS_CENTERED, or SDL_WINDOWPOS_UNDEFINED
   539  * \param y The y position of the window, SDL_WINDOWPOS_CENTERED, or SDL_WINDOWPOS_UNDEFINED
   540  * \param w The width of the window
   541  * \param h The height of the window
   542  * \param flags The flags for the window, a mask of any of the following: SDL_WINDOW_FULLSCREEN, SDL_WINDOW_OPENGL, SDL_WINDOW_SHOWN, SDL_WINDOW_BORDERLESS, SDL_WINDOW_RESIZABLE, SDL_WINDOW_MAXIMIZED, SDL_WINDOW_MINIMIZED, SDL_WINDOW_INPUT_GRABBED
   543  *
   544  * \return The id of the window created, or zero if window creation failed.
   545  *
   546  * \sa SDL_DestroyWindow()
   547  */
   548 extern DECLSPEC SDL_WindowID SDLCALL SDL_CreateWindow(const char *title,
   549                                                       int x, int y, int w,
   550                                                       int h, Uint32 flags);
   551 
   552 /**
   553  * \fn SDL_WindowID SDL_CreateWindowFrom(void *data)
   554  *
   555  * \brief Create an SDL window struct from an existing native window.
   556  *
   557  * \param data A pointer to driver-dependent window creation data
   558  *
   559  * \return The id of the window created, or zero if window creation failed.
   560  *
   561  * \warning This function is NOT SUPPORTED, use at your own risk!
   562  *
   563  * \sa SDL_DestroyWindow()
   564  */
   565 extern DECLSPEC SDL_WindowID SDLCALL SDL_CreateWindowFrom(const void *data);
   566 
   567 /**
   568  * \fn Uint32 SDL_GetWindowFlags(SDL_WindowID windowID)
   569  *
   570  * \brief Get the window flags.
   571  */
   572 extern DECLSPEC Uint32 SDLCALL SDL_GetWindowFlags(SDL_WindowID windowID);
   573 
   574 /**
   575  * \fn void SDL_SetWindowTitle(SDL_WindowID windowID, const char *title)
   576  *
   577  * \brief Set the title of the window, in UTF-8 format.
   578  *
   579  * \sa SDL_GetWindowTitle()
   580  */
   581 extern DECLSPEC void SDLCALL SDL_SetWindowTitle(SDL_WindowID windowID,
   582                                                 const char *title);
   583 
   584 /**
   585  * \fn const char *SDL_GetWindowTitle(SDL_WindowID windowID)
   586  *
   587  * \brief Get the title of the window, in UTF-8 format.
   588  *
   589  * \sa SDL_SetWindowTitle()
   590  */
   591 extern DECLSPEC const char *SDLCALL SDL_GetWindowTitle(SDL_WindowID windowID);
   592 
   593 /**
   594  * \fn void SDL_SetWindowIcon(SDL_Surface *icon)
   595  *
   596  * \brief Set the icon of the window.
   597  *
   598  * \param icon The icon for the window
   599  *
   600  * FIXME: The icon needs to be set before the window is first shown.  Should some icon representation be part of the window creation data?
   601  */
   602 extern DECLSPEC void SDLCALL SDL_SetWindowIcon(SDL_Surface * icon);
   603 
   604 /**
   605  * \fn void SDL_SetWindowData(SDL_WindowID windowID, void *userdata)
   606  *
   607  * \brief Associate an arbitrary pointer with the window.
   608  *
   609  * \sa SDL_GetWindowData()
   610  */
   611 extern DECLSPEC void SDLCALL SDL_SetWindowData(SDL_WindowID windowID,
   612                                                void *userdata);
   613 
   614 /**
   615  * \fn void *SDL_GetWindowData(SDL_WindowID windowID)
   616  *
   617  * \brief Retrieve the data pointer associated with the window.
   618  *
   619  * \sa SDL_SetWindowData()
   620  */
   621 extern DECLSPEC void *SDLCALL SDL_GetWindowData(SDL_WindowID windowID);
   622 
   623 /**
   624  * \fn void SDL_SetWindowPosition(SDL_WindowID windowID, int x, int y)
   625  *
   626  * \brief Set the position of the window.
   627  *
   628  * \param windowID The window to reposition
   629  * \param x The x coordinate of the window, SDL_WINDOWPOS_CENTERED, or SDL_WINDOWPOS_UNDEFINED
   630  * \param y The y coordinate of the window, SDL_WINDOWPOS_CENTERED, or SDL_WINDOWPOS_UNDEFINED
   631  *
   632  * \note The window coordinate origin is the upper left of the display.
   633  *
   634  * \sa SDL_GetWindowPosition()
   635  */
   636 extern DECLSPEC void SDLCALL SDL_SetWindowPosition(SDL_WindowID windowID,
   637                                                    int x, int y);
   638 
   639 /**
   640  * \fn void SDL_GetWindowPosition(SDL_WindowID windowID, int *x, int *y)
   641  *
   642  * \brief Get the position of the window.
   643  *
   644  * \sa SDL_SetWindowPosition()
   645  */
   646 extern DECLSPEC void SDLCALL SDL_GetWindowPosition(SDL_WindowID windowID,
   647                                                    int *x, int *y);
   648 
   649 /**
   650  * \fn void SDL_SetWindowSize(SDL_WindowID windowID, int w, int w)
   651  *
   652  * \brief Set the size of the window's client area.
   653  *
   654  * \note You can't change the size of a fullscreen window, it automatically
   655  * matches the size of the display mode.
   656  *
   657  * \sa SDL_GetWindowSize()
   658  */
   659 extern DECLSPEC void SDLCALL SDL_SetWindowSize(SDL_WindowID windowID, int w,
   660                                                int h);
   661 
   662 /**
   663  * \fn void SDL_GetWindowSize(SDL_WindowID windowID, int *w, int *w)
   664  *
   665  * \brief Get the size of the window's client area.
   666  *
   667  * \sa SDL_SetWindowSize()
   668  */
   669 extern DECLSPEC void SDLCALL SDL_GetWindowSize(SDL_WindowID windowID, int *w,
   670                                                int *h);
   671 
   672 /**
   673  * \fn void SDL_ShowWindow(SDL_WindowID windowID)
   674  *
   675  * \brief Show the window
   676  *
   677  * \sa SDL_HideWindow()
   678  */
   679 extern DECLSPEC void SDLCALL SDL_ShowWindow(SDL_WindowID windowID);
   680 
   681 /**
   682  * \fn void SDL_HideWindow(SDL_WindowID windowID)
   683  *
   684  * \brief Hide the window
   685  *
   686  * \sa SDL_ShowWindow()
   687  */
   688 extern DECLSPEC void SDLCALL SDL_HideWindow(SDL_WindowID windowID);
   689 
   690 /**
   691  * \fn void SDL_RaiseWindow(SDL_WindowID windowID)
   692  *
   693  * \brief Raise the window above other windows and set the input focus.
   694  */
   695 extern DECLSPEC void SDLCALL SDL_RaiseWindow(SDL_WindowID windowID);
   696 
   697 /**
   698  * \fn void SDL_MaximizeWindow(SDL_WindowID windowID)
   699  *
   700  * \brief Make the window as large as possible.
   701  *
   702  * \sa SDL_RestoreWindow()
   703  */
   704 extern DECLSPEC void SDLCALL SDL_MaximizeWindow(SDL_WindowID windowID);
   705 
   706 /**
   707  * \fn void SDL_MinimizeWindow(SDL_WindowID windowID)
   708  *
   709  * \brief Minimize the window to an iconic representation.
   710  *
   711  * \sa SDL_RestoreWindow()
   712  */
   713 extern DECLSPEC void SDLCALL SDL_MinimizeWindow(SDL_WindowID windowID);
   714 
   715 /**
   716  * \fn void SDL_RestoreWindow(SDL_WindowID windowID)
   717  *
   718  * \brief Restore the size and position of a minimized or maximized window.
   719  *
   720  * \sa SDL_MaximizeWindow()
   721  * \sa SDL_MinimizeWindow()
   722  */
   723 extern DECLSPEC void SDLCALL SDL_RestoreWindow(SDL_WindowID windowID);
   724 
   725 /**
   726  * \fn int SDL_SetWindowFullscreen(SDL_WindowID windowID, int fullscreen)
   727  *
   728  * \brief Set the window's fullscreen state.
   729  *
   730  * \return 0 on success, or -1 if setting the display mode failed.
   731  *
   732  * \sa SDL_SetFullscreenDisplayMode()
   733  */
   734 extern DECLSPEC int SDLCALL SDL_SetWindowFullscreen(SDL_WindowID windowID,
   735                                                     int fullscreen);
   736 
   737 /**
   738  * \fn void SDL_SetWindowGrab(SDL_WindowID windowID, int mode)
   739  *
   740  * \brief Set the window's input grab mode.
   741  *
   742  * \param mode This is 1 to grab input, and 0 to release input.
   743  *
   744  * \sa SDL_GetWindowGrab()
   745  */
   746 extern DECLSPEC void SDLCALL SDL_SetWindowGrab(SDL_WindowID windowID,
   747                                                int mode);
   748 
   749 /**
   750  * \fn int SDL_GetWindowGrab(SDL_WindowID windowID)
   751  *
   752  * \brief Get the window's input grab mode.
   753  *
   754  * \return This returns 1 if input is grabbed, and 0 otherwise.
   755  *
   756  * \sa SDL_SetWindowGrab()
   757  */
   758 extern DECLSPEC int SDLCALL SDL_GetWindowGrab(SDL_WindowID windowID);
   759 
   760 /**
   761  * \fn SDL_bool SDL_GetWindowWMInfo(SDL_WindowID windowID, struct SDL_SysWMinfo * info)
   762  *
   763  * \brief Get driver specific information about a window.
   764  *
   765  * \note Include SDL_syswm.h for the declaration of SDL_SysWMinfo.
   766  */
   767 struct SDL_SysWMinfo;
   768 extern DECLSPEC SDL_bool SDLCALL SDL_GetWindowWMInfo(SDL_WindowID windowID,
   769                                                      struct SDL_SysWMinfo
   770                                                      *info);
   771 
   772 /**
   773  * \fn void SDL_DestroyWindow(SDL_WindowID windowID)
   774  *
   775  * \brief Destroy a window.
   776  */
   777 extern DECLSPEC void SDLCALL SDL_DestroyWindow(SDL_WindowID windowID);
   778 
   779 /**
   780  * \fn int SDL_GetNumRenderDrivers(void)
   781  *
   782  * \brief Get the number of 2D rendering drivers available for the current display.
   783  *
   784  * A render driver is a set of code that handles rendering and texture
   785  * management on a particular display.  Normally there is only one, but
   786  * some drivers may have several available with different capabilities.
   787  *
   788  * \sa SDL_GetRenderDriverInfo()
   789  * \sa SDL_CreateRenderer()
   790  */
   791 extern DECLSPEC int SDLCALL SDL_GetNumRenderDrivers(void);
   792 
   793 /**
   794  * \fn int SDL_GetRenderDriverInfo(int index, SDL_RendererInfo *info)
   795  *
   796  * \brief Get information about a specific 2D rendering driver for the current display.
   797  *
   798  * \param index The index of the driver to query information about.
   799  * \param info A pointer to an SDL_RendererInfo struct to be filled with information on the rendering driver.
   800  *
   801  * \return 0 on success, -1 if the index was out of range
   802  *
   803  * \sa SDL_CreateRenderer()
   804  */
   805 extern DECLSPEC int SDLCALL SDL_GetRenderDriverInfo(int index,
   806                                                     SDL_RendererInfo * info);
   807 
   808 /**
   809  * \fn int SDL_CreateRenderer(SDL_WindowID window, int index, Uint32 flags)
   810  *
   811  * \brief Create and make active a 2D rendering context for a window.
   812  *
   813  * \param windowID The window used for rendering
   814  * \param index The index of the rendering driver to initialize, or -1 to initialize the first one supporting the requested flags.
   815  * \param flags SDL_RendererFlags
   816  *
   817  * \return 0 on success, -1 if the flags were not supported, or -2 if
   818  *         there isn't enough memory to support the requested flags
   819  *
   820  * \sa SDL_SelectRenderer()
   821  * \sa SDL_GetRendererInfo()
   822  * \sa SDL_DestroyRenderer()
   823  */
   824 extern DECLSPEC int SDLCALL SDL_CreateRenderer(SDL_WindowID windowID,
   825                                                int index, Uint32 flags);
   826 
   827 /**
   828  * \fn int SDL_SelectRenderer(SDL_WindowID windowID)
   829  *
   830  * \brief Select the rendering context for a particular window.
   831  *
   832  * \return 0 on success, -1 if the selected window doesn't have a
   833  *         rendering context.
   834  */
   835 extern DECLSPEC int SDLCALL SDL_SelectRenderer(SDL_WindowID windowID);
   836 
   837 /**
   838  * \fn int SDL_GetRendererInfo(SDL_RendererInfo *info)
   839  *
   840  * \brief Get information about the current rendering context.
   841  */
   842 extern DECLSPEC int SDLCALL SDL_GetRendererInfo(SDL_RendererInfo * info);
   843 
   844 /**
   845  * \fn SDL_TextureID SDL_CreateTexture(Uint32 format, int access, int w, int h)
   846  *
   847  * \brief Create a texture for the current rendering context.
   848  *
   849  * \param format The format of the texture
   850  * \param access One of the enumerated values in SDL_TextureAccess
   851  * \param w The width of the texture in pixels
   852  * \param h The height of the texture in pixels
   853  *
   854  * \return The created texture is returned, or 0 if no rendering context was active,  the format was unsupported, or the width or height were out of range.
   855  *
   856  * \sa SDL_QueryTexture()
   857  * \sa SDL_DestroyTexture()
   858  */
   859 extern DECLSPEC SDL_TextureID SDLCALL SDL_CreateTexture(Uint32 format,
   860                                                         int access, int w,
   861                                                         int h);
   862 
   863 /**
   864  * \fn SDL_TextureID SDL_CreateTextureFromSurface(Uint32 format, SDL_Surface *surface)
   865  *
   866  * \brief Create a texture from an existing surface.
   867  *
   868  * \param format The format of the texture, or 0 to pick an appropriate format
   869  * \param surface The surface containing pixel data used to fill the texture
   870  *
   871  * \return The created texture is returned, or 0 if no rendering context was active,  the format was unsupported, or the surface width or height were out of range.
   872  *
   873  * \note The surface is not modified or freed by this function.
   874  *
   875  * \sa SDL_QueryTexture()
   876  * \sa SDL_DestroyTexture()
   877  */
   878 extern DECLSPEC SDL_TextureID SDLCALL SDL_CreateTextureFromSurface(Uint32
   879                                                                    format,
   880                                                                    SDL_Surface
   881                                                                    * surface);
   882 
   883 /**
   884  * \fn int SDL_QueryTexture(SDL_TextureID textureID, Uint32 *format, int *access, int *w, int *h)
   885  *
   886  * \brief Query the attributes of a texture
   887  *
   888  * \param texture A texture to be queried
   889  * \param format A pointer filled in with the raw format of the texture.  The actual format may differ, but pixel transfers will use this format.
   890  * \param access A pointer filled in with the actual access to the texture.
   891  * \param w A pointer filled in with the width of the texture in pixels
   892  * \param h A pointer filled in with the height of the texture in pixels
   893  *
   894  * \return 0 on success, or -1 if the texture is not valid
   895  */
   896 extern DECLSPEC int SDLCALL SDL_QueryTexture(SDL_TextureID textureID,
   897                                              Uint32 * format, int *access,
   898                                              int *w, int *h);
   899 
   900 /**
   901  * \fn int SDL_QueryTexturePixels(SDL_TextureID textureID, void **pixels, int pitch)
   902  *
   903  * \brief Query the pixels of a texture, if the texture does not need to be locked for pixel access.
   904  *
   905  * \param texture A texture to be queried, which was created with SDL_TEXTUREACCESS_STREAMING
   906  * \param pixels A pointer filled with a pointer to the pixels for the texture 
   907  * \param pitch A pointer filled in with the pitch of the pixel data
   908  *
   909  * \return 0 on success, or -1 if the texture is not valid, or must be locked for pixel access.
   910  */
   911 extern DECLSPEC int SDLCALL SDL_QueryTexturePixels(SDL_TextureID textureID,
   912                                                    void **pixels, int *pitch);
   913 
   914 /**
   915  * \fn int SDL_SetTexturePalette(SDL_TextureID textureID, const SDL_Color * colors, int firstcolor, int ncolors)
   916  *
   917  * \brief Update an indexed texture with a color palette
   918  *
   919  * \param texture The texture to update
   920  * \param colors The array of RGB color data
   921  * \param firstcolor The first index to update
   922  * \param ncolors The number of palette entries to fill with the color data
   923  *
   924  * \return 0 on success, or -1 if the texture is not valid or not an indexed texture
   925  */
   926 extern DECLSPEC int SDLCALL SDL_SetTexturePalette(SDL_TextureID textureID,
   927                                                   const SDL_Color * colors,
   928                                                   int firstcolor,
   929                                                   int ncolors);
   930 
   931 /**
   932  * \fn int SDL_GetTexturePalette(SDL_TextureID textureID, SDL_Color * colors, int firstcolor, int ncolors)
   933  *
   934  * \brief Update an indexed texture with a color palette
   935  *
   936  * \param texture The texture to update
   937  * \param colors The array to fill with RGB color data
   938  * \param firstcolor The first index to retrieve
   939  * \param ncolors The number of palette entries to retrieve
   940  *
   941  * \return 0 on success, or -1 if the texture is not valid or not an indexed texture
   942  */
   943 extern DECLSPEC int SDLCALL SDL_GetTexturePalette(SDL_TextureID textureID,
   944                                                   SDL_Color * colors,
   945                                                   int firstcolor,
   946                                                   int ncolors);
   947 
   948 /**
   949  * \fn int SDL_SetTextureColorMod(SDL_TextureID textureID, Uint8 r, Uint8 g, Uint8 b)
   950  *
   951  * \brief Set an additional color value used in render copy operations
   952  *
   953  * \param texture The texture to update
   954  * \param r The red source color value multiplied into copy operations
   955  * \param g The green source color value multiplied into copy operations
   956  * \param b The blue source color value multiplied into copy operations
   957  *
   958  * \return 0 on success, or -1 if the texture is not valid or color modulation is not supported
   959  *
   960  * \sa SDL_GetTextureColorMod()
   961  */
   962 extern DECLSPEC int SDLCALL SDL_SetTextureColorMod(SDL_TextureID textureID,
   963                                                    Uint8 r, Uint8 g, Uint8 b);
   964 
   965 
   966 /**
   967  * \fn int SDL_GetTextureColorMod(SDL_TextureID textureID, Uint8 *r, Uint8 *g, Uint8 *b)
   968  *
   969  * \brief Get the additional color value used in render copy operations
   970  *
   971  * \param texture The texture to query
   972  * \param r A pointer filled in with the source red color value
   973  * \param g A pointer filled in with the source green color value
   974  * \param b A pointer filled in with the source blue color value
   975  *
   976  * \return 0 on success, or -1 if the texture is not valid
   977  *
   978  * \sa SDL_SetTextureColorMod()
   979  */
   980 extern DECLSPEC int SDLCALL SDL_GetTextureColorMod(SDL_TextureID textureID,
   981                                                    Uint8 * r, Uint8 * g,
   982                                                    Uint8 * b);
   983 
   984 /**
   985  * \fn int SDL_SetTextureAlphaMod(SDL_TextureID textureID, Uint8 alpha)
   986  *
   987  * \brief Set an additional alpha value used in render copy operations
   988  *
   989  * \param texture The texture to update
   990  * \param alpha The source alpha value multiplied into copy operations.
   991  *
   992  * \return 0 on success, or -1 if the texture is not valid or alpha modulation is not supported
   993  *
   994  * \sa SDL_GetTextureAlphaMod()
   995  */
   996 extern DECLSPEC int SDLCALL SDL_SetTextureAlphaMod(SDL_TextureID textureID,
   997                                                    Uint8 alpha);
   998 
   999 /**
  1000  * \fn int SDL_GetTextureAlphaMod(SDL_TextureID textureID, Uint8 *alpha)
  1001  *
  1002  * \brief Get the additional alpha value used in render copy operations
  1003  *
  1004  * \param texture The texture to query
  1005  * \param alpha A pointer filled in with the source alpha value
  1006  *
  1007  * \return 0 on success, or -1 if the texture is not valid
  1008  *
  1009  * \sa SDL_SetTextureAlphaMod()
  1010  */
  1011 extern DECLSPEC int SDLCALL SDL_GetTextureAlphaMod(SDL_TextureID textureID,
  1012                                                    Uint8 * alpha);
  1013 
  1014 /**
  1015  * \fn int SDL_SetTextureBlendMode(SDL_TextureID textureID, int blendMode)
  1016  *
  1017  * \brief Set the blend mode used for texture copy operations
  1018  *
  1019  * \param texture The texture to update
  1020  * \param blendMode SDL_TextureBlendMode to use for texture blending
  1021  *
  1022  * \return 0 on success, or -1 if the texture is not valid or the blend mode is not supported
  1023  *
  1024  * \note If the blend mode is not supported, the closest supported mode is chosen.
  1025  *
  1026  * \sa SDL_GetTextureBlendMode()
  1027  */
  1028 extern DECLSPEC int SDLCALL SDL_SetTextureBlendMode(SDL_TextureID textureID,
  1029                                                     int blendMode);
  1030 
  1031 /**
  1032  * \fn int SDL_GetTextureBlendMode(SDL_TextureID textureID, int *blendMode)
  1033  *
  1034  * \brief Get the blend mode used for texture copy operations
  1035  *
  1036  * \param texture The texture to query
  1037  * \param blendMode A pointer filled in with the current blend mode
  1038  *
  1039  * \return 0 on success, or -1 if the texture is not valid
  1040  *
  1041  * \sa SDL_SetTextureBlendMode()
  1042  */
  1043 extern DECLSPEC int SDLCALL SDL_GetTextureBlendMode(SDL_TextureID textureID,
  1044                                                     int *blendMode);
  1045 
  1046 /**
  1047  * \fn int SDL_SetTextureScaleMode(SDL_TextureID textureID, int scaleMode)
  1048  *
  1049  * \brief Set the scale mode used for texture copy operations
  1050  *
  1051  * \param texture The texture to update
  1052  * \param scaleMode SDL_TextureScaleMode to use for texture scaling
  1053  *
  1054  * \return 0 on success, or -1 if the texture is not valid or the scale mode is not supported
  1055  *
  1056  * \note If the scale mode is not supported, the closest supported mode is chosen.
  1057  *
  1058  * \sa SDL_GetTextureScaleMode()
  1059  */
  1060 extern DECLSPEC int SDLCALL SDL_SetTextureScaleMode(SDL_TextureID textureID,
  1061                                                     int scaleMode);
  1062 
  1063 /**
  1064  * \fn int SDL_GetTextureScaleMode(SDL_TextureID textureID, int *scaleMode)
  1065  *
  1066  * \brief Get the scale mode used for texture copy operations
  1067  *
  1068  * \param texture The texture to query
  1069  * \param scaleMode A pointer filled in with the current scale mode
  1070  *
  1071  * \return 0 on success, or -1 if the texture is not valid
  1072  *
  1073  * \sa SDL_SetTextureScaleMode()
  1074  */
  1075 extern DECLSPEC int SDLCALL SDL_GetTextureScaleMode(SDL_TextureID textureID,
  1076                                                     int *scaleMode);
  1077 
  1078 /**
  1079  * \fn int SDL_UpdateTexture(SDL_TextureID textureID, const SDL_Rect *rect, const void *pixels, int pitch)
  1080  *
  1081  * \brief Update the given texture rectangle with new pixel data.
  1082  *
  1083  * \param texture The texture to update
  1084  * \param rect A pointer to the rectangle of pixels to update, or NULL to update the entire texture.
  1085  * \param pixels The raw pixel data
  1086  * \param pitch The number of bytes between rows of pixel data
  1087  *
  1088  * \return 0 on success, or -1 if the texture is not valid
  1089  *
  1090  * \note This is a fairly slow function.
  1091  */
  1092 extern DECLSPEC int SDLCALL SDL_UpdateTexture(SDL_TextureID textureID,
  1093                                               const SDL_Rect * rect,
  1094                                               const void *pixels, int pitch);
  1095 
  1096 /**
  1097  * \fn void SDL_LockTexture(SDL_TextureID textureID, const SDL_Rect *rect, int markDirty, void **pixels, int *pitch)
  1098  *
  1099  * \brief Lock a portion of the texture for pixel access.
  1100  *
  1101  * \param textureID The texture to lock for access, which was created with SDL_TEXTUREACCESS_STREAMING.
  1102  * \param rect A pointer to the rectangle to lock for access. If the rect is NULL, the entire texture will be locked.
  1103  * \param markDirty If this is nonzero, the locked area will be marked dirty when the texture is unlocked.
  1104  * \param pixels This is filled in with a pointer to the locked pixels, appropriately offset by the locked area.
  1105  * \param pitch This is filled in with the pitch of the locked pixels.
  1106  *
  1107  * \return 0 on success, or -1 if the texture is not valid or was created with SDL_TEXTUREACCESS_STATIC
  1108  *
  1109  * \sa SDL_DirtyTexture()
  1110  * \sa SDL_UnlockTexture()
  1111  */
  1112 extern DECLSPEC int SDLCALL SDL_LockTexture(SDL_TextureID textureID,
  1113                                             const SDL_Rect * rect,
  1114                                             int markDirty, void **pixels,
  1115                                             int *pitch);
  1116 
  1117 /**
  1118  * \fn void SDL_UnlockTexture(SDL_TextureID textureID)
  1119  *
  1120  * \brief Unlock a texture, uploading the changes to video memory, if needed.
  1121  *
  1122  * \sa SDL_LockTexture()
  1123  * \sa SDL_DirtyTexture()
  1124  */
  1125 extern DECLSPEC void SDLCALL SDL_UnlockTexture(SDL_TextureID textureID);
  1126 
  1127 /**
  1128  * \fn void SDL_DirtyTexture(SDL_TextureID textureID, int numrects, const SDL_Rect * rects)
  1129  *
  1130  * \brief Mark the specified rectangles of the texture as dirty.
  1131  *
  1132  * \param textureID The texture to mark dirty, which was created with SDL_TEXTUREACCESS_STREAMING.
  1133  * \param numrects The number of rectangles pointed to by rects.
  1134  * \param rects The pointer to an array of dirty rectangles.
  1135  *
  1136  * \sa SDL_LockTexture()
  1137  * \sa SDL_UnlockTexture()
  1138  */
  1139 extern DECLSPEC void SDLCALL SDL_DirtyTexture(SDL_TextureID textureID,
  1140                                               int numrects,
  1141                                               const SDL_Rect * rects);
  1142 
  1143 /**
  1144  * \fn void SDL_SetRenderDrawColor(Uint8 r, Uint8 g, Uint8 b, Uint8 a)
  1145  *
  1146  * \brief Set the color used for drawing operations (Fill and Line).
  1147  *
  1148  * \param r The red value used to draw on the rendering target
  1149  * \param g The green value used to draw on the rendering target
  1150  * \param b The blue value used to draw on the rendering target
  1151  * \param a The alpha value used to draw on the rendering target, usually SDL_ALPHA_OPAQUE (255)
  1152  * \return 0 on success, or -1 if there is no rendering context current
  1153  */
  1154 extern DECLSPEC int SDL_SetRenderDrawColor(Uint8 r, Uint8 g, Uint8 b,
  1155                                            Uint8 a);
  1156 
  1157 /**
  1158  * \fn void SDL_GetRenderDrawColor(Uint8 r, Uint8 g, Uint8 b, Uint8 a)
  1159  *
  1160  * \brief Get the color used for drawing operations (Fill and Line).
  1161  *
  1162  * \param r A pointer to the red value used to draw on the rendering target
  1163  * \param g A pointer to the green value used to draw on the rendering target
  1164  * \param b A pointer to the blue value used to draw on the rendering target
  1165  * \param a A pointer to the alpha value used to draw on the rendering target, usually SDL_ALPHA_OPAQUE (255)
  1166  * \return 0 on success, or -1 if there is no rendering context current
  1167  */
  1168 extern DECLSPEC int SDL_GetRenderDrawColor(Uint8 * r, Uint8 * g, Uint8 * b,
  1169                                            Uint8 * a);
  1170 
  1171 /**
  1172  * \fn int SDL_SetRenderDrawBlendMode(int blendMode)
  1173  *
  1174  * \brief Set the blend mode used for drawing operations
  1175  *
  1176  * \param blendMode SDL_BlendMode to use for blending
  1177  *
  1178  * \return 0 on success, or -1 if there is no rendering context current
  1179  *
  1180  * \note If the blend mode is not supported, the closest supported mode is chosen.
  1181  *
  1182  * \sa SDL_SetRenderDrawBlendMode()
  1183  */
  1184 extern DECLSPEC int SDLCALL SDL_SetRenderDrawBlendMode(int blendMode);
  1185 
  1186 /**
  1187  * \fn int SDL_GetRenderDrawBlendMode(int *blendMode)
  1188  *
  1189  * \brief Get the blend mode used for drawing operations
  1190  *
  1191  * \param blendMode A pointer filled in with the current blend mode
  1192  *
  1193  * \return 0 on success, or -1 if there is no rendering context current
  1194  *
  1195  * \sa SDL_SetRenderDrawBlendMode()
  1196  */
  1197 extern DECLSPEC int SDLCALL SDL_GetRenderDrawBlendMode(int *blendMode);
  1198 
  1199 /**
  1200  * \fn void SDL_RenderLine(int x1, int y1, int x2, int y2)
  1201  *
  1202  * \brief Draw a line on the current rendering target.
  1203  *
  1204  * \param x1 The x coordinate of the start point
  1205  * \param y1 The y coordinate of the start point
  1206  * \param x2 The x coordinate of the end point
  1207  * \param y2 The y coordinate of the end point
  1208  *
  1209  * \return 0 on success, or -1 if there is no rendering context current
  1210  */
  1211 
  1212 extern DECLSPEC int SDLCALL SDL_RenderLine(int x1, int y1, int x2, int y2);
  1213 
  1214 /**
  1215  * \fn void SDL_RenderFill(const SDL_Rect *rect)
  1216  *
  1217  * \brief Fill the current rendering target with the drawing color.
  1218  *
  1219  * \param r The red value used to fill the rendering target
  1220  * \param g The green value used to fill the rendering target
  1221  * \param b The blue value used to fill the rendering target
  1222  * \param a The alpha value used to fill the rendering target, usually SDL_ALPHA_OPAQUE (255)
  1223  * \param rect A pointer to the destination rectangle, or NULL for the entire rendering target.
  1224  *
  1225  * \return 0 on success, or -1 if there is no rendering context current
  1226  */
  1227 extern DECLSPEC int SDLCALL SDL_RenderFill(const SDL_Rect * rect);
  1228 
  1229 /**
  1230  * \fn int SDL_RenderCopy(SDL_TextureID textureID, const SDL_Rect *srcrect, const SDL_Rect *dstrect)
  1231  *
  1232  * \brief Copy a portion of the texture to the current rendering target.
  1233  *
  1234  * \param texture The source texture.
  1235  * \param srcrect A pointer to the source rectangle, or NULL for the entire texture.
  1236  * \param dstrect A pointer to the destination rectangle, or NULL for the entire rendering target.
  1237  *
  1238  * \return 0 on success, or -1 if there is no rendering context current, or the driver doesn't support the requested operation.
  1239  */
  1240 extern DECLSPEC int SDLCALL SDL_RenderCopy(SDL_TextureID textureID,
  1241                                            const SDL_Rect * srcrect,
  1242                                            const SDL_Rect * dstrect);
  1243 
  1244 /**
  1245  * \fn int SDL_RenderReadPixels(const SDL_Rect *rect, void *pixels, int pitch)
  1246  *
  1247  * \brief Read pixels from the current rendering target.
  1248  *
  1249  * \param rect A pointer to the rectangle to read, or NULL for the entire render target
  1250  * \param pixels A pointer to be filled in with the pixel data
  1251  * \param pitch The pitch of the pixels parameter
  1252  *
  1253  * \return 0 on success, or -1 if pixel reading is not supported.
  1254  *
  1255  * \warning This is a very slow operation, and should not be used frequently.
  1256  */
  1257 extern DECLSPEC int SDLCALL SDL_RenderReadPixels(const SDL_Rect * rect,
  1258                                                  void *pixels, int pitch);
  1259 
  1260 /**
  1261  * \fn int SDL_RenderWritePixels(const SDL_Rect *rect, const void *pixels, int pitch)
  1262  *
  1263  * \brief Write pixels to the current rendering target.
  1264  *
  1265  * \param rect A pointer to the rectangle to write, or NULL for the entire render target
  1266  * \param pixels A pointer to the pixel data to write
  1267  * \param pitch The pitch of the pixels parameter
  1268  *
  1269  * \return 0 on success, or -1 if pixel writing is not supported.
  1270  *
  1271  * \warning This is a very slow operation, and should not be used frequently.
  1272  */
  1273 extern DECLSPEC int SDLCALL SDL_RenderWritePixels(const SDL_Rect * rect,
  1274                                                   const void *pixels,
  1275                                                   int pitch);
  1276 
  1277 /**
  1278  * \fn void SDL_RenderPresent(void)
  1279  *
  1280  * \brief Update the screen with rendering performed.
  1281  */
  1282 extern DECLSPEC void SDLCALL SDL_RenderPresent(void);
  1283 
  1284 /**
  1285  * \fn void SDL_DestroyTexture(SDL_TextureID textureID);
  1286  *
  1287  * \brief Destroy the specified texture.
  1288  *
  1289  * \sa SDL_CreateTexture()
  1290  * \sa SDL_CreateTextureFromSurface()
  1291  */
  1292 extern DECLSPEC void SDLCALL SDL_DestroyTexture(SDL_TextureID textureID);
  1293 
  1294 /**
  1295  * \fn void SDL_DestroyRenderer(SDL_WindowID windowID);
  1296  *
  1297  * \brief Destroy the rendering context for a window and free associated
  1298  *        textures.
  1299  *
  1300  * \sa SDL_CreateRenderer()
  1301  */
  1302 extern DECLSPEC void SDLCALL SDL_DestroyRenderer(SDL_WindowID windowID);
  1303 
  1304 
  1305 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
  1306 /* OpenGL support functions.                                                 */
  1307 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
  1308 
  1309 /**
  1310  * \fn int SDL_GL_LoadLibrary(const char *path)
  1311  *
  1312  * \brief Dynamically load an OpenGL library.
  1313  *
  1314  * \param path The platform dependent OpenGL library name, or NULL to open the default OpenGL library
  1315  *
  1316  * \return 0 on success, or -1 if the library couldn't be loaded
  1317  *
  1318  * This should be done after initializing the video driver, but before
  1319  * creating any OpenGL windows.  If no OpenGL library is loaded, the default
  1320  * library will be loaded upon creation of the first OpenGL window.
  1321  *
  1322  * \note If you do this, you need to retrieve all of the GL functions used in
  1323  *       your program from the dynamic library using SDL_GL_GetProcAddress().
  1324  *
  1325  * \sa SDL_GL_GetProcAddress()
  1326  */
  1327 extern DECLSPEC int SDLCALL SDL_GL_LoadLibrary(const char *path);
  1328 
  1329 /**
  1330  * \fn void *SDL_GL_GetProcAddress(const char *proc)
  1331  *
  1332  * \brief Get the address of an OpenGL function.
  1333  */
  1334 extern DECLSPEC void *SDLCALL SDL_GL_GetProcAddress(const char *proc);
  1335 
  1336 /**
  1337  * \fn SDL_bool SDL_GL_ExtensionSupported(const char *extension)
  1338  *
  1339  * \brief Return true if an OpenGL extension is supported for the current context.
  1340  */
  1341 extern DECLSPEC SDL_bool SDLCALL SDL_GL_ExtensionSupported(const char
  1342                                                            *extension);
  1343 
  1344 /**
  1345  * \fn int SDL_GL_SetAttribute(SDL_GLattr attr, int value)
  1346  *
  1347  * \brief Set an OpenGL window attribute before window creation.
  1348  */
  1349 extern DECLSPEC int SDLCALL SDL_GL_SetAttribute(SDL_GLattr attr, int value);
  1350 
  1351 /**
  1352  * \fn int SDL_GL_GetWindowAttribute(SDL_WindowID windowID, SDL_GLattr attr, int *value)
  1353  *
  1354  * \brief Get the actual value for an attribute from the current context.
  1355  */
  1356 extern DECLSPEC int SDLCALL SDL_GL_GetAttribute(SDL_GLattr attr, int *value);
  1357 
  1358 /**
  1359  * \fn SDL_GLContext SDL_GL_CreateContext(SDL_WindowID windowID)
  1360  *
  1361  * \brief Create an OpenGL context for use with an OpenGL window, and make it current.
  1362  *
  1363  * \sa SDL_GL_DeleteContext()
  1364  */
  1365 extern DECLSPEC SDL_GLContext SDLCALL SDL_GL_CreateContext(SDL_WindowID
  1366                                                            windowID);
  1367 
  1368 /**
  1369  * \fn int SDL_GL_MakeCurrent(SDL_WindowID windowID, SDL_GLContext context)
  1370  *
  1371  * \brief Set up an OpenGL context for rendering into an OpenGL window.
  1372  *
  1373  * \note The context must have been created with a compatible window.
  1374  */
  1375 extern DECLSPEC int SDLCALL SDL_GL_MakeCurrent(SDL_WindowID windowID,
  1376                                                SDL_GLContext context);
  1377 
  1378 /**
  1379  * \fn int SDL_GL_SetSwapInterval(int interval)
  1380  *
  1381  * \brief Set the swap interval for the current OpenGL context.
  1382  *
  1383  * \param interval 0 for immediate updates, 1 for updates synchronized with the vertical retrace
  1384  *
  1385  * \return 0 on success, or -1 if setting the swap interval is not supported.
  1386  *
  1387  * \sa SDL_GL_GetSwapInterval()
  1388  */
  1389 extern DECLSPEC int SDLCALL SDL_GL_SetSwapInterval(int interval);
  1390 
  1391 /**
  1392  * \fn int SDL_GL_GetSwapInterval(void)
  1393  *
  1394  * \brief Get the swap interval for the current OpenGL context.
  1395  *
  1396  * \return 0 if there is no vertical retrace synchronization, 1 if the buffer swap is synchronized with the vertical retrace, and -1 if getting the swap interval is not supported.
  1397  *
  1398  * \sa SDL_GL_SetSwapInterval()
  1399  */
  1400 extern DECLSPEC int SDLCALL SDL_GL_GetSwapInterval(void);
  1401 
  1402 /**
  1403  * \fn void SDL_GL_SwapWindow(SDL_WindowID windowID)
  1404  *
  1405  * \brief Swap the OpenGL buffers for the window, if double-buffering is supported.
  1406  */
  1407 extern DECLSPEC void SDLCALL SDL_GL_SwapWindow(SDL_WindowID windowID);
  1408 
  1409 /**
  1410  * \fn void SDL_GL_DeleteContext(SDL_GLContext context)
  1411  *
  1412  * \brief Delete an OpenGL context.
  1413  *
  1414  * \sa SDL_GL_CreateContext()
  1415  */
  1416 extern DECLSPEC void SDLCALL SDL_GL_DeleteContext(SDL_GLContext context);
  1417 
  1418 
  1419 /* Ends C function definitions when using C++ */
  1420 #ifdef __cplusplus
  1421 /* *INDENT-OFF* */
  1422 }
  1423 /* *INDENT-ON* */
  1424 #endif
  1425 #include "close_code.h"
  1426 
  1427 #endif /* _SDL_video_h */
  1428 
  1429 /* vi: set ts=4 sw=4 expandtab: */