mirror of https://github.com/encounter/SDL.git
1680 lines
63 KiB
C
1680 lines
63 KiB
C
/*
|
|
Simple DirectMedia Layer
|
|
Copyright (C) 1997-2021 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
|
|
arising from the use of this software.
|
|
|
|
Permission is granted to anyone to use this software for any purpose,
|
|
including commercial applications, and to alter it and redistribute it
|
|
freely, subject to the following restrictions:
|
|
|
|
1. The origin of this software must not be misrepresented; you must not
|
|
claim that you wrote the original software. If you use this software
|
|
in a product, an acknowledgment in the product documentation would be
|
|
appreciated but is not required.
|
|
2. Altered source versions must be plainly marked as such, and must not be
|
|
misrepresented as being the original software.
|
|
3. This notice may not be removed or altered from any source distribution.
|
|
*/
|
|
|
|
/**
|
|
* \file SDL_render.h
|
|
*
|
|
* Header file for SDL 2D rendering functions.
|
|
*
|
|
* This API supports the following features:
|
|
* * single pixel points
|
|
* * single pixel lines
|
|
* * filled rectangles
|
|
* * texture images
|
|
*
|
|
* The primitives may be drawn in opaque, blended, or additive modes.
|
|
*
|
|
* The texture images may be drawn in opaque, blended, or additive modes.
|
|
* They can have an additional color tint or alpha modulation applied to
|
|
* them, and may also be stretched with linear interpolation.
|
|
*
|
|
* This API is designed to accelerate simple 2D operations. You may
|
|
* want more functionality such as polygons and particle effects and
|
|
* in that case you should use SDL's OpenGL/Direct3D support or one
|
|
* of the many good 3D engines.
|
|
*
|
|
* These functions must be called from the main thread.
|
|
* See this bug for details: http://bugzilla.libsdl.org/show_bug.cgi?id=1995
|
|
*/
|
|
|
|
#ifndef SDL_render_h_
|
|
#define SDL_render_h_
|
|
|
|
#include "SDL_stdinc.h"
|
|
#include "SDL_rect.h"
|
|
#include "SDL_video.h"
|
|
|
|
#include "begin_code.h"
|
|
/* Set up for C function definitions, even when using C++ */
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
/**
|
|
* Flags used when creating a rendering context
|
|
*/
|
|
typedef enum
|
|
{
|
|
SDL_RENDERER_SOFTWARE = 0x00000001, /**< The renderer is a software fallback */
|
|
SDL_RENDERER_ACCELERATED = 0x00000002, /**< The renderer uses hardware
|
|
acceleration */
|
|
SDL_RENDERER_PRESENTVSYNC = 0x00000004, /**< Present is synchronized
|
|
with the refresh rate */
|
|
SDL_RENDERER_TARGETTEXTURE = 0x00000008 /**< The renderer supports
|
|
rendering to texture */
|
|
} SDL_RendererFlags;
|
|
|
|
/**
|
|
* Information on the capabilities of a render driver or context.
|
|
*/
|
|
typedef struct SDL_RendererInfo
|
|
{
|
|
const char *name; /**< The name of the renderer */
|
|
Uint32 flags; /**< Supported ::SDL_RendererFlags */
|
|
Uint32 num_texture_formats; /**< The number of available texture formats */
|
|
Uint32 texture_formats[16]; /**< The available texture formats */
|
|
int max_texture_width; /**< The maximum texture width */
|
|
int max_texture_height; /**< The maximum texture height */
|
|
} SDL_RendererInfo;
|
|
|
|
/**
|
|
* The scaling mode for a texture.
|
|
*/
|
|
typedef enum
|
|
{
|
|
SDL_ScaleModeNearest, /**< nearest pixel sampling */
|
|
SDL_ScaleModeLinear, /**< linear filtering */
|
|
SDL_ScaleModeBest /**< anisotropic filtering */
|
|
} SDL_ScaleMode;
|
|
|
|
/**
|
|
* The access pattern allowed for a texture.
|
|
*/
|
|
typedef enum
|
|
{
|
|
SDL_TEXTUREACCESS_STATIC, /**< Changes rarely, not lockable */
|
|
SDL_TEXTUREACCESS_STREAMING, /**< Changes frequently, lockable */
|
|
SDL_TEXTUREACCESS_TARGET /**< Texture can be used as a render target */
|
|
} SDL_TextureAccess;
|
|
|
|
/**
|
|
* The texture channel modulation used in SDL_RenderCopy().
|
|
*/
|
|
typedef enum
|
|
{
|
|
SDL_TEXTUREMODULATE_NONE = 0x00000000, /**< No modulation */
|
|
SDL_TEXTUREMODULATE_COLOR = 0x00000001, /**< srcC = srcC * color */
|
|
SDL_TEXTUREMODULATE_ALPHA = 0x00000002 /**< srcA = srcA * alpha */
|
|
} SDL_TextureModulate;
|
|
|
|
/**
|
|
* Flip constants for SDL_RenderCopyEx
|
|
*/
|
|
typedef enum
|
|
{
|
|
SDL_FLIP_NONE = 0x00000000, /**< Do not flip */
|
|
SDL_FLIP_HORIZONTAL = 0x00000001, /**< flip horizontally */
|
|
SDL_FLIP_VERTICAL = 0x00000002 /**< flip vertically */
|
|
} SDL_RendererFlip;
|
|
|
|
/**
|
|
* A structure representing rendering state
|
|
*/
|
|
struct SDL_Renderer;
|
|
typedef struct SDL_Renderer SDL_Renderer;
|
|
|
|
/**
|
|
* An efficient driver-specific representation of pixel data
|
|
*/
|
|
struct SDL_Texture;
|
|
typedef struct SDL_Texture SDL_Texture;
|
|
|
|
/**
|
|
* \brief Vertex structure
|
|
*/
|
|
typedef struct SDL_Vertex
|
|
{
|
|
SDL_FPoint position; /**< Vertex position, in SDL_Renderer coordinates */
|
|
SDL_Color color; /**< Vertex color */
|
|
SDL_FPoint tex_coord; /**< Texture coordinates (0..texture width, 0..texture height),
|
|
if needed */
|
|
} SDL_Vertex;
|
|
|
|
|
|
/* Function prototypes */
|
|
|
|
/**
|
|
* 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.
|
|
*
|
|
* 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);
|
|
|
|
/**
|
|
* 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 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.
|
|
*
|
|
* \sa SDL_CreateRenderer
|
|
* \sa SDL_GetNumRenderDrivers
|
|
*/
|
|
extern DECLSPEC int SDLCALL SDL_GetRenderDriverInfo(int index,
|
|
SDL_RendererInfo * info);
|
|
|
|
/**
|
|
* 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 (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.
|
|
*
|
|
* \sa SDL_CreateRenderer
|
|
* \sa SDL_CreateWindow
|
|
*/
|
|
extern DECLSPEC int SDLCALL SDL_CreateWindowAndRenderer(
|
|
int width, int height, Uint32 window_flags,
|
|
SDL_Window **window, SDL_Renderer **renderer);
|
|
|
|
|
|
/**
|
|
* 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 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.
|
|
*
|
|
* \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);
|
|
|
|
/**
|
|
* 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 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.
|
|
*
|
|
* \sa SDL_CreateRenderer
|
|
* \sa SDL_CreateWindowRenderer
|
|
* \sa SDL_DestroyRenderer
|
|
*/
|
|
extern DECLSPEC SDL_Renderer * SDLCALL SDL_CreateSoftwareRenderer(SDL_Surface * surface);
|
|
|
|
/**
|
|
* 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.
|
|
*
|
|
* \sa SDL_CreateRenderer
|
|
*/
|
|
extern DECLSPEC SDL_Renderer * SDLCALL SDL_GetRenderer(SDL_Window * window);
|
|
|
|
/**
|
|
* 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.
|
|
*
|
|
* \sa SDL_CreateRenderer
|
|
*/
|
|
extern DECLSPEC int SDLCALL SDL_GetRendererInfo(SDL_Renderer * renderer,
|
|
SDL_RendererInfo * info);
|
|
|
|
/**
|
|
* 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);
|
|
|
|
/**
|
|
* Create a texture for a rendering context.
|
|
*
|
|
* You can set the texture scaling method by setting
|
|
* `SDL_HINT_RENDER_SCALE_QUALITY` before creating the texture.
|
|
*
|
|
* \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.
|
|
*
|
|
* \sa SDL_CreateTextureFromSurface
|
|
* \sa SDL_DestroyTexture
|
|
* \sa SDL_QueryTexture
|
|
* \sa SDL_UpdateTexture
|
|
*/
|
|
extern DECLSPEC SDL_Texture * SDLCALL SDL_CreateTexture(SDL_Renderer * renderer,
|
|
Uint32 format,
|
|
int access, int w,
|
|
int h);
|
|
|
|
/**
|
|
* 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`.
|
|
*
|
|
* 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.
|
|
*
|
|
* \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.
|
|
*
|
|
* \sa SDL_CreateTexture
|
|
* \sa SDL_DestroyTexture
|
|
* \sa SDL_QueryTexture
|
|
*/
|
|
extern DECLSPEC SDL_Texture * SDLCALL SDL_CreateTextureFromSurface(SDL_Renderer * renderer, SDL_Surface * surface);
|
|
|
|
/**
|
|
* Query the attributes of a texture.
|
|
*
|
|
* \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.
|
|
*
|
|
* \sa SDL_CreateTexture
|
|
*/
|
|
extern DECLSPEC int SDLCALL SDL_QueryTexture(SDL_Texture * texture,
|
|
Uint32 * format, int *access,
|
|
int *w, int *h);
|
|
|
|
/**
|
|
* 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:
|
|
*
|
|
* `srcC = srcC * (color / 255)`
|
|
*
|
|
* Color modulation is not always supported by the renderer; it will return -1
|
|
* if color modulation is not supported.
|
|
*
|
|
* \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.
|
|
*
|
|
* \sa SDL_GetTextureColorMod
|
|
* \sa SDL_SetTextureAlphaMod
|
|
*/
|
|
extern DECLSPEC int SDLCALL SDL_SetTextureColorMod(SDL_Texture * texture,
|
|
Uint8 r, Uint8 g, Uint8 b);
|
|
|
|
|
|
/**
|
|
* 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
|
|
* \returns 0 on success or a negative error code on failure; call
|
|
* SDL_GetError() for more information.
|
|
*
|
|
* \sa SDL_GetTextureAlphaMod
|
|
* \sa SDL_SetTextureColorMod
|
|
*/
|
|
extern DECLSPEC int SDLCALL SDL_GetTextureColorMod(SDL_Texture * texture,
|
|
Uint8 * r, Uint8 * g,
|
|
Uint8 * b);
|
|
|
|
/**
|
|
* 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 source alpha value multiplied into copy operations
|
|
* \returns 0 on success or a negative error code on failure; call
|
|
* SDL_GetError() for more information.
|
|
*
|
|
* \sa SDL_GetTextureAlphaMod
|
|
* \sa SDL_SetTextureColorMod
|
|
*/
|
|
extern DECLSPEC int SDLCALL SDL_SetTextureAlphaMod(SDL_Texture * texture,
|
|
Uint8 alpha);
|
|
|
|
/**
|
|
* 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
|
|
* \returns 0 on success or a negative error code on failure; call
|
|
* SDL_GetError() for more information.
|
|
*
|
|
* \sa SDL_GetTextureColorMod
|
|
* \sa SDL_SetTextureAlphaMod
|
|
*/
|
|
extern DECLSPEC int SDLCALL SDL_GetTextureAlphaMod(SDL_Texture * texture,
|
|
Uint8 * alpha);
|
|
|
|
/**
|
|
* Set the blend mode for a texture, used by SDL_RenderCopy().
|
|
*
|
|
* If the blend mode is not supported, the closest supported mode is chosen
|
|
* and this function returns -1.
|
|
*
|
|
* \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.
|
|
*
|
|
* \sa SDL_GetTextureBlendMode
|
|
* \sa SDL_RenderCopy
|
|
*/
|
|
extern DECLSPEC int SDLCALL SDL_SetTextureBlendMode(SDL_Texture * texture,
|
|
SDL_BlendMode blendMode);
|
|
|
|
/**
|
|
* Get the blend mode used for texture copy operations.
|
|
*
|
|
* \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.
|
|
*
|
|
* \sa SDL_SetTextureBlendMode
|
|
*/
|
|
extern DECLSPEC int SDLCALL SDL_GetTextureBlendMode(SDL_Texture * texture,
|
|
SDL_BlendMode *blendMode);
|
|
|
|
/**
|
|
* Set the scale mode used for texture scale operations.
|
|
*
|
|
* If the scale mode is not supported, the closest supported mode is chosen.
|
|
*
|
|
* \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.
|
|
*
|
|
* \sa SDL_GetTextureScaleMode
|
|
*/
|
|
extern DECLSPEC int SDLCALL SDL_SetTextureScaleMode(SDL_Texture * texture,
|
|
SDL_ScaleMode scaleMode);
|
|
|
|
/**
|
|
* 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.
|
|
* \return 0 on success, or -1 if the texture is not valid.
|
|
*
|
|
* \sa SDL_SetTextureScaleMode
|
|
*/
|
|
extern DECLSPEC int SDLCALL SDL_GetTextureScaleMode(SDL_Texture * texture,
|
|
SDL_ScaleMode *scaleMode);
|
|
|
|
/**
|
|
* Associate a user-specified pointer with a texture.
|
|
*
|
|
* \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.
|
|
*
|
|
* \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.
|
|
*
|
|
* \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.
|
|
*
|
|
* \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);
|
|
|
|
/**
|
|
* Update a rectangle within a planar YV12 or IYUV texture with new pixel
|
|
* data.
|
|
*
|
|
* 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.
|
|
*
|
|
* \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.
|
|
*
|
|
* \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,
|
|
const Uint8 *Yplane, int Ypitch,
|
|
const Uint8 *Uplane, int Upitch,
|
|
const Uint8 *Vplane, int Vpitch);
|
|
|
|
/**
|
|
* Update a rectangle within a planar NV12 or NV21 texture with new 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.
|
|
*
|
|
* \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.
|
|
*/
|
|
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.
|
|
*
|
|
* \sa SDL_UnlockTexture
|
|
*/
|
|
extern DECLSPEC int SDLCALL SDL_LockTexture(SDL_Texture * texture,
|
|
const SDL_Rect * rect,
|
|
void **pixels, int *pitch);
|
|
|
|
/**
|
|
* 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.
|
|
*
|
|
* The returned surface is freed internally after calling SDL_UnlockTexture()
|
|
* or SDL_DestroyTexture(). The caller should not free it.
|
|
*
|
|
* \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_LockTexture
|
|
* \sa SDL_UnlockTexture
|
|
*/
|
|
extern DECLSPEC int SDLCALL SDL_LockTextureToSurface(SDL_Texture *texture,
|
|
const SDL_Rect *rect,
|
|
SDL_Surface **surface);
|
|
|
|
/**
|
|
* 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 notguarantee 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()
|
|
*
|
|
* \sa SDL_LockTexture
|
|
*/
|
|
extern DECLSPEC void SDLCALL SDL_UnlockTexture(SDL_Texture * texture);
|
|
|
|
/**
|
|
* Determine whether a renderer supports the use of render targets.
|
|
*
|
|
* \param renderer the renderer that will be checked
|
|
* \returns SDL_TRUE if supported or 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);
|
|
|
|
/**
|
|
* Set a texture as the current rendering 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.
|
|
*
|
|
* 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
|
|
*/
|
|
extern DECLSPEC int SDLCALL SDL_SetRenderTarget(SDL_Renderer *renderer,
|
|
SDL_Texture *texture);
|
|
|
|
/**
|
|
* Get the current render target.
|
|
*
|
|
* The default render target is the window for which the renderer was created,
|
|
* and is reported a NULL here.
|
|
*
|
|
* \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);
|
|
|
|
/**
|
|
* 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.
|
|
*
|
|
* 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.
|
|
*
|
|
* If this function results in scaling or subpixel drawing by the rendering
|
|
* backend, it will be handled using the appropriate quality hints.
|
|
*
|
|
* \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.
|
|
*
|
|
* \since This function is available since SDL 2.0.0.
|
|
*
|
|
* \sa SDL_RenderGetLogicalSize
|
|
*/
|
|
extern DECLSPEC int SDLCALL SDL_RenderSetLogicalSize(SDL_Renderer * renderer, int w, int h);
|
|
|
|
/**
|
|
* 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
|
|
*
|
|
* \since This function is available since SDL 2.0.0.
|
|
*
|
|
* \sa SDL_RenderSetLogicalSize
|
|
*/
|
|
extern DECLSPEC void SDLCALL SDL_RenderGetLogicalSize(SDL_Renderer * renderer, int *w, int *h);
|
|
|
|
/**
|
|
* Set whether to force integer scales for resolution-independent rendering.
|
|
*
|
|
* 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.
|
|
*
|
|
* \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);
|
|
|
|
/**
|
|
* 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.
|
|
*
|
|
* \since This function is available since SDL 2.0.5.
|
|
*
|
|
* \sa SDL_RenderSetIntegerScale
|
|
*/
|
|
extern DECLSPEC SDL_bool SDLCALL SDL_RenderGetIntegerScale(SDL_Renderer * renderer);
|
|
|
|
/**
|
|
* Set the drawing area for rendering on the current target.
|
|
*
|
|
* When the window is resized, the viewport is reset to fill the entire new
|
|
* window size.
|
|
*
|
|
* \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.
|
|
*
|
|
* \sa SDL_RenderGetViewport
|
|
*/
|
|
extern DECLSPEC int SDLCALL SDL_RenderSetViewport(SDL_Renderer * renderer,
|
|
const SDL_Rect * rect);
|
|
|
|
/**
|
|
* 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
|
|
*/
|
|
extern DECLSPEC void SDLCALL SDL_RenderGetViewport(SDL_Renderer * renderer,
|
|
SDL_Rect * rect);
|
|
|
|
/**
|
|
* Set the clip rectangle for rendering on the specified target.
|
|
*
|
|
* \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.
|
|
*
|
|
* \sa SDL_RenderGetClipRect
|
|
* \sa SDL_RenderIsClipEnabled
|
|
*/
|
|
extern DECLSPEC int SDLCALL SDL_RenderSetClipRect(SDL_Renderer * renderer,
|
|
const SDL_Rect * rect);
|
|
|
|
/**
|
|
* 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
|
|
*
|
|
* \sa SDL_RenderIsClipEnabled
|
|
* \sa SDL_RenderSetClipRect
|
|
*/
|
|
extern DECLSPEC void SDLCALL SDL_RenderGetClipRect(SDL_Renderer * renderer,
|
|
SDL_Rect * rect);
|
|
|
|
/**
|
|
* 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.
|
|
*
|
|
* \since This function is available since SDL 2.0.4.
|
|
*
|
|
* \sa SDL_RenderGetClipRect
|
|
* \sa SDL_RenderSetClipRect
|
|
*/
|
|
extern DECLSPEC SDL_bool SDLCALL SDL_RenderIsClipEnabled(SDL_Renderer * renderer);
|
|
|
|
|
|
/**
|
|
* Set the drawing scale for rendering on the current target.
|
|
*
|
|
* 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.
|
|
*
|
|
* \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.
|
|
*
|
|
* \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);
|
|
|
|
/**
|
|
* 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
|
|
*
|
|
* \since This function is available since SDL 2.0.0.
|
|
*
|
|
* \sa SDL_RenderSetScale
|
|
*/
|
|
extern DECLSPEC void SDLCALL SDL_RenderGetScale(SDL_Renderer * renderer,
|
|
float *scaleX, float *scaleY);
|
|
|
|
/**
|
|
* 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.
|
|
*
|
|
* \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);
|
|
|
|
/**
|
|
* 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.
|
|
*
|
|
* \sa SDL_SetRenderDrawColor
|
|
*/
|
|
extern DECLSPEC int SDLCALL SDL_GetRenderDrawColor(SDL_Renderer * renderer,
|
|
Uint8 * r, Uint8 * g, Uint8 * b,
|
|
Uint8 * a);
|
|
|
|
/**
|
|
* Set the blend mode used for drawing operations (Fill and Line).
|
|
*
|
|
* If the blend mode is not supported, the closest supported mode is chosen.
|
|
*
|
|
* \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.
|
|
*
|
|
* \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);
|
|
|
|
/**
|
|
* Get the blend mode used for drawing operations.
|
|
*
|
|
* \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.
|
|
*
|
|
* \sa SDL_SetRenderDrawBlendMode
|
|
*/
|
|
extern DECLSPEC int SDLCALL SDL_GetRenderDrawBlendMode(SDL_Renderer * renderer,
|
|
SDL_BlendMode *blendMode);
|
|
|
|
/**
|
|
* 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.
|
|
*
|
|
* \since This function is available since SDL 2.0.0.
|
|
*
|
|
* \sa SDL_SetRenderDrawColor
|
|
*/
|
|
extern DECLSPEC int SDLCALL SDL_RenderClear(SDL_Renderer * renderer);
|
|
|
|
/**
|
|
* Draw a point on the current rendering target.
|
|
*
|
|
* SDL_RenderDrawPoint() draws a single point. If you want to draw multiple,
|
|
* use SDL_RenderDrawPoints() instead.
|
|
*
|
|
* \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.
|
|
*
|
|
* \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);
|
|
|
|
/**
|
|
* 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.
|
|
*
|
|
* \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);
|
|
|
|
/**
|
|
* 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.
|
|
*
|
|
* \since This function is available since SDL 2.0.0.
|
|
*
|
|
* \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);
|
|
|
|
/**
|
|
* Draw a series of connected lines on the current rendering target.
|
|
*
|
|
* \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.
|
|
*
|
|
* \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);
|
|
|
|
/**
|
|
* 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.
|
|
*
|
|
* \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);
|
|
|
|
/**
|
|
* Draw some number of rectangles on the current rendering target.
|
|
*
|
|
* \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.
|
|
*
|
|
* \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);
|
|
|
|
/**
|
|
* 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 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.
|
|
*
|
|
* \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);
|
|
|
|
/**
|
|
* 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.
|
|
*
|
|
* \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);
|
|
|
|
/**
|
|
* 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 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.
|
|
*
|
|
* \sa SDL_RenderCopyEx
|
|
* \sa SDL_SetTextureAlphaMod
|
|
* \sa SDL_SetTextureBlendMode
|
|
* \sa SDL_SetTextureColorMod
|
|
*/
|
|
extern DECLSPEC int SDLCALL SDL_RenderCopy(SDL_Renderer * renderer,
|
|
SDL_Texture * texture,
|
|
const SDL_Rect * srcrect,
|
|
const SDL_Rect * dstrect);
|
|
|
|
/**
|
|
* 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 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.
|
|
*
|
|
* \sa SDL_RenderCopy
|
|
* \sa SDL_SetTextureAlphaMod
|
|
* \sa SDL_SetTextureBlendMode
|
|
* \sa SDL_SetTextureColorMod
|
|
*/
|
|
extern DECLSPEC int SDLCALL SDL_RenderCopyEx(SDL_Renderer * renderer,
|
|
SDL_Texture * texture,
|
|
const SDL_Rect * srcrect,
|
|
const SDL_Rect * dstrect,
|
|
const double angle,
|
|
const SDL_Point *center,
|
|
const SDL_RendererFlip flip);
|
|
|
|
|
|
/**
|
|
* 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.
|
|
* \return 0 on success, or -1 on error
|
|
*/
|
|
extern DECLSPEC int SDLCALL SDL_RenderDrawPointF(SDL_Renderer * renderer,
|
|
float x, float y);
|
|
|
|
/**
|
|
* 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
|
|
* \return 0 on success, or -1 on error
|
|
*/
|
|
extern DECLSPEC int SDLCALL SDL_RenderDrawPointsF(SDL_Renderer * renderer,
|
|
const SDL_FPoint * points,
|
|
int count);
|
|
|
|
/**
|
|
* 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.
|
|
* \return 0 on success, or -1 on error
|
|
*/
|
|
extern DECLSPEC int SDLCALL SDL_RenderDrawLineF(SDL_Renderer * renderer,
|
|
float x1, float y1, float x2, float y2);
|
|
|
|
/**
|
|
* 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
|
|
* \return 0 on success, or -1 on error
|
|
*/
|
|
extern DECLSPEC int SDLCALL SDL_RenderDrawLinesF(SDL_Renderer * renderer,
|
|
const SDL_FPoint * points,
|
|
int count);
|
|
|
|
/**
|
|
* 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.
|
|
* \return 0 on success, or -1 on error
|
|
*/
|
|
extern DECLSPEC int SDLCALL SDL_RenderDrawRectF(SDL_Renderer * renderer,
|
|
const SDL_FRect * rect);
|
|
|
|
/**
|
|
* 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.
|
|
* \return 0 on success, or -1 on error
|
|
*/
|
|
extern DECLSPEC int SDLCALL SDL_RenderDrawRectsF(SDL_Renderer * renderer,
|
|
const SDL_FRect * rects,
|
|
int count);
|
|
|
|
/**
|
|
* 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.
|
|
* \return 0 on success, or -1 on error
|
|
*/
|
|
extern DECLSPEC int SDLCALL SDL_RenderFillRectF(SDL_Renderer * renderer,
|
|
const SDL_FRect * rect);
|
|
|
|
/**
|
|
* 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.
|
|
* \return 0 on success, or -1 on error
|
|
*/
|
|
extern DECLSPEC int SDLCALL SDL_RenderFillRectsF(SDL_Renderer * renderer,
|
|
const SDL_FRect * rects,
|
|
int count);
|
|
|
|
/**
|
|
* 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.
|
|
* \return 0 on success, or -1 on error
|
|
*/
|
|
extern DECLSPEC int SDLCALL SDL_RenderCopyF(SDL_Renderer * renderer,
|
|
SDL_Texture * texture,
|
|
const SDL_Rect * srcrect,
|
|
const SDL_FRect * dstrect);
|
|
|
|
/**
|
|
* 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
|
|
*/
|
|
extern DECLSPEC int SDLCALL SDL_RenderCopyExF(SDL_Renderer * renderer,
|
|
SDL_Texture * texture,
|
|
const SDL_Rect * srcrect,
|
|
const SDL_FRect * dstrect,
|
|
const double angle,
|
|
const SDL_FPoint *center,
|
|
const SDL_RendererFlip flip);
|
|
|
|
/**
|
|
* \brief 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.
|
|
*
|
|
* \sa SDL_Vertex
|
|
*
|
|
* \return 0 on success, or -1 if the operation is not supported
|
|
*/
|
|
extern DECLSPEC int SDLCALL SDL_RenderGeometry(SDL_Renderer *renderer,
|
|
SDL_Texture *texture,
|
|
SDL_Vertex *vertices, int num_vertices,
|
|
int *indices, int num_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.
|
|
*/
|
|
extern DECLSPEC int SDLCALL SDL_RenderReadPixels(SDL_Renderer * renderer,
|
|
const SDL_Rect * rect,
|
|
Uint32 format,
|
|
void *pixels, int pitch);
|
|
|
|
/**
|
|
* 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
|
|
*
|
|
* \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);
|
|
|
|
/**
|
|
* Destroy the specified texture.
|
|
*
|
|
* Passing NULL or an otherwise invalid texture will set the SDL error message
|
|
* to "Invalid texture".
|
|
*
|
|
* \param texture the texture to destroy
|
|
*
|
|
* \sa SDL_CreateTexture
|
|
* \sa SDL_CreateTextureFromSurface
|
|
*/
|
|
extern DECLSPEC void SDLCALL SDL_DestroyTexture(SDL_Texture * texture);
|
|
|
|
/**
|
|
* Destroy the rendering context for a window and free associated textures.
|
|
*
|
|
* \param renderer the rendering context
|
|
*
|
|
* \sa SDL_CreateRenderer
|
|
*/
|
|
extern DECLSPEC void SDLCALL SDL_DestroyRenderer(SDL_Renderer * renderer);
|
|
|
|
/**
|
|
* 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.
|
|
*
|
|
* 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 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.
|
|
*
|
|
* \param renderer the rendering context
|
|
* \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.10.
|
|
*/
|
|
extern DECLSPEC int SDLCALL SDL_RenderFlush(SDL_Renderer * renderer);
|
|
|
|
|
|
/**
|
|
* 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.
|
|
*
|
|
* 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.
|
|
*
|
|
* 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);
|
|
|
|
/**
|
|
* 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 texture to unbind from the current OpenGL/ES/ES2 context
|
|
* \returns 0 on success, or -1 if the operation is not supported
|
|
*
|
|
* \sa SDL_GL_BindTexture
|
|
* \sa SDL_GL_MakeCurrent
|
|
*/
|
|
extern DECLSPEC int SDLCALL SDL_GL_UnbindTexture(SDL_Texture *texture);
|
|
|
|
/**
|
|
* 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
|
|
* \returns a `CAMetalLayer *` on success, or NULL if the renderer isn't a
|
|
* Metal renderer
|
|
*
|
|
* \sa SDL_RenderGetMetalCommandEncoder
|
|
*/
|
|
extern DECLSPEC void *SDLCALL SDL_RenderGetMetalLayer(SDL_Renderer * renderer);
|
|
|
|
/**
|
|
* 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
|
|
* \returns an `id<MTLRenderCommandEncoder>` on success, or NULL if the
|
|
* renderer isn't a Metal renderer.
|
|
*
|
|
* \sa SDL_RenderGetMetalLayer
|
|
*/
|
|
extern DECLSPEC void *SDLCALL SDL_RenderGetMetalCommandEncoder(SDL_Renderer * renderer);
|
|
|
|
/* Ends C function definitions when using C++ */
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
#include "close_code.h"
|
|
|
|
#endif /* SDL_render_h_ */
|
|
|
|
/* vi: set ts=4 sw=4 expandtab: */
|