ruby2d 0.11.0 → 0.11.3

data/assets/include/SDL2/SDL_render.h

@@ -1,6 +1,6 @@
 /*
   Simple DirectMedia Layer
-  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -59,7 +59,7 @@ extern "C" {
 #endif
 
 /**
- *  \brief Flags used when creating a rendering context
+ * Flags used when creating a rendering context
  */
 typedef enum
 {
@@ -73,7 +73,7 @@ typedef enum
 } SDL_RendererFlags;
 
 /**
- *  \brief Information on the capabilities of a render driver or context.
+ * Information on the capabilities of a render driver or context.
  */
 typedef struct SDL_RendererInfo
 {
@@ -86,7 +86,17 @@ typedef struct SDL_RendererInfo
 } SDL_RendererInfo;
 
 /**
- *  \brief The scaling mode for a texture.
+ *  Vertex structure
+ */
+typedef struct SDL_Vertex
+{
+    SDL_FPoint position;        /**< Vertex position, in SDL_Renderer coordinates  */
+    SDL_Color  color;           /**< Vertex color */
+    SDL_FPoint tex_coord;       /**< Normalized texture coordinates, if needed */
+} SDL_Vertex;
+
+/**
+ * The scaling mode for a texture.
  */
 typedef enum
 {
@@ -96,7 +106,7 @@ typedef enum
 } SDL_ScaleMode;
 
 /**
- *  \brief The access pattern allowed for a texture.
+ * The access pattern allowed for a texture.
  */
 typedef enum
 {
@@ -106,7 +116,7 @@ typedef enum
 } SDL_TextureAccess;
 
 /**
- *  \brief The texture channel modulation used in SDL_RenderCopy().
+ * The texture channel modulation used in SDL_RenderCopy().
  */
 typedef enum
 {
@@ -116,7 +126,7 @@ typedef enum
 } SDL_TextureModulate;
 
 /**
- *  \brief Flip constants for SDL_RenderCopyEx
+ * Flip constants for SDL_RenderCopyEx
  */
 typedef enum
 {
@@ -126,58 +136,71 @@ typedef enum
 } SDL_RendererFlip;
 
 /**
- *  \brief A structure representing rendering state
+ * A structure representing rendering state
  */
 struct SDL_Renderer;
 typedef struct SDL_Renderer SDL_Renderer;
 
 /**
- *  \brief An efficient driver-specific representation of pixel data
+ * An efficient driver-specific representation of pixel data
  */
 struct SDL_Texture;
 typedef struct SDL_Texture SDL_Texture;
 
-
 /* Function prototypes */
 
 /**
- *  \brief Get the number of 2D rendering drivers available for the current
- *         display.
+ * Get the number of 2D rendering drivers available for the current display.
  *
- *  A render driver is a set of code that handles rendering and texture
- *  management on a particular display.  Normally there is only one, but
- *  some drivers may have several available with different capabilities.
+ * A render driver is a set of code that handles rendering and texture
+ * management on a particular display. Normally there is only one, but some
+ * drivers may have several available with different capabilities.
  *
- *  \sa SDL_GetRenderDriverInfo()
- *  \sa SDL_CreateRenderer()
+ * There may be none if SDL was compiled without render support.
+ *
+ * \returns a number >= 0 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_CreateRenderer
+ * \sa SDL_GetRenderDriverInfo
  */
 extern DECLSPEC int SDLCALL SDL_GetNumRenderDrivers(void);
 
 /**
- *  \brief Get information about a specific 2D rendering driver for the current
- *         display.
+ * Get info about a specific 2D rendering driver for the current display.
  *
- *  \param index The index of the driver to query information about.
- *  \param info  A pointer to an SDL_RendererInfo struct to be filled with
- *               information on the rendering driver.
+ * \param index the index of the driver to query information about
+ * \param info an SDL_RendererInfo structure to be filled with information on
+ *             the rendering driver
+ * \returns 0 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
  *
- *  \return 0 on success, -1 if the index was out of range.
+ * \since This function is available since SDL 2.0.0.
  *
- *  \sa SDL_CreateRenderer()
+ * \sa SDL_CreateRenderer
+ * \sa SDL_GetNumRenderDrivers
  */
 extern DECLSPEC int SDLCALL SDL_GetRenderDriverInfo(int index,
                                                     SDL_RendererInfo * info);
 
 /**
- *  \brief Create a window and default renderer
+ * Create a window and default renderer.
  *
- *  \param width    The width of the window
- *  \param height   The height of the window
- *  \param window_flags The flags used to create the window
- *  \param window   A pointer filled with the window, or NULL on error
- *  \param renderer A pointer filled with the renderer, or NULL on error
+ * \param width the width of the window
+ * \param height the height of the window
+ * \param window_flags the flags used to create the window (see
+ *                     SDL_CreateWindow())
+ * \param window a pointer filled with the window, or NULL on error
+ * \param renderer a pointer filled with the renderer, or NULL on error
+ * \returns 0 on success, or -1 on error; call SDL_GetError() for more
+ *          information.
  *
- *  \return 0 on success, or -1 on error
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_CreateRenderer
+ * \sa SDL_CreateWindow
  */
 extern DECLSPEC int SDLCALL SDL_CreateWindowAndRenderer(
                                 int width, int height, Uint32 window_flags,
@@ -185,69 +208,116 @@ extern DECLSPEC int SDLCALL SDL_CreateWindowAndRenderer(
 
 
 /**
- *  \brief Create a 2D rendering context for a window.
+ * Create a 2D rendering context for a window.
  *
- *  \param window The window where rendering is displayed.
- *  \param index    The index of the rendering driver to initialize, or -1 to
- *                  initialize the first one supporting the requested flags.
- *  \param flags    ::SDL_RendererFlags.
+ * \param window the window where rendering is displayed
+ * \param index the index of the rendering driver to initialize, or -1 to
+ *              initialize the first one supporting the requested flags
+ * \param flags 0, or one or more SDL_RendererFlags OR'd together
+ * \returns a valid rendering context or NULL if there was an error; call
+ *          SDL_GetError() for more information.
  *
- *  \return A valid rendering context or NULL if there was an error.
+ * \since This function is available since SDL 2.0.0.
  *
- *  \sa SDL_CreateSoftwareRenderer()
- *  \sa SDL_GetRendererInfo()
- *  \sa SDL_DestroyRenderer()
+ * \sa SDL_CreateSoftwareRenderer
+ * \sa SDL_DestroyRenderer
+ * \sa SDL_GetNumRenderDrivers
+ * \sa SDL_GetRendererInfo
  */
 extern DECLSPEC SDL_Renderer * SDLCALL SDL_CreateRenderer(SDL_Window * window,
                                                int index, Uint32 flags);
 
 /**
- *  \brief Create a 2D software rendering context for a surface.
+ * Create a 2D software rendering context for a surface.
+ *
+ * Two other API which can be used to create SDL_Renderer:
+ * SDL_CreateRenderer() and SDL_CreateWindowAndRenderer(). These can _also_
+ * create a software renderer, but they are intended to be used with an
+ * SDL_Window as the final destination and not an SDL_Surface.
  *
- *  \param surface The surface where rendering is done.
+ * \param surface the SDL_Surface structure representing the surface where
+ *                rendering is done
+ * \returns a valid rendering context or NULL if there was an error; call
+ *          SDL_GetError() for more information.
  *
- *  \return A valid rendering context or NULL if there was an error.
+ * \since This function is available since SDL 2.0.0.
  *
- *  \sa SDL_CreateRenderer()
- *  \sa SDL_DestroyRenderer()
+ * \sa SDL_CreateRenderer
+ * \sa SDL_CreateWindowRenderer
+ * \sa SDL_DestroyRenderer
  */
 extern DECLSPEC SDL_Renderer * SDLCALL SDL_CreateSoftwareRenderer(SDL_Surface * surface);
 
 /**
- *  \brief Get the renderer associated with a window.
+ * Get the renderer associated with a window.
+ *
+ * \param window the window to query
+ * \returns the rendering context on success or NULL on failure; call
+ *          SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_CreateRenderer
  */
 extern DECLSPEC SDL_Renderer * SDLCALL SDL_GetRenderer(SDL_Window * window);
 
 /**
- *  \brief Get information about a rendering context.
+ * Get information about a rendering context.
+ *
+ * \param renderer the rendering context
+ * \param info an SDL_RendererInfo structure filled with information about the
+ *             current renderer
+ * \returns 0 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_CreateRenderer
  */
 extern DECLSPEC int SDLCALL SDL_GetRendererInfo(SDL_Renderer * renderer,
                                                 SDL_RendererInfo * info);
 
 /**
- *  \brief Get the output size in pixels of a rendering context.
+ * Get the output size in pixels of a rendering context.
+ *
+ * Due to high-dpi displays, you might end up with a rendering context that
+ * has more pixels than the window that contains it, so use this instead of
+ * SDL_GetWindowSize() to decide how much drawing area you have.
+ *
+ * \param renderer the rendering context
+ * \param w an int filled with the width
+ * \param h an int filled with the height
+ * \returns 0 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_GetRenderer
  */
 extern DECLSPEC int SDLCALL SDL_GetRendererOutputSize(SDL_Renderer * renderer,
                                                       int *w, int *h);
 
 /**
- *  \brief Create a texture for a rendering context.
+ * Create a texture for a rendering context.
  *
- *  \param renderer The renderer.
- *  \param format The format of the texture.
- *  \param access One of the enumerated values in ::SDL_TextureAccess.
- *  \param w      The width of the texture in pixels.
- *  \param h      The height of the texture in pixels.
+ * You can set the texture scaling method by setting
+ * `SDL_HINT_RENDER_SCALE_QUALITY` before creating the texture.
  *
- *  \return The created texture is returned, or NULL if no rendering context was
- *          active,  the format was unsupported, or the width or height were out
- *          of range.
+ * \param renderer the rendering context
+ * \param format one of the enumerated values in SDL_PixelFormatEnum
+ * \param access one of the enumerated values in SDL_TextureAccess
+ * \param w the width of the texture in pixels
+ * \param h the height of the texture in pixels
+ * \returns a pointer to the created texture or NULL if no rendering context
+ *          was active, the format was unsupported, or the width or height
+ *          were out of range; call SDL_GetError() for more information.
  *
- *  \note The contents of the texture are not defined at creation.
+ * \since This function is available since SDL 2.0.0.
  *
- *  \sa SDL_QueryTexture()
- *  \sa SDL_UpdateTexture()
- *  \sa SDL_DestroyTexture()
+ * \sa SDL_CreateTextureFromSurface
+ * \sa SDL_DestroyTexture
+ * \sa SDL_QueryTexture
+ * \sa SDL_UpdateTexture
  */
 extern DECLSPEC SDL_Texture * SDLCALL SDL_CreateTexture(SDL_Renderer * renderer,
                                                         Uint32 format,
@@ -255,194 +325,290 @@ extern DECLSPEC SDL_Texture * SDLCALL SDL_CreateTexture(SDL_Renderer * renderer,
                                                         int h);
 
 /**
- *  \brief Create a texture from an existing surface.
+ * Create a texture from an existing surface.
+ *
+ * The surface is not modified or freed by this function.
+ *
+ * The SDL_TextureAccess hint for the created texture is
+ * `SDL_TEXTUREACCESS_STATIC`.
  *
- *  \param renderer The renderer.
- *  \param surface The surface containing pixel data used to fill the texture.
+ * The pixel format of the created texture may be different from the pixel
+ * format of the surface. Use SDL_QueryTexture() to query the pixel format of
+ * the texture.
  *
- *  \return The created texture is returned, or NULL on error.
+ * \param renderer the rendering context
+ * \param surface the SDL_Surface structure containing pixel data used to fill
+ *                the texture
+ * \returns the created texture or NULL on failure; call SDL_GetError() for
+ *          more information.
  *
- *  \note The surface is not modified or freed by this function.
+ * \since This function is available since SDL 2.0.0.
  *
- *  \sa SDL_QueryTexture()
- *  \sa SDL_DestroyTexture()
+ * \sa SDL_CreateTexture
+ * \sa SDL_DestroyTexture
+ * \sa SDL_QueryTexture
  */
 extern DECLSPEC SDL_Texture * SDLCALL SDL_CreateTextureFromSurface(SDL_Renderer * renderer, SDL_Surface * surface);
 
 /**
- *  \brief Query the attributes of a texture
+ * Query the attributes of a texture.
  *
- *  \param texture A texture to be queried.
- *  \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.
- *  \param access  A pointer filled in with the actual access to the texture.
- *  \param w       A pointer filled in with the width of the texture in pixels.
- *  \param h       A pointer filled in with the height of the texture in pixels.
+ * \param texture the texture to query
+ * \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 (one of the SDL_PixelFormatEnum values)
+ * \param access a pointer filled in with the actual access to the texture
+ *               (one of the SDL_TextureAccess values)
+ * \param w a pointer filled in with the width of the texture in pixels
+ * \param h a pointer filled in with the height of the texture in pixels
+ * \returns 0 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
  *
- *  \return 0 on success, or -1 if the texture is not valid.
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_CreateTexture
  */
 extern DECLSPEC int SDLCALL SDL_QueryTexture(SDL_Texture * texture,
                                              Uint32 * format, int *access,
                                              int *w, int *h);
 
 /**
- *  \brief Set an additional color value used in render copy operations.
+ * Set an additional color value multiplied into render copy operations.
+ *
+ * When this texture is rendered, during the copy operation each source color
+ * channel is modulated by the appropriate color value according to the
+ * following formula:
  *
- *  \param texture The texture to update.
- *  \param r       The red color value multiplied into copy operations.
- *  \param g       The green color value multiplied into copy operations.
- *  \param b       The blue color value multiplied into copy operations.
+ * `srcC = srcC * (color / 255)`
  *
- *  \return 0 on success, or -1 if the texture is not valid or color modulation
- *          is not supported.
+ * Color modulation is not always supported by the renderer; it will return -1
+ * if color modulation is not supported.
  *
- *  \sa SDL_GetTextureColorMod()
+ * \param texture the texture to update
+ * \param r the red color value multiplied into copy operations
+ * \param g the green color value multiplied into copy operations
+ * \param b the blue color value multiplied into copy operations
+ * \returns 0 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_GetTextureColorMod
+ * \sa SDL_SetTextureAlphaMod
  */
 extern DECLSPEC int SDLCALL SDL_SetTextureColorMod(SDL_Texture * texture,
                                                    Uint8 r, Uint8 g, Uint8 b);
 
 
 /**
- *  \brief Get the additional color value used in render copy operations.
+ * Get the additional color value multiplied into render copy operations.
  *
- *  \param texture The texture to query.
- *  \param r         A pointer filled in with the current red color value.
- *  \param g         A pointer filled in with the current green color value.
- *  \param b         A pointer filled in with the current blue color value.
+ * \param texture the texture to query
+ * \param r a pointer filled in with the current red color value
+ * \param g a pointer filled in with the current green color value
+ * \param b a pointer filled in with the current blue color value
+ * \returns 0 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
  *
- *  \return 0 on success, or -1 if the texture is not valid.
+ * \since This function is available since SDL 2.0.0.
  *
- *  \sa SDL_SetTextureColorMod()
+ * \sa SDL_GetTextureAlphaMod
+ * \sa SDL_SetTextureColorMod
  */
 extern DECLSPEC int SDLCALL SDL_GetTextureColorMod(SDL_Texture * texture,
                                                    Uint8 * r, Uint8 * g,
                                                    Uint8 * b);
 
 /**
- *  \brief Set an additional alpha value used in render copy operations.
+ * Set an additional alpha value multiplied into render copy operations.
+ *
+ * When this texture is rendered, during the copy operation the source alpha
+ * value is modulated by this alpha value according to the following formula:
+ *
+ * `srcA = srcA * (alpha / 255)`
+ *
+ * Alpha modulation is not always supported by the renderer; it will return -1
+ * if alpha modulation is not supported.
  *
- *  \param texture The texture to update.
- *  \param alpha     The alpha value multiplied into copy operations.
+ * \param texture the texture to update
+ * \param alpha the source alpha value multiplied into copy operations
+ * \returns 0 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
  *
- *  \return 0 on success, or -1 if the texture is not valid or alpha modulation
- *          is not supported.
+ * \since This function is available since SDL 2.0.0.
  *
- *  \sa SDL_GetTextureAlphaMod()
+ * \sa SDL_GetTextureAlphaMod
+ * \sa SDL_SetTextureColorMod
  */
 extern DECLSPEC int SDLCALL SDL_SetTextureAlphaMod(SDL_Texture * texture,
                                                    Uint8 alpha);
 
 /**
- *  \brief Get the additional alpha value used in render copy operations.
+ * Get the additional alpha value multiplied into render copy operations.
  *
- *  \param texture The texture to query.
- *  \param alpha     A pointer filled in with the current alpha value.
+ * \param texture the texture to query
+ * \param alpha a pointer filled in with the current alpha value
+ * \returns 0 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
  *
- *  \return 0 on success, or -1 if the texture is not valid.
+ * \since This function is available since SDL 2.0.0.
  *
- *  \sa SDL_SetTextureAlphaMod()
+ * \sa SDL_GetTextureColorMod
+ * \sa SDL_SetTextureAlphaMod
  */
 extern DECLSPEC int SDLCALL SDL_GetTextureAlphaMod(SDL_Texture * texture,
                                                    Uint8 * alpha);
 
 /**
- *  \brief Set the blend mode used for texture copy operations.
+ * Set the blend mode for a texture, used by SDL_RenderCopy().
  *
- *  \param texture The texture to update.
- *  \param blendMode ::SDL_BlendMode to use for texture blending.
+ * If the blend mode is not supported, the closest supported mode is chosen
+ * and this function returns -1.
  *
- *  \return 0 on success, or -1 if the texture is not valid or the blend mode is
- *          not supported.
+ * \param texture the texture to update
+ * \param blendMode the SDL_BlendMode to use for texture blending
+ * \returns 0 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
  *
- *  \note If the blend mode is not supported, the closest supported mode is
- *        chosen.
+ * \since This function is available since SDL 2.0.0.
  *
- *  \sa SDL_GetTextureBlendMode()
+ * \sa SDL_GetTextureBlendMode
+ * \sa SDL_RenderCopy
  */
 extern DECLSPEC int SDLCALL SDL_SetTextureBlendMode(SDL_Texture * texture,
                                                     SDL_BlendMode blendMode);
 
 /**
- *  \brief Get the blend mode used for texture copy operations.
+ * Get the blend mode used for texture copy operations.
  *
- *  \param texture   The texture to query.
- *  \param blendMode A pointer filled in with the current blend mode.
+ * \param texture the texture to query
+ * \param blendMode a pointer filled in with the current SDL_BlendMode
+ * \returns 0 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
  *
- *  \return 0 on success, or -1 if the texture is not valid.
+ * \since This function is available since SDL 2.0.0.
  *
- *  \sa SDL_SetTextureBlendMode()
+ * \sa SDL_SetTextureBlendMode
  */
 extern DECLSPEC int SDLCALL SDL_GetTextureBlendMode(SDL_Texture * texture,
                                                     SDL_BlendMode *blendMode);
 
 /**
- *  \brief Set the scale mode used for texture scale operations.
+ * Set the scale mode used for texture scale operations.
  *
- *  \param texture The texture to update.
- *  \param scaleMode ::SDL_ScaleMode to use for texture scaling.
+ * If the scale mode is not supported, the closest supported mode is chosen.
  *
- *  \return 0 on success, or -1 if the texture is not valid.
+ * \param texture The texture to update.
+ * \param scaleMode the SDL_ScaleMode to use for texture scaling.
+ * \returns 0 on success, or -1 if the texture is not valid.
  *
- *  \note If the scale mode is not supported, the closest supported mode is
- *        chosen.
+ * \since This function is available since SDL 2.0.12.
  *
- *  \sa SDL_GetTextureScaleMode()
+ * \sa SDL_GetTextureScaleMode
  */
 extern DECLSPEC int SDLCALL SDL_SetTextureScaleMode(SDL_Texture * texture,
                                                     SDL_ScaleMode scaleMode);
 
 /**
- *  \brief Get the scale mode used for texture scale operations.
+ * Get the scale mode used for texture scale operations.
  *
- *  \param texture   The texture to query.
- *  \param scaleMode A pointer filled in with the current scale mode.
+ * \param texture the texture to query.
+ * \param scaleMode a pointer filled in with the current scale mode.
+ * \return 0 on success, or -1 if the texture is not valid.
  *
- *  \return 0 on success, or -1 if the texture is not valid.
+ * \since This function is available since SDL 2.0.12.
  *
- *  \sa SDL_SetTextureScaleMode()
+ * \sa SDL_SetTextureScaleMode
  */
 extern DECLSPEC int SDLCALL SDL_GetTextureScaleMode(SDL_Texture * texture,
                                                     SDL_ScaleMode *scaleMode);
 
 /**
- *  \brief Update the given texture rectangle with new pixel data.
+ * Associate a user-specified pointer with a texture.
  *
- *  \param texture   The texture to update
- *  \param rect      A pointer to the rectangle of pixels to update, or NULL to
- *                   update the entire texture.
- *  \param pixels    The raw pixel data in the format of the texture.
- *  \param pitch     The number of bytes in a row of pixel data, including padding between lines.
+ * \param texture the texture to update.
+ * \param userdata the pointer to associate with the texture.
+ * \returns 0 on success, or -1 if the texture is not valid.
  *
- *  The pixel data must be in the format of the texture. The pixel format can be
- *  queried with SDL_QueryTexture.
+ * \since This function is available since SDL 2.0.18.
  *
- *  \return 0 on success, or -1 if the texture is not valid.
+ * \sa SDL_GetTextureUserData
+ */
+extern DECLSPEC int SDLCALL SDL_SetTextureUserData(SDL_Texture * texture,
+                                                   void *userdata);
+
+/**
+ * Get the user-specified pointer associated with a texture
+ *
+ * \param texture the texture to query.
+ * \return the pointer associated with the texture, or NULL if the texture is
+ *         not valid.
+ *
+ * \since This function is available since SDL 2.0.18.
  *
- *  \note This is a fairly slow function.
+ * \sa SDL_SetTextureUserData
+ */
+extern DECLSPEC void * SDLCALL SDL_GetTextureUserData(SDL_Texture * texture);
+
+/**
+ * Update the given texture rectangle with new pixel data.
+ *
+ * The pixel data must be in the pixel format of the texture. Use
+ * SDL_QueryTexture() to query the pixel format of the texture.
+ *
+ * This is a fairly slow function, intended for use with static textures that
+ * do not change often.
+ *
+ * If the texture is intended to be updated often, it is preferred to create
+ * the texture as streaming and use the locking functions referenced below.
+ * While this function will work with streaming textures, for optimization
+ * reasons you may not get the pixels back if you lock the texture afterward.
+ *
+ * \param texture the texture to update
+ * \param rect an SDL_Rect structure representing the area to update, or NULL
+ *             to update the entire texture
+ * \param pixels the raw pixel data in the format of the texture
+ * \param pitch the number of bytes in a row of pixel data, including padding
+ *              between lines
+ * \returns 0 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_CreateTexture
+ * \sa SDL_LockTexture
+ * \sa SDL_UnlockTexture
  */
 extern DECLSPEC int SDLCALL SDL_UpdateTexture(SDL_Texture * texture,
                                               const SDL_Rect * rect,
                                               const void *pixels, int pitch);
 
 /**
- *  \brief Update a rectangle within a planar YV12 or IYUV texture with new pixel data.
+ * Update a rectangle within a planar YV12 or IYUV texture with new pixel
+ * data.
  *
- *  \param texture   The texture to update
- *  \param rect      A pointer to the rectangle of pixels to update, or NULL to
- *                   update the entire texture.
- *  \param Yplane    The raw pixel data for the Y plane.
- *  \param Ypitch    The number of bytes between rows of pixel data for the Y plane.
- *  \param Uplane    The raw pixel data for the U plane.
- *  \param Upitch    The number of bytes between rows of pixel data for the U plane.
- *  \param Vplane    The raw pixel data for the V plane.
- *  \param Vpitch    The number of bytes between rows of pixel data for the V plane.
+ * You can use SDL_UpdateTexture() as long as your pixel data is a contiguous
+ * block of Y and U/V planes in the proper order, but this function is
+ * available if your pixel data is not contiguous.
  *
- *  \return 0 on success, or -1 if the texture is not valid.
+ * \param texture the texture to update
+ * \param rect a pointer to the rectangle of pixels to update, or NULL to
+ *             update the entire texture
+ * \param Yplane the raw pixel data for the Y plane
+ * \param Ypitch the number of bytes between rows of pixel data for the Y
+ *               plane
+ * \param Uplane the raw pixel data for the U plane
+ * \param Upitch the number of bytes between rows of pixel data for the U
+ *               plane
+ * \param Vplane the raw pixel data for the V plane
+ * \param Vpitch the number of bytes between rows of pixel data for the V
+ *               plane
+ * \returns 0 on success or -1 if the texture is not valid; call
+ *          SDL_GetError() for more information.
  *
- *  \note You can use SDL_UpdateTexture() as long as your pixel data is
- *        a contiguous block of Y and U/V planes in the proper order, but
- *        this function is available if your pixel data is not contiguous.
+ * \since This function is available since SDL 2.0.1.
+ *
+ * \sa SDL_UpdateTexture
  */
 extern DECLSPEC int SDLCALL SDL_UpdateYUVTexture(SDL_Texture * texture,
                                                  const SDL_Rect * rect,
@@ -451,421 +617,771 @@ extern DECLSPEC int SDLCALL SDL_UpdateYUVTexture(SDL_Texture * texture,
                                                  const Uint8 *Vplane, int Vpitch);
 
 /**
- *  \brief Lock a portion of the texture for write-only pixel access.
+ * Update a rectangle within a planar NV12 or NV21 texture with new pixels.
  *
- *  \param texture   The texture to lock for access, which was created with
- *                   ::SDL_TEXTUREACCESS_STREAMING.
- *  \param rect      A pointer to the rectangle to lock for access. If the rect
- *                   is NULL, the entire texture will be locked.
- *  \param pixels    This is filled in with a pointer to the locked pixels,
- *                   appropriately offset by the locked area.
- *  \param pitch     This is filled in with the pitch of the locked pixels.
+ * You can use SDL_UpdateTexture() as long as your pixel data is a contiguous
+ * block of NV12/21 planes in the proper order, but this function is available
+ * if your pixel data is not contiguous.
  *
- *  \return 0 on success, or -1 if the texture is not valid or was not created with ::SDL_TEXTUREACCESS_STREAMING.
+ * \param texture the texture to update
+ * \param rect a pointer to the rectangle of pixels to update, or NULL to
+ *             update the entire texture.
+ * \param Yplane the raw pixel data for the Y plane.
+ * \param Ypitch the number of bytes between rows of pixel data for the Y
+ *               plane.
+ * \param UVplane the raw pixel data for the UV plane.
+ * \param UVpitch the number of bytes between rows of pixel data for the UV
+ *                plane.
+ * \return 0 on success, or -1 if the texture is not valid.
  *
- *  \sa SDL_UnlockTexture()
+ * \since This function is available since SDL 2.0.16.
+ */
+extern DECLSPEC int SDLCALL SDL_UpdateNVTexture(SDL_Texture * texture,
+                                                 const SDL_Rect * rect,
+                                                 const Uint8 *Yplane, int Ypitch,
+                                                 const Uint8 *UVplane, int UVpitch);
+
+/**
+ * Lock a portion of the texture for **write-only** pixel access.
+ *
+ * As an optimization, the pixels made available for editing don't necessarily
+ * contain the old texture data. This is a write-only operation, and if you
+ * need to keep a copy of the texture data you should do that at the
+ * application level.
+ *
+ * You must use SDL_UnlockTexture() to unlock the pixels and apply any
+ * changes.
+ *
+ * \param texture the texture to lock for access, which was created with
+ *                `SDL_TEXTUREACCESS_STREAMING`
+ * \param rect an SDL_Rect structure representing the area to lock for access;
+ *             NULL to lock the entire texture
+ * \param pixels this is filled in with a pointer to the locked pixels,
+ *               appropriately offset by the locked area
+ * \param pitch this is filled in with the pitch of the locked pixels; the
+ *              pitch is the length of one row in bytes
+ * \returns 0 on success or a negative error code if the texture is not valid
+ *          or was not created with `SDL_TEXTUREACCESS_STREAMING`; call
+ *          SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_UnlockTexture
  */
 extern DECLSPEC int SDLCALL SDL_LockTexture(SDL_Texture * texture,
                                             const SDL_Rect * rect,
                                             void **pixels, int *pitch);
 
 /**
- *  \brief Lock a portion of the texture for write-only pixel access.
- *         Expose it as a SDL surface.
+ * Lock a portion of the texture for **write-only** pixel access, and expose
+ * it as a SDL surface.
+ *
+ * Besides providing an SDL_Surface instead of raw pixel data, this function
+ * operates like SDL_LockTexture.
+ *
+ * As an optimization, the pixels made available for editing don't necessarily
+ * contain the old texture data. This is a write-only operation, and if you
+ * need to keep a copy of the texture data you should do that at the
+ * application level.
+ *
+ * You must use SDL_UnlockTexture() to unlock the pixels and apply any
+ * changes.
  *
- *  \param texture   The texture to lock for access, which was created with
- *                   ::SDL_TEXTUREACCESS_STREAMING.
- *  \param rect      A pointer to the rectangle to lock for access. If the rect
- *                   is NULL, the entire texture will be locked.
- *  \param surface   This is filled in with a SDL surface representing the locked area
- *                   Surface is freed internally after calling SDL_UnlockTexture or SDL_DestroyTexture.
+ * The returned surface is freed internally after calling SDL_UnlockTexture()
+ * or SDL_DestroyTexture(). The caller should not free it.
  *
- *  \return 0 on success, or -1 if the texture is not valid or was not created with ::SDL_TEXTUREACCESS_STREAMING.
+ * \param texture the texture to lock for access, which was created with
+ *                `SDL_TEXTUREACCESS_STREAMING`
+ * \param rect a pointer to the rectangle to lock for access. If the rect is
+ *             NULL, the entire texture will be locked
+ * \param surface this is filled in with an SDL surface representing the
+ *                locked area
+ * \returns 0 on success, or -1 if the texture is not valid or was not created
+ *          with `SDL_TEXTUREACCESS_STREAMING`
  *
- *  \sa SDL_UnlockTexture()
+ * \since This function is available since SDL 2.0.12.
+ *
+ * \sa SDL_LockTexture
+ * \sa SDL_UnlockTexture
  */
 extern DECLSPEC int SDLCALL SDL_LockTextureToSurface(SDL_Texture *texture,
                                             const SDL_Rect *rect,
                                             SDL_Surface **surface);
 
 /**
- *  \brief Unlock a texture, uploading the changes to video memory, if needed.
- *         If SDL_LockTextureToSurface() was called for locking, the SDL surface is freed.
+ * Unlock a texture, uploading the changes to video memory, if needed.
+ *
+ * **Warning**: Please note that SDL_LockTexture() is intended to be
+ * write-only; it will not guarantee the previous contents of the texture will
+ * be provided. You must fully initialize any area of a texture that you lock
+ * before unlocking it, as the pixels might otherwise be uninitialized memory.
+ *
+ * Which is to say: locking and immediately unlocking a texture can result in
+ * corrupted textures, depending on the renderer in use.
+ *
+ * \param texture a texture locked by SDL_LockTexture()
+ *
+ * \since This function is available since SDL 2.0.0.
  *
- *  \sa SDL_LockTexture()
- *  \sa SDL_LockTextureToSurface()
+ * \sa SDL_LockTexture
  */
 extern DECLSPEC void SDLCALL SDL_UnlockTexture(SDL_Texture * texture);
 
 /**
- * \brief Determines whether a window supports the use of render targets
+ * Determine whether a renderer supports the use of render targets.
  *
- * \param renderer The renderer that will be checked
+ * \param renderer the renderer that will be checked
+ * \returns SDL_TRUE if supported or SDL_FALSE if not.
  *
- * \return SDL_TRUE if supported, SDL_FALSE if not.
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_SetRenderTarget
  */
 extern DECLSPEC SDL_bool SDLCALL SDL_RenderTargetSupported(SDL_Renderer *renderer);
 
 /**
- * \brief Set a texture as the current rendering target.
+ * Set a texture as the current rendering target.
  *
- * \param renderer The renderer.
- * \param texture The targeted texture, which must be created with the SDL_TEXTUREACCESS_TARGET flag, or NULL for the default render target
+ * Before using this function, you should check the
+ * `SDL_RENDERER_TARGETTEXTURE` bit in the flags of SDL_RendererInfo to see if
+ * render targets are supported.
  *
- * \return 0 on success, or -1 on error
+ * The default render target is the window for which the renderer was created.
+ * To stop rendering to a texture and render to the window again, call this
+ * function with a NULL `texture`.
+ *
+ * \param renderer the rendering context
+ * \param texture the targeted texture, which must be created with the
+ *                `SDL_TEXTUREACCESS_TARGET` flag, or NULL to render to the
+ *                window instead of a texture.
+ * \returns 0 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.0.
  *
- *  \sa SDL_GetRenderTarget()
+ * \sa SDL_GetRenderTarget
  */
 extern DECLSPEC int SDLCALL SDL_SetRenderTarget(SDL_Renderer *renderer,
                                                 SDL_Texture *texture);
 
 /**
- * \brief Get the current render target or NULL for the default render target.
+ * Get the current render target.
  *
- * \return The current render target
+ * The default render target is the window for which the renderer was created,
+ * and is reported a NULL here.
  *
- *  \sa SDL_SetRenderTarget()
+ * \param renderer the rendering context
+ * \returns the current render target or NULL for the default render target.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_SetRenderTarget
  */
 extern DECLSPEC SDL_Texture * SDLCALL SDL_GetRenderTarget(SDL_Renderer *renderer);
 
 /**
- *  \brief Set device independent resolution for rendering
+ * Set a device independent resolution for rendering.
+ *
+ * This function uses the viewport and scaling functionality to allow a fixed
+ * logical resolution for rendering, regardless of the actual output
+ * resolution. If the actual output resolution doesn't have the same aspect
+ * ratio the output rendering will be centered within the output display.
  *
- *  \param renderer The renderer for which resolution should be set.
- *  \param w      The width of the logical resolution
- *  \param h      The height of the logical resolution
+ * If the output display is a window, mouse and touch events in the window
+ * will be filtered and scaled so they seem to arrive within the logical
+ * resolution. The SDL_HINT_MOUSE_RELATIVE_SCALING hint controls whether
+ * relative motion events are also scaled.
  *
- *  This function uses the viewport and scaling functionality to allow a fixed logical
- *  resolution for rendering, regardless of the actual output resolution.  If the actual
- *  output resolution doesn't have the same aspect ratio the output rendering will be
- *  centered within the output display.
+ * If this function results in scaling or subpixel drawing by the rendering
+ * backend, it will be handled using the appropriate quality hints.
  *
- *  If the output display is a window, mouse events in the window will be filtered
- *  and scaled so they seem to arrive within the logical resolution.
+ * \param renderer the renderer for which resolution should be set
+ * \param w the width of the logical resolution
+ * \param h the height of the logical resolution
+ * \returns 0 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
  *
- *  \note If this function results in scaling or subpixel drawing by the
- *        rendering backend, it will be handled using the appropriate
- *        quality hints.
+ * \since This function is available since SDL 2.0.0.
  *
- *  \sa SDL_RenderGetLogicalSize()
- *  \sa SDL_RenderSetScale()
- *  \sa SDL_RenderSetViewport()
+ * \sa SDL_RenderGetLogicalSize
  */
 extern DECLSPEC int SDLCALL SDL_RenderSetLogicalSize(SDL_Renderer * renderer, int w, int h);
 
 /**
- *  \brief Get device independent resolution for rendering
+ * Get device independent resolution for rendering.
+ *
+ * This may return 0 for `w` and `h` if the SDL_Renderer has never had its
+ * logical size set by SDL_RenderSetLogicalSize() and never had a render
+ * target set.
+ *
+ * \param renderer a rendering context
+ * \param w an int to be filled with the width
+ * \param h an int to be filled with the height
  *
- *  \param renderer The renderer from which resolution should be queried.
- *  \param w      A pointer filled with the width of the logical resolution
- *  \param h      A pointer filled with the height of the logical resolution
+ * \since This function is available since SDL 2.0.0.
  *
- *  \sa SDL_RenderSetLogicalSize()
+ * \sa SDL_RenderSetLogicalSize
  */
 extern DECLSPEC void SDLCALL SDL_RenderGetLogicalSize(SDL_Renderer * renderer, int *w, int *h);
 
 /**
- *  \brief Set whether to force integer scales for resolution-independent rendering
+ * Set whether to force integer scales for resolution-independent rendering.
  *
- *  \param renderer The renderer for which integer scaling should be set.
- *  \param enable   Enable or disable integer scaling
+ * This function restricts the logical viewport to integer values - that is,
+ * when a resolution is between two multiples of a logical size, the viewport
+ * size is rounded down to the lower multiple.
  *
- *  This function restricts the logical viewport to integer values - that is, when
- *  a resolution is between two multiples of a logical size, the viewport size is
- *  rounded down to the lower multiple.
+ * \param renderer the renderer for which integer scaling should be set
+ * \param enable enable or disable the integer scaling for rendering
+ * \returns 0 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
  *
- *  \sa SDL_RenderSetLogicalSize()
+ * \since This function is available since SDL 2.0.5.
+ *
+ * \sa SDL_RenderGetIntegerScale
+ * \sa SDL_RenderSetLogicalSize
  */
 extern DECLSPEC int SDLCALL SDL_RenderSetIntegerScale(SDL_Renderer * renderer,
                                                       SDL_bool enable);
 
 /**
- *  \brief Get whether integer scales are forced for resolution-independent rendering
+ * Get whether integer scales are forced for resolution-independent rendering.
+ *
+ * \param renderer the renderer from which integer scaling should be queried
+ * \returns SDL_TRUE if integer scales are forced or SDL_FALSE if not and on
+ *          failure; call SDL_GetError() for more information.
  *
- *  \param renderer The renderer from which integer scaling should be queried.
+ * \since This function is available since SDL 2.0.5.
  *
- *  \sa SDL_RenderSetIntegerScale()
+ * \sa SDL_RenderSetIntegerScale
  */
 extern DECLSPEC SDL_bool SDLCALL SDL_RenderGetIntegerScale(SDL_Renderer * renderer);
 
 /**
- *  \brief Set the drawing area for rendering on the current target.
+ * Set the drawing area for rendering on the current target.
  *
- *  \param renderer The renderer for which the drawing area should be set.
- *  \param rect The rectangle representing the drawing area, or NULL to set the viewport to the entire target.
+ * When the window is resized, the viewport is reset to fill the entire new
+ * window size.
  *
- *  The x,y of the viewport rect represents the origin for rendering.
+ * \param renderer the rendering context
+ * \param rect the SDL_Rect structure representing the drawing area, or NULL
+ *             to set the viewport to the entire target
+ * \returns 0 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
  *
- *  \return 0 on success, or -1 on error
+ * \since This function is available since SDL 2.0.0.
  *
- *  \note If the window associated with the renderer is resized, the viewport is automatically reset.
- *
- *  \sa SDL_RenderGetViewport()
- *  \sa SDL_RenderSetLogicalSize()
+ * \sa SDL_RenderGetViewport
  */
 extern DECLSPEC int SDLCALL SDL_RenderSetViewport(SDL_Renderer * renderer,
                                                   const SDL_Rect * rect);
 
 /**
- *  \brief Get the drawing area for the current target.
+ * Get the drawing area for the current target.
+ *
+ * \param renderer the rendering context
+ * \param rect an SDL_Rect structure filled in with the current drawing area
  *
- *  \sa SDL_RenderSetViewport()
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_RenderSetViewport
  */
 extern DECLSPEC void SDLCALL SDL_RenderGetViewport(SDL_Renderer * renderer,
                                                    SDL_Rect * rect);
 
 /**
- *  \brief Set the clip rectangle for the current target.
+ * Set the clip rectangle for rendering on the specified target.
  *
- *  \param renderer The renderer for which clip rectangle should be set.
- *  \param rect   A pointer to the rectangle to set as the clip rectangle,
- *                relative to the viewport, or NULL to disable clipping.
+ * \param renderer the rendering context for which clip rectangle should be
+ *                 set
+ * \param rect an SDL_Rect structure representing the clip area, relative to
+ *             the viewport, or NULL to disable clipping
+ * \returns 0 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
  *
- *  \return 0 on success, or -1 on error
+ * \since This function is available since SDL 2.0.0.
  *
- *  \sa SDL_RenderGetClipRect()
+ * \sa SDL_RenderGetClipRect
+ * \sa SDL_RenderIsClipEnabled
  */
 extern DECLSPEC int SDLCALL SDL_RenderSetClipRect(SDL_Renderer * renderer,
                                                   const SDL_Rect * rect);
 
 /**
- *  \brief Get the clip rectangle for the current target.
+ * Get the clip rectangle for the current target.
+ *
+ * \param renderer the rendering context from which clip rectangle should be
+ *                 queried
+ * \param rect an SDL_Rect structure filled in with the current clipping area
+ *             or an empty rectangle if clipping is disabled
  *
- *  \param renderer The renderer from which clip rectangle should be queried.
- *  \param rect   A pointer filled in with the current clip rectangle, or
- *                an empty rectangle if clipping is disabled.
+ * \since This function is available since SDL 2.0.0.
  *
- *  \sa SDL_RenderSetClipRect()
+ * \sa SDL_RenderIsClipEnabled
+ * \sa SDL_RenderSetClipRect
  */
 extern DECLSPEC void SDLCALL SDL_RenderGetClipRect(SDL_Renderer * renderer,
                                                    SDL_Rect * rect);
 
 /**
- *  \brief Get whether clipping is enabled on the given renderer.
+ * Get whether clipping is enabled on the given renderer.
+ *
+ * \param renderer the renderer from which clip state should be queried
+ * \returns SDL_TRUE if clipping is enabled or SDL_FALSE if not; call
+ *          SDL_GetError() for more information.
  *
- *  \param renderer The renderer from which clip state should be queried.
+ * \since This function is available since SDL 2.0.4.
  *
- *  \sa SDL_RenderGetClipRect()
+ * \sa SDL_RenderGetClipRect
+ * \sa SDL_RenderSetClipRect
  */
 extern DECLSPEC SDL_bool SDLCALL SDL_RenderIsClipEnabled(SDL_Renderer * renderer);
 
 
 /**
- *  \brief Set the drawing scale for rendering on the current target.
+ * Set the drawing scale for rendering on the current target.
  *
- *  \param renderer The renderer for which the drawing scale should be set.
- *  \param scaleX The horizontal scaling factor
- *  \param scaleY The vertical scaling factor
+ * The drawing coordinates are scaled by the x/y scaling factors before they
+ * are used by the renderer. This allows resolution independent drawing with a
+ * single coordinate system.
  *
- *  The drawing coordinates are scaled by the x/y scaling factors
- *  before they are used by the renderer.  This allows resolution
- *  independent drawing with a single coordinate system.
+ * If this results in scaling or subpixel drawing by the rendering backend, it
+ * will be handled using the appropriate quality hints. For best results use
+ * integer scaling factors.
  *
- *  \note If this results in scaling or subpixel drawing by the
- *        rendering backend, it will be handled using the appropriate
- *        quality hints.  For best results use integer scaling factors.
+ * \param renderer a rendering context
+ * \param scaleX the horizontal scaling factor
+ * \param scaleY the vertical scaling factor
+ * \returns 0 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
  *
- *  \sa SDL_RenderGetScale()
- *  \sa SDL_RenderSetLogicalSize()
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_RenderGetScale
+ * \sa SDL_RenderSetLogicalSize
  */
 extern DECLSPEC int SDLCALL SDL_RenderSetScale(SDL_Renderer * renderer,
                                                float scaleX, float scaleY);
 
 /**
- *  \brief Get the drawing scale for the current target.
+ * Get the drawing scale for the current target.
+ *
+ * \param renderer the renderer from which drawing scale should be queried
+ * \param scaleX a pointer filled in with the horizontal scaling factor
+ * \param scaleY a pointer filled in with the vertical scaling factor
  *
- *  \param renderer The renderer from which drawing scale should be queried.
- *  \param scaleX A pointer filled in with the horizontal scaling factor
- *  \param scaleY A pointer filled in with the vertical scaling factor
+ * \since This function is available since SDL 2.0.0.
  *
- *  \sa SDL_RenderSetScale()
+ * \sa SDL_RenderSetScale
  */
 extern DECLSPEC void SDLCALL SDL_RenderGetScale(SDL_Renderer * renderer,
                                                float *scaleX, float *scaleY);
 
 /**
- *  \brief Set the color used for drawing operations (Rect, Line and Clear).
- *
- *  \param renderer The renderer for which drawing color should be set.
- *  \param r The red value used to draw on the rendering target.
- *  \param g The green value used to draw on the rendering target.
- *  \param b The blue value used to draw on the rendering target.
- *  \param a The alpha value used to draw on the rendering target, usually
- *           ::SDL_ALPHA_OPAQUE (255).
- *
- *  \return 0 on success, or -1 on error
+ * Get logical coordinates of point in renderer when given real coordinates of
+ * point in window.
+ *
+ * Logical coordinates will differ from real coordinates when render is scaled
+ * and logical renderer size set
+ *
+ * \param renderer the renderer from which the logical coordinates should be
+ *                 calcualted
+ * \param windowX the real X coordinate in the window
+ * \param windowY the real Y coordinate in the window
+ * \param logicalX the pointer filled with the logical x coordinate
+ * \param logicalY the pointer filled with the logical y coordinate
+ *
+ * \since This function is available since SDL 2.0.18.
+ *
+ * \sa SDL_RenderGetScale
+ * \sa SDL_RenderSetScale
+ * \sa SDL_RenderGetLogicalSize
+ * \sa SDL_RenderSetLogicalSize
+ */
+extern DECLSPEC void SDLCALL SDL_RenderWindowToLogical(SDL_Renderer * renderer, 
+                                                            int windowX, int windowY, 
+                                                            float *logicalX, float *logicalY);
+                                                  
+                                                  /**
+ * Get real coordinates of point in window when given logical coordinates of point in renderer.
+ * Logical coordinates will differ from real coordinates when render is scaled and logical renderer size set
+ * 
+ * \param renderer the renderer from which the window coordinates should be calculated
+ * \param logicalX the logical x coordinate
+ * \param logicalY the logical y coordinate
+ * \param windowX the pointer filled with the real X coordinate in the window
+ * \param windowY the pointer filled with the real Y coordinate in the window
+ 
+ *  
+ * \since This function is available since SDL 2.0.18.
+ * 
+ * \sa SDL_RenderGetScale
+ * \sa SDL_RenderSetScale
+ * \sa SDL_RenderGetLogicalSize
+ * \sa SDL_RenderSetLogicalSize
+ */
+extern DECLSPEC void SDLCALL SDL_RenderLogicalToWindow(SDL_Renderer * renderer, 
+                                                            float logicalX, float logicalY,
+                                                            int *windowX, int *windowY);
+
+/**
+ * Set the color used for drawing operations (Rect, Line and Clear).
+ *
+ * Set the color for drawing or filling rectangles, lines, and points, and for
+ * SDL_RenderClear().
+ *
+ * \param renderer the rendering context
+ * \param r the red value used to draw on the rendering target
+ * \param g the green value used to draw on the rendering target
+ * \param b the blue value used to draw on the rendering target
+ * \param a the alpha value used to draw on the rendering target; usually
+ *          `SDL_ALPHA_OPAQUE` (255). Use SDL_SetRenderDrawBlendMode to
+ *          specify how the alpha channel is used
+ * \returns 0 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_GetRenderDrawColor
+ * \sa SDL_RenderClear
+ * \sa SDL_RenderDrawLine
+ * \sa SDL_RenderDrawLines
+ * \sa SDL_RenderDrawPoint
+ * \sa SDL_RenderDrawPoints
+ * \sa SDL_RenderDrawRect
+ * \sa SDL_RenderDrawRects
+ * \sa SDL_RenderFillRect
+ * \sa SDL_RenderFillRects
  */
 extern DECLSPEC int SDLCALL SDL_SetRenderDrawColor(SDL_Renderer * renderer,
                                            Uint8 r, Uint8 g, Uint8 b,
                                            Uint8 a);
 
 /**
- *  \brief Get the color used for drawing operations (Rect, Line and Clear).
+ * Get the color used for drawing operations (Rect, Line and Clear).
+ *
+ * \param renderer the rendering context
+ * \param r a pointer filled in with the red value used to draw on the
+ *          rendering target
+ * \param g a pointer filled in with the green value used to draw on the
+ *          rendering target
+ * \param b a pointer filled in with the blue value used to draw on the
+ *          rendering target
+ * \param a a pointer filled in with the alpha value used to draw on the
+ *          rendering target; usually `SDL_ALPHA_OPAQUE` (255)
+ * \returns 0 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
  *
- *  \param renderer The renderer from which drawing color should be queried.
- *  \param r A pointer to the red value used to draw on the rendering target.
- *  \param g A pointer to the green value used to draw on the rendering target.
- *  \param b A pointer to the blue value used to draw on the rendering target.
- *  \param a A pointer to the alpha value used to draw on the rendering target,
- *           usually ::SDL_ALPHA_OPAQUE (255).
+ * \since This function is available since SDL 2.0.0.
  *
- *  \return 0 on success, or -1 on error
+ * \sa SDL_SetRenderDrawColor
  */
 extern DECLSPEC int SDLCALL SDL_GetRenderDrawColor(SDL_Renderer * renderer,
                                            Uint8 * r, Uint8 * g, Uint8 * b,
                                            Uint8 * a);
 
 /**
- *  \brief Set the blend mode used for drawing operations (Fill and Line).
+ * Set the blend mode used for drawing operations (Fill and Line).
  *
- *  \param renderer The renderer for which blend mode should be set.
- *  \param blendMode ::SDL_BlendMode to use for blending.
+ * If the blend mode is not supported, the closest supported mode is chosen.
  *
- *  \return 0 on success, or -1 on error
+ * \param renderer the rendering context
+ * \param blendMode the SDL_BlendMode to use for blending
+ * \returns 0 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
  *
- *  \note If the blend mode is not supported, the closest supported mode is
- *        chosen.
+ * \since This function is available since SDL 2.0.0.
  *
- *  \sa SDL_GetRenderDrawBlendMode()
+ * \sa SDL_GetRenderDrawBlendMode
+ * \sa SDL_RenderDrawLine
+ * \sa SDL_RenderDrawLines
+ * \sa SDL_RenderDrawPoint
+ * \sa SDL_RenderDrawPoints
+ * \sa SDL_RenderDrawRect
+ * \sa SDL_RenderDrawRects
+ * \sa SDL_RenderFillRect
+ * \sa SDL_RenderFillRects
  */
 extern DECLSPEC int SDLCALL SDL_SetRenderDrawBlendMode(SDL_Renderer * renderer,
                                                        SDL_BlendMode blendMode);
 
 /**
- *  \brief Get the blend mode used for drawing operations.
+ * Get the blend mode used for drawing operations.
  *
- *  \param renderer The renderer from which blend mode should be queried.
- *  \param blendMode A pointer filled in with the current blend mode.
+ * \param renderer the rendering context
+ * \param blendMode a pointer filled in with the current SDL_BlendMode
+ * \returns 0 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
  *
- *  \return 0 on success, or -1 on error
+ * \since This function is available since SDL 2.0.0.
  *
- *  \sa SDL_SetRenderDrawBlendMode()
+ * \sa SDL_SetRenderDrawBlendMode
  */
 extern DECLSPEC int SDLCALL SDL_GetRenderDrawBlendMode(SDL_Renderer * renderer,
                                                        SDL_BlendMode *blendMode);
 
 /**
- *  \brief Clear the current rendering target with the drawing color
+ * Clear the current rendering target with the drawing color.
+ *
+ * This function clears the entire rendering target, ignoring the viewport and
+ * the clip rectangle.
+ *
+ * \param renderer the rendering context
+ * \returns 0 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
  *
- *  This function clears the entire rendering target, ignoring the viewport and
- *  the clip rectangle.
+ * \since This function is available since SDL 2.0.0.
  *
- *  \return 0 on success, or -1 on error
+ * \sa SDL_SetRenderDrawColor
  */
 extern DECLSPEC int SDLCALL SDL_RenderClear(SDL_Renderer * renderer);
 
 /**
- *  \brief Draw a point on the current rendering target.
+ * Draw a point on the current rendering target.
  *
- *  \param renderer The renderer which should draw a point.
- *  \param x The x coordinate of the point.
- *  \param y The y coordinate of the point.
+ * SDL_RenderDrawPoint() draws a single point. If you want to draw multiple,
+ * use SDL_RenderDrawPoints() instead.
  *
- *  \return 0 on success, or -1 on error
+ * \param renderer the rendering context
+ * \param x the x coordinate of the point
+ * \param y the y coordinate of the point
+ * \returns 0 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_RenderDrawLine
+ * \sa SDL_RenderDrawLines
+ * \sa SDL_RenderDrawPoints
+ * \sa SDL_RenderDrawRect
+ * \sa SDL_RenderDrawRects
+ * \sa SDL_RenderFillRect
+ * \sa SDL_RenderFillRects
+ * \sa SDL_RenderPresent
+ * \sa SDL_SetRenderDrawBlendMode
+ * \sa SDL_SetRenderDrawColor
  */
 extern DECLSPEC int SDLCALL SDL_RenderDrawPoint(SDL_Renderer * renderer,
                                                 int x, int y);
 
 /**
- *  \brief Draw multiple points on the current rendering target.
+ * Draw multiple points on the current rendering target.
+ *
+ * \param renderer the rendering context
+ * \param points an array of SDL_Point structures that represent the points to
+ *               draw
+ * \param count the number of points to draw
+ * \returns 0 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
  *
- *  \param renderer The renderer which should draw multiple points.
- *  \param points The points to draw
- *  \param count The number of points to draw
+ * \since This function is available since SDL 2.0.0.
  *
- *  \return 0 on success, or -1 on error
+ * \sa SDL_RenderDrawLine
+ * \sa SDL_RenderDrawLines
+ * \sa SDL_RenderDrawPoint
+ * \sa SDL_RenderDrawRect
+ * \sa SDL_RenderDrawRects
+ * \sa SDL_RenderFillRect
+ * \sa SDL_RenderFillRects
+ * \sa SDL_RenderPresent
+ * \sa SDL_SetRenderDrawBlendMode
+ * \sa SDL_SetRenderDrawColor
  */
 extern DECLSPEC int SDLCALL SDL_RenderDrawPoints(SDL_Renderer * renderer,
                                                  const SDL_Point * points,
                                                  int count);
 
 /**
- *  \brief Draw a line on the current rendering target.
+ * Draw a line on the current rendering target.
+ *
+ * SDL_RenderDrawLine() draws the line to include both end points. If you want
+ * to draw multiple, connecting lines use SDL_RenderDrawLines() instead.
+ *
+ * \param renderer the rendering context
+ * \param x1 the x coordinate of the start point
+ * \param y1 the y coordinate of the start point
+ * \param x2 the x coordinate of the end point
+ * \param y2 the y coordinate of the end point
+ * \returns 0 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
  *
- *  \param renderer The renderer which should draw a line.
- *  \param x1 The x coordinate of the start point.
- *  \param y1 The y coordinate of the start point.
- *  \param x2 The x coordinate of the end point.
- *  \param y2 The y coordinate of the end point.
+ * \since This function is available since SDL 2.0.0.
  *
- *  \return 0 on success, or -1 on error
+ * \sa SDL_RenderDrawLines
+ * \sa SDL_RenderDrawPoint
+ * \sa SDL_RenderDrawPoints
+ * \sa SDL_RenderDrawRect
+ * \sa SDL_RenderDrawRects
+ * \sa SDL_RenderFillRect
+ * \sa SDL_RenderFillRects
+ * \sa SDL_RenderPresent
+ * \sa SDL_SetRenderDrawBlendMode
+ * \sa SDL_SetRenderDrawColor
  */
 extern DECLSPEC int SDLCALL SDL_RenderDrawLine(SDL_Renderer * renderer,
                                                int x1, int y1, int x2, int y2);
 
 /**
- *  \brief Draw a series of connected lines on the current rendering target.
+ * Draw a series of connected lines on the current rendering target.
  *
- *  \param renderer The renderer which should draw multiple lines.
- *  \param points The points along the lines
- *  \param count The number of points, drawing count-1 lines
+ * \param renderer the rendering context
+ * \param points an array of SDL_Point structures representing points along
+ *               the lines
+ * \param count the number of points, drawing count-1 lines
+ * \returns 0 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
  *
- *  \return 0 on success, or -1 on error
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_RenderDrawLine
+ * \sa SDL_RenderDrawPoint
+ * \sa SDL_RenderDrawPoints
+ * \sa SDL_RenderDrawRect
+ * \sa SDL_RenderDrawRects
+ * \sa SDL_RenderFillRect
+ * \sa SDL_RenderFillRects
+ * \sa SDL_RenderPresent
+ * \sa SDL_SetRenderDrawBlendMode
+ * \sa SDL_SetRenderDrawColor
  */
 extern DECLSPEC int SDLCALL SDL_RenderDrawLines(SDL_Renderer * renderer,
                                                 const SDL_Point * points,
                                                 int count);
 
 /**
- *  \brief Draw a rectangle on the current rendering target.
+ * Draw a rectangle on the current rendering target.
+ *
+ * \param renderer the rendering context
+ * \param rect an SDL_Rect structure representing the rectangle to draw, or
+ *             NULL to outline the entire rendering target
+ * \returns 0 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
  *
- *  \param renderer The renderer which should draw a rectangle.
- *  \param rect A pointer to the destination rectangle, or NULL to outline the entire rendering target.
+ * \since This function is available since SDL 2.0.0.
  *
- *  \return 0 on success, or -1 on error
+ * \sa SDL_RenderDrawLine
+ * \sa SDL_RenderDrawLines
+ * \sa SDL_RenderDrawPoint
+ * \sa SDL_RenderDrawPoints
+ * \sa SDL_RenderDrawRects
+ * \sa SDL_RenderFillRect
+ * \sa SDL_RenderFillRects
+ * \sa SDL_RenderPresent
+ * \sa SDL_SetRenderDrawBlendMode
+ * \sa SDL_SetRenderDrawColor
  */
 extern DECLSPEC int SDLCALL SDL_RenderDrawRect(SDL_Renderer * renderer,
                                                const SDL_Rect * rect);
 
 /**
- *  \brief Draw some number of rectangles on the current rendering target.
+ * Draw some number of rectangles on the current rendering target.
  *
- *  \param renderer The renderer which should draw multiple rectangles.
- *  \param rects A pointer to an array of destination rectangles.
- *  \param count The number of rectangles.
+ * \param renderer the rendering context
+ * \param rects an array of SDL_Rect structures representing the rectangles to
+ *              be drawn
+ * \param count the number of rectangles
+ * \returns 0 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
  *
- *  \return 0 on success, or -1 on error
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_RenderDrawLine
+ * \sa SDL_RenderDrawLines
+ * \sa SDL_RenderDrawPoint
+ * \sa SDL_RenderDrawPoints
+ * \sa SDL_RenderDrawRect
+ * \sa SDL_RenderFillRect
+ * \sa SDL_RenderFillRects
+ * \sa SDL_RenderPresent
+ * \sa SDL_SetRenderDrawBlendMode
+ * \sa SDL_SetRenderDrawColor
  */
 extern DECLSPEC int SDLCALL SDL_RenderDrawRects(SDL_Renderer * renderer,
                                                 const SDL_Rect * rects,
                                                 int count);
 
 /**
- *  \brief Fill a rectangle on the current rendering target with the drawing color.
+ * Fill a rectangle on the current rendering target with the drawing color.
+ *
+ * The current drawing color is set by SDL_SetRenderDrawColor(), and the
+ * color's alpha value is ignored unless blending is enabled with the
+ * appropriate call to SDL_SetRenderDrawBlendMode().
  *
- *  \param renderer The renderer which should fill a rectangle.
- *  \param rect A pointer to the destination rectangle, or NULL for the entire
- *              rendering target.
+ * \param renderer the rendering context
+ * \param rect the SDL_Rect structure representing the rectangle to fill, or
+ *             NULL for the entire rendering target
+ * \returns 0 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
  *
- *  \return 0 on success, or -1 on error
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_RenderDrawLine
+ * \sa SDL_RenderDrawLines
+ * \sa SDL_RenderDrawPoint
+ * \sa SDL_RenderDrawPoints
+ * \sa SDL_RenderDrawRect
+ * \sa SDL_RenderDrawRects
+ * \sa SDL_RenderFillRects
+ * \sa SDL_RenderPresent
+ * \sa SDL_SetRenderDrawBlendMode
+ * \sa SDL_SetRenderDrawColor
  */
 extern DECLSPEC int SDLCALL SDL_RenderFillRect(SDL_Renderer * renderer,
                                                const SDL_Rect * rect);
 
 /**
- *  \brief Fill some number of rectangles on the current rendering target with the drawing color.
+ * Fill some number of rectangles on the current rendering target with the
+ * drawing color.
+ *
+ * \param renderer the rendering context
+ * \param rects an array of SDL_Rect structures representing the rectangles to
+ *              be filled
+ * \param count the number of rectangles
+ * \returns 0 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
  *
- *  \param renderer The renderer which should fill multiple rectangles.
- *  \param rects A pointer to an array of destination rectangles.
- *  \param count The number of rectangles.
+ * \since This function is available since SDL 2.0.0.
  *
- *  \return 0 on success, or -1 on error
+ * \sa SDL_RenderDrawLine
+ * \sa SDL_RenderDrawLines
+ * \sa SDL_RenderDrawPoint
+ * \sa SDL_RenderDrawPoints
+ * \sa SDL_RenderDrawRect
+ * \sa SDL_RenderDrawRects
+ * \sa SDL_RenderFillRect
+ * \sa SDL_RenderPresent
  */
 extern DECLSPEC int SDLCALL SDL_RenderFillRects(SDL_Renderer * renderer,
                                                 const SDL_Rect * rects,
                                                 int count);
 
 /**
- *  \brief Copy a portion of the texture to the current rendering target.
+ * Copy a portion of the texture to the current rendering target.
+ *
+ * The texture is blended with the destination based on its blend mode set
+ * with SDL_SetTextureBlendMode().
+ *
+ * The texture color is affected based on its color modulation set by
+ * SDL_SetTextureColorMod().
+ *
+ * The texture alpha is affected based on its alpha modulation set by
+ * SDL_SetTextureAlphaMod().
  *
- *  \param renderer The renderer which should copy parts of a texture.
- *  \param texture The source texture.
- *  \param srcrect   A pointer to the source rectangle, or NULL for the entire
- *                   texture.
- *  \param dstrect   A pointer to the destination rectangle, or NULL for the
- *                   entire rendering target.
+ * \param renderer the rendering context
+ * \param texture the source texture
+ * \param srcrect the source SDL_Rect structure or NULL for the entire texture
+ * \param dstrect the destination SDL_Rect structure or NULL for the entire
+ *                rendering target; the texture will be stretched to fill the
+ *                given rectangle
+ * \returns 0 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
  *
- *  \return 0 on success, or -1 on error
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_RenderCopyEx
+ * \sa SDL_SetTextureAlphaMod
+ * \sa SDL_SetTextureBlendMode
+ * \sa SDL_SetTextureColorMod
  */
 extern DECLSPEC int SDLCALL SDL_RenderCopy(SDL_Renderer * renderer,
                                            SDL_Texture * texture,
@@ -873,19 +1389,43 @@ extern DECLSPEC int SDLCALL SDL_RenderCopy(SDL_Renderer * renderer,
                                            const SDL_Rect * dstrect);
 
 /**
- *  \brief Copy a portion of the source texture to the current rendering target, rotating it by angle around the given center
+ * Copy a portion of the texture to the current rendering, with optional
+ * rotation and flipping.
+ *
+ * Copy a portion of the texture to the current rendering target, optionally
+ * rotating it by angle around the given center and also flipping it
+ * top-bottom and/or left-right.
+ *
+ * The texture is blended with the destination based on its blend mode set
+ * with SDL_SetTextureBlendMode().
+ *
+ * The texture color is affected based on its color modulation set by
+ * SDL_SetTextureColorMod().
+ *
+ * The texture alpha is affected based on its alpha modulation set by
+ * SDL_SetTextureAlphaMod().
  *
- *  \param renderer The renderer which should copy parts of a texture.
- *  \param texture The source texture.
- *  \param srcrect   A pointer to the source rectangle, or NULL for the entire
- *                   texture.
- *  \param dstrect   A pointer to the destination rectangle, or NULL for the
- *                   entire rendering target.
- *  \param angle    An angle in degrees that indicates the rotation that will be applied to dstrect, rotating it in a clockwise direction
- *  \param center   A pointer to a point indicating the point around which dstrect will be rotated (if NULL, rotation will be done around dstrect.w/2, dstrect.h/2).
- *  \param flip     An SDL_RendererFlip value stating which flipping actions should be performed on the texture
+ * \param renderer the rendering context
+ * \param texture the source texture
+ * \param srcrect the source SDL_Rect structure or NULL for the entire texture
+ * \param dstrect the destination SDL_Rect structure or NULL for the entire
+ *                rendering target
+ * \param angle an angle in degrees that indicates the rotation that will be
+ *              applied to dstrect, rotating it in a clockwise direction
+ * \param center a pointer to a point indicating the point around which
+ *               dstrect will be rotated (if NULL, rotation will be done
+ *               around `dstrect.w / 2`, `dstrect.h / 2`)
+ * \param flip a SDL_RendererFlip value stating which flipping actions should
+ *             be performed on the texture
+ * \returns 0 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
  *
- *  \return 0 on success, or -1 on error
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_RenderCopy
+ * \sa SDL_SetTextureAlphaMod
+ * \sa SDL_SetTextureBlendMode
+ * \sa SDL_SetTextureColorMod
  */
 extern DECLSPEC int SDLCALL SDL_RenderCopyEx(SDL_Renderer * renderer,
                                            SDL_Texture * texture,
@@ -897,117 +1437,132 @@ extern DECLSPEC int SDLCALL SDL_RenderCopyEx(SDL_Renderer * renderer,
 
 
 /**
- *  \brief Draw a point on the current rendering target.
+ * Draw a point on the current rendering target at subpixel precision.
  *
- *  \param renderer The renderer which should draw a point.
- *  \param x The x coordinate of the point.
- *  \param y The y coordinate of the point.
+ * \param renderer The renderer which should draw a point.
+ * \param x The x coordinate of the point.
+ * \param y The y coordinate of the point.
+ * \return 0 on success, or -1 on error
  *
- *  \return 0 on success, or -1 on error
+ * \since This function is available since SDL 2.0.10.
  */
 extern DECLSPEC int SDLCALL SDL_RenderDrawPointF(SDL_Renderer * renderer,
                                                  float x, float y);
 
 /**
- *  \brief Draw multiple points on the current rendering target.
+ * Draw multiple points on the current rendering target at subpixel precision.
  *
- *  \param renderer The renderer which should draw multiple points.
- *  \param points The points to draw
- *  \param count The number of points to draw
+ * \param renderer The renderer which should draw multiple points.
+ * \param points The points to draw
+ * \param count The number of points to draw
+ * \return 0 on success, or -1 on error
  *
- *  \return 0 on success, or -1 on error
+ * \since This function is available since SDL 2.0.10.
  */
 extern DECLSPEC int SDLCALL SDL_RenderDrawPointsF(SDL_Renderer * renderer,
                                                   const SDL_FPoint * points,
                                                   int count);
 
 /**
- *  \brief Draw a line on the current rendering target.
+ * Draw a line on the current rendering target at subpixel precision.
  *
- *  \param renderer The renderer which should draw a line.
- *  \param x1 The x coordinate of the start point.
- *  \param y1 The y coordinate of the start point.
- *  \param x2 The x coordinate of the end point.
- *  \param y2 The y coordinate of the end point.
+ * \param renderer The renderer which should draw a line.
+ * \param x1 The x coordinate of the start point.
+ * \param y1 The y coordinate of the start point.
+ * \param x2 The x coordinate of the end point.
+ * \param y2 The y coordinate of the end point.
+ * \return 0 on success, or -1 on error
  *
- *  \return 0 on success, or -1 on error
+ * \since This function is available since SDL 2.0.10.
  */
 extern DECLSPEC int SDLCALL SDL_RenderDrawLineF(SDL_Renderer * renderer,
                                                 float x1, float y1, float x2, float y2);
 
 /**
- *  \brief Draw a series of connected lines on the current rendering target.
+ * Draw a series of connected lines on the current rendering target at
+ * subpixel precision.
  *
- *  \param renderer The renderer which should draw multiple lines.
- *  \param points The points along the lines
- *  \param count The number of points, drawing count-1 lines
+ * \param renderer The renderer which should draw multiple lines.
+ * \param points The points along the lines
+ * \param count The number of points, drawing count-1 lines
+ * \return 0 on success, or -1 on error
  *
- *  \return 0 on success, or -1 on error
+ * \since This function is available since SDL 2.0.10.
  */
 extern DECLSPEC int SDLCALL SDL_RenderDrawLinesF(SDL_Renderer * renderer,
-                                                const SDL_FPoint * points,
-                                                int count);
+                                                 const SDL_FPoint * points,
+                                                 int count);
 
 /**
- *  \brief Draw a rectangle on the current rendering target.
+ * Draw a rectangle on the current rendering target at subpixel precision.
  *
- *  \param renderer The renderer which should draw a rectangle.
- *  \param rect A pointer to the destination rectangle, or NULL to outline the entire rendering target.
+ * \param renderer The renderer which should draw a rectangle.
+ * \param rect A pointer to the destination rectangle, or NULL to outline the
+ *             entire rendering target.
+ * \return 0 on success, or -1 on error
  *
- *  \return 0 on success, or -1 on error
+ * \since This function is available since SDL 2.0.10.
  */
 extern DECLSPEC int SDLCALL SDL_RenderDrawRectF(SDL_Renderer * renderer,
-                                               const SDL_FRect * rect);
+                                                const SDL_FRect * rect);
 
 /**
- *  \brief Draw some number of rectangles on the current rendering target.
+ * Draw some number of rectangles on the current rendering target at subpixel
+ * precision.
  *
- *  \param renderer The renderer which should draw multiple rectangles.
- *  \param rects A pointer to an array of destination rectangles.
- *  \param count The number of rectangles.
+ * \param renderer The renderer which should draw multiple rectangles.
+ * \param rects A pointer to an array of destination rectangles.
+ * \param count The number of rectangles.
+ * \return 0 on success, or -1 on error
  *
- *  \return 0 on success, or -1 on error
+ * \since This function is available since SDL 2.0.10.
  */
 extern DECLSPEC int SDLCALL SDL_RenderDrawRectsF(SDL_Renderer * renderer,
                                                  const SDL_FRect * rects,
                                                  int count);
 
 /**
- *  \brief Fill a rectangle on the current rendering target with the drawing color.
+ * Fill a rectangle on the current rendering target with the drawing color at
+ * subpixel precision.
  *
- *  \param renderer The renderer which should fill a rectangle.
- *  \param rect A pointer to the destination rectangle, or NULL for the entire
- *              rendering target.
+ * \param renderer The renderer which should fill a rectangle.
+ * \param rect A pointer to the destination rectangle, or NULL for the entire
+ *             rendering target.
+ * \return 0 on success, or -1 on error
  *
- *  \return 0 on success, or -1 on error
+ * \since This function is available since SDL 2.0.10.
  */
 extern DECLSPEC int SDLCALL SDL_RenderFillRectF(SDL_Renderer * renderer,
                                                 const SDL_FRect * rect);
 
 /**
- *  \brief Fill some number of rectangles on the current rendering target with the drawing color.
+ * Fill some number of rectangles on the current rendering target with the
+ * drawing color at subpixel precision.
  *
- *  \param renderer The renderer which should fill multiple rectangles.
- *  \param rects A pointer to an array of destination rectangles.
- *  \param count The number of rectangles.
+ * \param renderer The renderer which should fill multiple rectangles.
+ * \param rects A pointer to an array of destination rectangles.
+ * \param count The number of rectangles.
+ * \return 0 on success, or -1 on error
  *
- *  \return 0 on success, or -1 on error
+ * \since This function is available since SDL 2.0.10.
  */
 extern DECLSPEC int SDLCALL SDL_RenderFillRectsF(SDL_Renderer * renderer,
                                                  const SDL_FRect * rects,
                                                  int count);
 
 /**
- *  \brief Copy a portion of the texture to the current rendering target.
+ * Copy a portion of the texture to the current rendering target at subpixel
+ * precision.
  *
- *  \param renderer The renderer which should copy parts of a texture.
- *  \param texture The source texture.
- *  \param srcrect   A pointer to the source rectangle, or NULL for the entire
- *                   texture.
- *  \param dstrect   A pointer to the destination rectangle, or NULL for the
- *                   entire rendering target.
+ * \param renderer The renderer which should copy parts of a texture.
+ * \param texture The source texture.
+ * \param srcrect A pointer to the source rectangle, or NULL for the entire
+ *                texture.
+ * \param dstrect A pointer to the destination rectangle, or NULL for the
+ *                entire rendering target.
+ * \return 0 on success, or -1 on error
  *
- *  \return 0 on success, or -1 on error
+ * \since This function is available since SDL 2.0.10.
  */
 extern DECLSPEC int SDLCALL SDL_RenderCopyF(SDL_Renderer * renderer,
                                             SDL_Texture * texture,
@@ -1015,19 +1570,25 @@ extern DECLSPEC int SDLCALL SDL_RenderCopyF(SDL_Renderer * renderer,
                                             const SDL_FRect * dstrect);
 
 /**
- *  \brief Copy a portion of the source texture to the current rendering target, rotating it by angle around the given center
- *
- *  \param renderer The renderer which should copy parts of a texture.
- *  \param texture The source texture.
- *  \param srcrect   A pointer to the source rectangle, or NULL for the entire
- *                   texture.
- *  \param dstrect   A pointer to the destination rectangle, or NULL for the
- *                   entire rendering target.
- *  \param angle    An angle in degrees that indicates the rotation that will be applied to dstrect, rotating it in a clockwise direction
- *  \param center   A pointer to a point indicating the point around which dstrect will be rotated (if NULL, rotation will be done around dstrect.w/2, dstrect.h/2).
- *  \param flip     An SDL_RendererFlip value stating which flipping actions should be performed on the texture
+ * Copy a portion of the source texture to the current rendering target, with
+ * rotation and flipping, at subpixel precision.
+ *
+ * \param renderer The renderer which should copy parts of a texture.
+ * \param texture The source texture.
+ * \param srcrect A pointer to the source rectangle, or NULL for the entire
+ *                texture.
+ * \param dstrect A pointer to the destination rectangle, or NULL for the
+ *                entire rendering target.
+ * \param angle An angle in degrees that indicates the rotation that will be
+ *              applied to dstrect, rotating it in a clockwise direction
+ * \param center A pointer to a point indicating the point around which
+ *               dstrect will be rotated (if NULL, rotation will be done
+ *               around dstrect.w/2, dstrect.h/2).
+ * \param flip An SDL_RendererFlip value stating which flipping actions should
+ *             be performed on the texture
+ * \return 0 on success, or -1 on error
  *
- *  \return 0 on success, or -1 on error
+ * \since This function is available since SDL 2.0.10.
  */
 extern DECLSPEC int SDLCALL SDL_RenderCopyExF(SDL_Renderer * renderer,
                                             SDL_Texture * texture,
@@ -1038,19 +1599,85 @@ extern DECLSPEC int SDLCALL SDL_RenderCopyExF(SDL_Renderer * renderer,
                                             const SDL_RendererFlip flip);
 
 /**
- *  \brief Read pixels from the current rendering target.
- *
- *  \param renderer The renderer from which pixels should be read.
- *  \param rect   A pointer to the rectangle to read, or NULL for the entire
- *                render target.
- *  \param format The desired format of the pixel data, or 0 to use the format
- *                of the rendering target
- *  \param pixels A pointer to be filled in with the pixel data
- *  \param pitch  The pitch of the pixels parameter.
- *
- *  \return 0 on success, or -1 if pixel reading is not supported.
- *
- *  \warning This is a very slow operation, and should not be used frequently.
+ * Render a list of triangles, optionally using a texture and indices into the
+ * vertex array Color and alpha modulation is done per vertex
+ * (SDL_SetTextureColorMod and SDL_SetTextureAlphaMod are ignored).
+ *
+ * \param texture (optional) The SDL texture to use.
+ * \param vertices Vertices.
+ * \param num_vertices Number of vertices.
+ * \param indices (optional) An array of integer indices into the 'vertices'
+ *                array, if NULL all vertices will be rendered in sequential
+ *                order.
+ * \param num_indices Number of indices.
+ * \return 0 on success, or -1 if the operation is not supported
+ *
+ * \since This function is available since SDL 2.0.18.
+ *
+ * \sa SDL_RenderGeometryRaw
+ * \sa SDL_Vertex
+ */
+extern DECLSPEC int SDLCALL SDL_RenderGeometry(SDL_Renderer *renderer,
+                                               SDL_Texture *texture,
+                                               const SDL_Vertex *vertices, int num_vertices,
+                                               const int *indices, int num_indices);
+
+/**
+ * Render a list of triangles, optionally using a texture and indices into the
+ * vertex arrays Color and alpha modulation is done per vertex
+ * (SDL_SetTextureColorMod and SDL_SetTextureAlphaMod are ignored).
+ *
+ * \param texture (optional) The SDL texture to use.
+ * \param xy Vertex positions
+ * \param xy_stride Byte size to move from one element to the next element
+ * \param color Vertex colors (as SDL_Color)
+ * \param color_stride Byte size to move from one element to the next element
+ * \param uv Vertex normalized texture coordinates
+ * \param uv_stride Byte size to move from one element to the next element
+ * \param num_vertices Number of vertices.
+ * \param indices (optional) An array of indices into the 'vertices' arrays,
+ *                if NULL all vertices will be rendered in sequential order.
+ * \param num_indices Number of indices.
+ * \param size_indices Index size: 1 (byte), 2 (short), 4 (int)
+ * \return 0 on success, or -1 if the operation is not supported
+ *
+ * \since This function is available since SDL 2.0.18.
+ *
+ * \sa SDL_RenderGeometry
+ * \sa SDL_Vertex
+ */
+extern DECLSPEC int SDLCALL SDL_RenderGeometryRaw(SDL_Renderer *renderer,
+                                               SDL_Texture *texture,
+                                               const float *xy, int xy_stride,
+                                               const SDL_Color *color, int color_stride,
+                                               const float *uv, int uv_stride,
+                                               int num_vertices,
+                                               const void *indices, int num_indices, int size_indices);
+
+/**
+ * Read pixels from the current rendering target to an array of pixels.
+ *
+ * **WARNING**: This is a very slow operation, and should not be used
+ * frequently.
+ *
+ * `pitch` specifies the number of bytes between rows in the destination
+ * `pixels` data. This allows you to write to a subrectangle or have padded
+ * rows in the destination. Generally, `pitch` should equal the number of
+ * pixels per row in the `pixels` data times the number of bytes per pixel,
+ * but it might contain additional padding (for example, 24bit RGB Windows
+ * Bitmap data pads all rows to multiples of 4 bytes).
+ *
+ * \param renderer the rendering context
+ * \param rect an SDL_Rect structure representing the area to read, or NULL
+ *             for the entire render target
+ * \param format an SDL_PixelFormatEnum value of the desired format of the
+ *               pixel data, or 0 to use the format of the rendering target
+ * \param pixels a pointer to the pixel data to copy into
+ * \param pitch the pitch of the `pixels` parameter
+ * \returns 0 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.0.
  */
 extern DECLSPEC int SDLCALL SDL_RenderReadPixels(SDL_Renderer * renderer,
                                                  const SDL_Rect * rect,
@@ -1058,95 +1685,200 @@ extern DECLSPEC int SDLCALL SDL_RenderReadPixels(SDL_Renderer * renderer,
                                                  void *pixels, int pitch);
 
 /**
- *  \brief Update the screen with rendering performed.
+ * Update the screen with any rendering performed since the previous call.
+ *
+ * SDL's rendering functions operate on a backbuffer; that is, calling a
+ * rendering function such as SDL_RenderDrawLine() does not directly put a
+ * line on the screen, but rather updates the backbuffer. As such, you compose
+ * your entire scene and *present* the composed backbuffer to the screen as a
+ * complete picture.
+ *
+ * Therefore, when using SDL's rendering API, one does all drawing intended
+ * for the frame, and then calls this function once per frame to present the
+ * final drawing to the user.
+ *
+ * The backbuffer should be considered invalidated after each present; do not
+ * assume that previous contents will exist between frames. You are strongly
+ * encouraged to call SDL_RenderClear() to initialize the backbuffer before
+ * starting each new frame's drawing, even if you plan to overwrite every
+ * pixel.
+ *
+ * \param renderer the rendering context
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_RenderClear
+ * \sa SDL_RenderDrawLine
+ * \sa SDL_RenderDrawLines
+ * \sa SDL_RenderDrawPoint
+ * \sa SDL_RenderDrawPoints
+ * \sa SDL_RenderDrawRect
+ * \sa SDL_RenderDrawRects
+ * \sa SDL_RenderFillRect
+ * \sa SDL_RenderFillRects
+ * \sa SDL_SetRenderDrawBlendMode
+ * \sa SDL_SetRenderDrawColor
  */
 extern DECLSPEC void SDLCALL SDL_RenderPresent(SDL_Renderer * renderer);
 
 /**
- *  \brief Destroy the specified texture.
+ * Destroy the specified texture.
  *
- *  \sa SDL_CreateTexture()
- *  \sa SDL_CreateTextureFromSurface()
+ * Passing NULL or an otherwise invalid texture will set the SDL error message
+ * to "Invalid texture".
+ *
+ * \param texture the texture to destroy
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_CreateTexture
+ * \sa SDL_CreateTextureFromSurface
  */
 extern DECLSPEC void SDLCALL SDL_DestroyTexture(SDL_Texture * texture);
 
 /**
- *  \brief Destroy the rendering context for a window and free associated
- *         textures.
+ * Destroy the rendering context for a window and free associated textures.
+ *
+ * \param renderer the rendering context
  *
- *  \sa SDL_CreateRenderer()
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_CreateRenderer
  */
 extern DECLSPEC void SDLCALL SDL_DestroyRenderer(SDL_Renderer * renderer);
 
 /**
- *  \brief Force the rendering context to flush any pending commands to the
- *         underlying rendering API.
+ * Force the rendering context to flush any pending commands to the underlying
+ * rendering API.
+ *
+ * You do not need to (and in fact, shouldn't) call this function unless you
+ * are planning to call into OpenGL/Direct3D/Metal/whatever directly in
+ * addition to using an SDL_Renderer.
+ *
+ * This is for a very-specific case: if you are using SDL's render API, you
+ * asked for a specific renderer backend (OpenGL, Direct3D, etc), you set
+ * SDL_HINT_RENDER_BATCHING to "1", and you plan to make OpenGL/D3D/whatever
+ * calls in addition to SDL render API calls. If all of this applies, you
+ * should call SDL_RenderFlush() between calls to SDL's render API and the
+ * low-level API you're using in cooperation.
  *
- *  You do not need to (and in fact, shouldn't) call this function unless
- *  you are planning to call into OpenGL/Direct3D/Metal/whatever directly
- *  in addition to using an SDL_Renderer.
+ * In all other cases, you can ignore this function. This is only here to get
+ * maximum performance out of a specific situation. In all other cases, SDL
+ * will do the right thing, perhaps at a performance loss.
  *
- *  This is for a very-specific case: if you are using SDL's render API,
- *  you asked for a specific renderer backend (OpenGL, Direct3D, etc),
- *  you set SDL_HINT_RENDER_BATCHING to "1", and you plan to make
- *  OpenGL/D3D/whatever calls in addition to SDL render API calls. If all of
- *  this applies, you should call SDL_RenderFlush() between calls to SDL's
- *  render API and the low-level API you're using in cooperation.
+ * This function is first available in SDL 2.0.10, and is not needed in 2.0.9
+ * and earlier, as earlier versions did not queue rendering commands at all,
+ * instead flushing them to the OS immediately.
  *
- *  In all other cases, you can ignore this function. This is only here to
- *  get maximum performance out of a specific situation. In all other cases,
- *  SDL will do the right thing, perhaps at a performance loss.
+ * \param renderer the rendering context
+ * \returns 0 on success or a negative error code on failure; call
+ *          SDL_GetError() for more information.
  *
- *  This function is first available in SDL 2.0.10, and is not needed in
- *  2.0.9 and earlier, as earlier versions did not queue rendering commands
- *  at all, instead flushing them to the OS immediately.
+ * \since This function is available since SDL 2.0.10.
  */
 extern DECLSPEC int SDLCALL SDL_RenderFlush(SDL_Renderer * renderer);
 
 
 /**
- *  \brief Bind the texture to the current OpenGL/ES/ES2 context for use with
- *         OpenGL instructions.
+ * Bind an OpenGL/ES/ES2 texture to the current context.
+ *
+ * This is for use with OpenGL instructions when rendering OpenGL primitives
+ * directly.
+ *
+ * If not NULL, `texw` and `texh` will be filled with the width and height
+ * values suitable for the provided texture. In most cases, both will be 1.0,
+ * however, on systems that support the GL_ARB_texture_rectangle extension,
+ * these values will actually be the pixel width and height used to create the
+ * texture, so this factor needs to be taken into account when providing
+ * texture coordinates to OpenGL.
  *
- *  \param texture  The SDL texture to bind
- *  \param texw     A pointer to a float that will be filled with the texture width
- *  \param texh     A pointer to a float that will be filled with the texture height
+ * You need a renderer to create an SDL_Texture, therefore you can only use
+ * this function with an implicit OpenGL context from SDL_CreateRenderer(),
+ * not with your own OpenGL context. If you need control over your OpenGL
+ * context, you need to write your own texture-loading methods.
  *
- *  \return 0 on success, or -1 if the operation is not supported
+ * Also note that SDL may upload RGB textures as BGR (or vice-versa), and
+ * re-order the color channels in the shaders phase, so the uploaded texture
+ * may have swapped color channels.
+ *
+ * \param texture the texture to bind to the current OpenGL/ES/ES2 context
+ * \param texw a pointer to a float value which will be filled with the
+ *             texture width or NULL if you don't need that value
+ * \param texh a pointer to a float value which will be filled with the
+ *             texture height or NULL if you don't need that value
+ * \returns 0 on success, or -1 if the operation is not supported; call
+ *          SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_GL_MakeCurrent
+ * \sa SDL_GL_UnbindTexture
  */
 extern DECLSPEC int SDLCALL SDL_GL_BindTexture(SDL_Texture *texture, float *texw, float *texh);
 
 /**
- *  \brief Unbind a texture from the current OpenGL/ES/ES2 context.
+ * Unbind an OpenGL/ES/ES2 texture from the current context.
+ *
+ * See SDL_GL_BindTexture() for examples on how to use these functions
  *
- *  \param texture  The SDL texture to unbind
+ * \param texture the texture to unbind from the current OpenGL/ES/ES2 context
+ * \returns 0 on success, or -1 if the operation is not supported
  *
- *  \return 0 on success, or -1 if the operation is not supported
+ * \since This function is available since SDL 2.0.0.
+ *
+ * \sa SDL_GL_BindTexture
+ * \sa SDL_GL_MakeCurrent
  */
 extern DECLSPEC int SDLCALL SDL_GL_UnbindTexture(SDL_Texture *texture);
 
 /**
- *  \brief Get the CAMetalLayer associated with the given Metal renderer
+ * Get the CAMetalLayer associated with the given Metal renderer.
+ *
+ * This function returns `void *`, so SDL doesn't have to include Metal's
+ * headers, but it can be safely cast to a `CAMetalLayer *`.
  *
- *  \param renderer The renderer to query
+ * \param renderer The renderer to query
+ * \returns a `CAMetalLayer *` on success, or NULL if the renderer isn't a
+ *          Metal renderer
  *
- *  \return CAMetalLayer* on success, or NULL if the renderer isn't a Metal renderer
+ * \since This function is available since SDL 2.0.8.
  *
- *  \sa SDL_RenderGetMetalCommandEncoder()
+ * \sa SDL_RenderGetMetalCommandEncoder
  */
 extern DECLSPEC void *SDLCALL SDL_RenderGetMetalLayer(SDL_Renderer * renderer);
 
 /**
- *  \brief Get the Metal command encoder for the current frame
+ * Get the Metal command encoder for the current frame
+ *
+ * This function returns `void *`, so SDL doesn't have to include Metal's
+ * headers, but it can be safely cast to an `id<MTLRenderCommandEncoder>`.
  *
- *  \param renderer The renderer to query
+ * Note that as of SDL 2.0.18, this will return NULL if Metal refuses to give
+ * SDL a drawable to render to, which might happen if the window is
+ * hidden/minimized/offscreen. This doesn't apply to command encoders for
+ * render targets, just the window's backbacker. Check your return values!
  *
- *  \return id<MTLRenderCommandEncoder> on success, or NULL if the renderer isn't a Metal renderer
+ * \param renderer The renderer to query
+ * \returns an `id<MTLRenderCommandEncoder>` on success, or NULL if the
+ *          renderer isn't a Metal renderer or there was an error.
  *
- *  \sa SDL_RenderGetMetalLayer()
+ * \since This function is available since SDL 2.0.8.
+ *
+ * \sa SDL_RenderGetMetalLayer
  */
 extern DECLSPEC void *SDLCALL SDL_RenderGetMetalCommandEncoder(SDL_Renderer * renderer);
 
+/**
+ * Toggle VSync of the given renderer.
+ *
+ * \param renderer The renderer to toggle
+ * \param vsync 1 for on, 0 for off. All other values are reserved
+ * \returns a 0 int on success, or non-zero on failure
+ *
+ * \since This function is available since SDL 2.0.18.
+ */
+extern DECLSPEC int SDLCALL SDL_RenderSetVSync(SDL_Renderer* renderer, int vsync);
+
 /* Ends C function definitions when using C++ */
 #ifdef __cplusplus
 }