SDL_render.c File Reference

#include "../SDL_internal.h"
#include "SDL_hints.h"
#include "SDL_render.h"
#include "SDL_sysrender.h"
#include "software/SDL_render_sw_c.h"
#include "../video/SDL_pixels_c.h"

Include dependency graph for SDL_render.c:

Go to the source code of this file.

Macros
#define	SDL_WINDOWRENDERDATA   "_SDL_WindowRenderData"
#define	CHECK_RENDERER_MAGIC(renderer, retval)
#define	CHECK_TEXTURE_MAGIC(texture, retval)
#define	SDL_COMPOSE_BLENDMODE(srcColorFactor, dstColorFactor, colorOperation, srcAlphaFactor, dstAlphaFactor, alphaOperation)
#define	SDL_BLENDMODE_NONE_FULL
#define	SDL_BLENDMODE_BLEND_FULL
#define	SDL_BLENDMODE_ADD_FULL
#define	SDL_BLENDMODE_MOD_FULL
#define	SDL_BLENDMODE_MUL_FULL

Functions
static SDL_INLINE void	DebugLogRenderCommands (const SDL_RenderCommand *cmd)
static int	FlushRenderCommands (SDL_Renderer *renderer)
static int	FlushRenderCommandsIfTextureNeeded (SDL_Texture *texture)
static SDL_INLINE int	FlushRenderCommandsIfNotBatching (SDL_Renderer *renderer)
int	SDL_RenderFlush (SDL_Renderer *renderer)
	Force the rendering context to flush any pending commands to the underlying rendering API. More...
void *	SDL_AllocateRenderVertices (SDL_Renderer *renderer, const size_t numbytes, const size_t alignment, size_t *offset)
static SDL_RenderCommand *	AllocateRenderCommand (SDL_Renderer *renderer)
static int	QueueCmdSetViewport (SDL_Renderer *renderer)
static int	QueueCmdSetClipRect (SDL_Renderer *renderer)
static int	QueueCmdSetDrawColor (SDL_Renderer *renderer, const Uint8 r, const Uint8 g, const Uint8 b, const Uint8 a)
static int	QueueCmdClear (SDL_Renderer *renderer)
static int	PrepQueueCmdDraw (SDL_Renderer *renderer, const Uint8 r, const Uint8 g, const Uint8 b, const Uint8 a)
static SDL_RenderCommand *	PrepQueueCmdDrawSolid (SDL_Renderer *renderer, const SDL_RenderCommandType cmdtype)
static int	QueueCmdDrawPoints (SDL_Renderer *renderer, const SDL_FPoint *points, const int count)
static int	QueueCmdDrawLines (SDL_Renderer *renderer, const SDL_FPoint *points, const int count)
static int	QueueCmdFillRects (SDL_Renderer *renderer, const SDL_FRect *rects, const int count)
static SDL_RenderCommand *	PrepQueueCmdDrawTexture (SDL_Renderer *renderer, SDL_Texture *texture, const SDL_RenderCommandType cmdtype)
static int	QueueCmdCopy (SDL_Renderer *renderer, SDL_Texture *texture, const SDL_Rect *srcrect, const SDL_FRect *dstrect)
static int	QueueCmdCopyEx (SDL_Renderer *renderer, SDL_Texture *texture, const SDL_Rect *srcquad, const SDL_FRect *dstrect, const double angle, const SDL_FPoint *center, const SDL_RendererFlip flip)
static int	UpdateLogicalSize (SDL_Renderer *renderer)
int	SDL_GetNumRenderDrivers (void)
	Get the number of 2D rendering drivers available for the current display. More...
int	SDL_GetRenderDriverInfo (int index, SDL_RendererInfo *info)
	Get information about a specific 2D rendering driver for the current display. More...
static void	GetWindowViewportValues (SDL_Renderer *renderer, int *logical_w, int *logical_h, SDL_Rect *viewport, SDL_FPoint *scale)
static int	SDL_RendererEventWatch (void *userdata, SDL_Event *event)
int	SDL_CreateWindowAndRenderer (int width, int height, Uint32 window_flags, SDL_Window **window, SDL_Renderer **renderer)
	Create a window and default renderer. More...
static SDL_INLINE void	VerifyDrawQueueFunctions (const SDL_Renderer *renderer)
SDL_Renderer *	SDL_CreateRenderer (SDL_Window *window, int index, Uint32 flags)
	Create a 2D rendering context for a window. More...
SDL_Renderer *	SDL_CreateSoftwareRenderer (SDL_Surface *surface)
	Create a 2D software rendering context for a surface. More...
SDL_Renderer *	SDL_GetRenderer (SDL_Window *window)
	Get the renderer associated with a window. More...
int	SDL_GetRendererInfo (SDL_Renderer *renderer, SDL_RendererInfo *info)
	Get information about a rendering context. More...
int	SDL_GetRendererOutputSize (SDL_Renderer *renderer, int *w, int *h)
	Get the output size in pixels of a rendering context. More...
static SDL_bool	IsSupportedBlendMode (SDL_Renderer *renderer, SDL_BlendMode blendMode)
static SDL_bool	IsSupportedFormat (SDL_Renderer *renderer, Uint32 format)
static Uint32	GetClosestSupportedFormat (SDL_Renderer *renderer, Uint32 format)
static SDL_ScaleMode	SDL_GetScaleMode (void)
SDL_Texture *	SDL_CreateTexture (SDL_Renderer *renderer, Uint32 format, int access, int w, int h)
	Create a texture for a rendering context. More...
SDL_Texture *	SDL_CreateTextureFromSurface (SDL_Renderer *renderer, SDL_Surface *surface)
	Create a texture from an existing surface. More...
int	SDL_QueryTexture (SDL_Texture *texture, Uint32 *format, int *access, int *w, int *h)
	Query the attributes of a texture. More...
int	SDL_SetTextureColorMod (SDL_Texture *texture, Uint8 r, Uint8 g, Uint8 b)
	Set an additional color value used in render copy operations. More...
int	SDL_GetTextureColorMod (SDL_Texture *texture, Uint8 *r, Uint8 *g, Uint8 *b)
	Get the additional color value used in render copy operations. More...
int	SDL_SetTextureAlphaMod (SDL_Texture *texture, Uint8 alpha)
	Set an additional alpha value used in render copy operations. More...
int	SDL_GetTextureAlphaMod (SDL_Texture *texture, Uint8 *alpha)
	Get the additional alpha value used in render copy operations. More...
int	SDL_SetTextureBlendMode (SDL_Texture *texture, SDL_BlendMode blendMode)
	Set the blend mode used for texture copy operations. More...
int	SDL_GetTextureBlendMode (SDL_Texture *texture, SDL_BlendMode *blendMode)
	Get the blend mode used for texture copy operations. More...
int	SDL_SetTextureScaleMode (SDL_Texture *texture, SDL_ScaleMode scaleMode)
	Set the scale mode used for texture scale operations. More...
int	SDL_GetTextureScaleMode (SDL_Texture *texture, SDL_ScaleMode *scaleMode)
	Get the scale mode used for texture scale operations. More...
static int	SDL_UpdateTextureYUV (SDL_Texture *texture, const SDL_Rect *rect, const void *pixels, int pitch)
static int	SDL_UpdateTextureNative (SDL_Texture *texture, const SDL_Rect *rect, const void *pixels, int pitch)
int	SDL_UpdateTexture (SDL_Texture *texture, const SDL_Rect *rect, const void *pixels, int pitch)
	Update the given texture rectangle with new pixel data. More...
static int	SDL_UpdateTextureYUVPlanar (SDL_Texture *texture, const SDL_Rect *rect, const Uint8 *Yplane, int Ypitch, const Uint8 *Uplane, int Upitch, const Uint8 *Vplane, int Vpitch)
int	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 YV12 or IYUV texture with new pixel data. More...
static int	SDL_LockTextureYUV (SDL_Texture *texture, const SDL_Rect *rect, void **pixels, int *pitch)
static int	SDL_LockTextureNative (SDL_Texture *texture, const SDL_Rect *rect, void **pixels, int *pitch)
int	SDL_LockTexture (SDL_Texture *texture, const SDL_Rect *rect, void **pixels, int *pitch)
	Lock a portion of the texture for write-only pixel access. More...
int	SDL_LockTextureToSurface (SDL_Texture *texture, const SDL_Rect *rect, SDL_Surface **surface)
	Lock a portion of the texture for write-only pixel access. Expose it as a SDL surface. More...
static void	SDL_UnlockTextureYUV (SDL_Texture *texture)
static void	SDL_UnlockTextureNative (SDL_Texture *texture)
void	SDL_UnlockTexture (SDL_Texture *texture)
	Unlock a texture, uploading the changes to video memory, if needed. If SDL_LockTextureToSurface() was called for locking, the SDL surface is freed. More...
SDL_bool	SDL_RenderTargetSupported (SDL_Renderer *renderer)
	Determines whether a window supports the use of render targets. More...
int	SDL_SetRenderTarget (SDL_Renderer *renderer, SDL_Texture *texture)
	Set a texture as the current rendering target. More...
SDL_Texture *	SDL_GetRenderTarget (SDL_Renderer *renderer)
	Get the current render target or NULL for the default render target. More...
int	SDL_RenderSetLogicalSize (SDL_Renderer *renderer, int w, int h)
	Set device independent resolution for rendering. More...
void	SDL_RenderGetLogicalSize (SDL_Renderer *renderer, int *w, int *h)
	Get device independent resolution for rendering. More...
int	SDL_RenderSetIntegerScale (SDL_Renderer *renderer, SDL_bool enable)
	Set whether to force integer scales for resolution-independent rendering. More...
SDL_bool	SDL_RenderGetIntegerScale (SDL_Renderer *renderer)
	Get whether integer scales are forced for resolution-independent rendering. More...
int	SDL_RenderSetViewport (SDL_Renderer *renderer, const SDL_Rect *rect)
	Set the drawing area for rendering on the current target. More...
void	SDL_RenderGetViewport (SDL_Renderer *renderer, SDL_Rect *rect)
	Get the drawing area for the current target. More...
int	SDL_RenderSetClipRect (SDL_Renderer *renderer, const SDL_Rect *rect)
	Set the clip rectangle for the current target. More...
void	SDL_RenderGetClipRect (SDL_Renderer *renderer, SDL_Rect *rect)
	Get the clip rectangle for the current target. More...
SDL_bool	SDL_RenderIsClipEnabled (SDL_Renderer *renderer)
	Get whether clipping is enabled on the given renderer. More...
int	SDL_RenderSetScale (SDL_Renderer *renderer, float scaleX, float scaleY)
	Set the drawing scale for rendering on the current target. More...
void	SDL_RenderGetScale (SDL_Renderer *renderer, float *scaleX, float *scaleY)
	Get the drawing scale for the current target. More...
int	SDL_SetRenderDrawColor (SDL_Renderer *renderer, Uint8 r, Uint8 g, Uint8 b, Uint8 a)
	Set the color used for drawing operations (Rect, Line and Clear). More...
int	SDL_GetRenderDrawColor (SDL_Renderer *renderer, Uint8 *r, Uint8 *g, Uint8 *b, Uint8 *a)
	Get the color used for drawing operations (Rect, Line and Clear). More...
int	SDL_SetRenderDrawBlendMode (SDL_Renderer *renderer, SDL_BlendMode blendMode)
	Set the blend mode used for drawing operations (Fill and Line). More...
int	SDL_GetRenderDrawBlendMode (SDL_Renderer *renderer, SDL_BlendMode *blendMode)
	Get the blend mode used for drawing operations. More...
int	SDL_RenderClear (SDL_Renderer *renderer)
	Clear the current rendering target with the drawing color. More...
int	SDL_RenderDrawPoint (SDL_Renderer *renderer, int x, int y)
	Draw a point on the current rendering target. More...
int	SDL_RenderDrawPointF (SDL_Renderer *renderer, float x, float y)
	Draw a point on the current rendering target. More...
static int	RenderDrawPointsWithRects (SDL_Renderer *renderer, const SDL_Point *points, const int count)
int	SDL_RenderDrawPoints (SDL_Renderer *renderer, const SDL_Point *points, int count)
	Draw multiple points on the current rendering target. More...
static int	RenderDrawPointsWithRectsF (SDL_Renderer *renderer, const SDL_FPoint *fpoints, const int count)
int	SDL_RenderDrawPointsF (SDL_Renderer *renderer, const SDL_FPoint *points, int count)
	Draw multiple points on the current rendering target. More...
int	SDL_RenderDrawLine (SDL_Renderer *renderer, int x1, int y1, int x2, int y2)
	Draw a line on the current rendering target. More...
int	SDL_RenderDrawLineF (SDL_Renderer *renderer, float x1, float y1, float x2, float y2)
	Draw a line on the current rendering target. More...
static int	RenderDrawLinesWithRects (SDL_Renderer *renderer, const SDL_Point *points, const int count)
static int	RenderDrawLinesWithRectsF (SDL_Renderer *renderer, const SDL_FPoint *points, const int count)
int	SDL_RenderDrawLines (SDL_Renderer *renderer, const SDL_Point *points, int count)
	Draw a series of connected lines on the current rendering target. More...
int	SDL_RenderDrawLinesF (SDL_Renderer *renderer, const SDL_FPoint *points, int count)
	Draw a series of connected lines on the current rendering target. More...
int	SDL_RenderDrawRect (SDL_Renderer *renderer, const SDL_Rect *rect)
	Draw a rectangle on the current rendering target. More...
int	SDL_RenderDrawRectF (SDL_Renderer *renderer, const SDL_FRect *rect)
	Draw a rectangle on the current rendering target. More...
int	SDL_RenderDrawRects (SDL_Renderer *renderer, const SDL_Rect *rects, int count)
	Draw some number of rectangles on the current rendering target. More...
int	SDL_RenderDrawRectsF (SDL_Renderer *renderer, const SDL_FRect *rects, int count)
	Draw some number of rectangles on the current rendering target. More...
int	SDL_RenderFillRect (SDL_Renderer *renderer, const SDL_Rect *rect)
	Fill a rectangle on the current rendering target with the drawing color. More...
int	SDL_RenderFillRectF (SDL_Renderer *renderer, const SDL_FRect *rect)
	Fill a rectangle on the current rendering target with the drawing color. More...
int	SDL_RenderFillRects (SDL_Renderer *renderer, const SDL_Rect *rects, int count)
	Fill some number of rectangles on the current rendering target with the drawing color. More...
int	SDL_RenderFillRectsF (SDL_Renderer *renderer, const SDL_FRect *rects, int count)
	Fill some number of rectangles on the current rendering target with the drawing color. More...
SDL_FORCE_INLINE SDL_bool	SDL_FRectEmpty (const SDL_FRect *r)
static SDL_bool	SDL_HasIntersectionF (const SDL_FRect *A, const SDL_FRect *B)
int	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 target. More...
int	SDL_RenderCopyF (SDL_Renderer *renderer, SDL_Texture *texture, const SDL_Rect *srcrect, const SDL_FRect *dstrect)
	Copy a portion of the texture to the current rendering target. More...
int	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)
	Copy a portion of the source texture to the current rendering target, rotating it by angle around the given center. More...
int	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)
	Copy a portion of the source texture to the current rendering target, rotating it by angle around the given center. More...
int	SDL_RenderReadPixels (SDL_Renderer *renderer, const SDL_Rect *rect, Uint32 format, void *pixels, int pitch)
	Read pixels from the current rendering target. More...
void	SDL_RenderPresent (SDL_Renderer *renderer)
	Update the screen with rendering performed. More...
void	SDL_DestroyTexture (SDL_Texture *texture)
	Destroy the specified texture. More...
void	SDL_DestroyRenderer (SDL_Renderer *renderer)
	Destroy the rendering context for a window and free associated textures. More...
int	SDL_GL_BindTexture (SDL_Texture *texture, float *texw, float *texh)
	Bind the texture to the current OpenGL/ES/ES2 context for use with OpenGL instructions. More...
int	SDL_GL_UnbindTexture (SDL_Texture *texture)
	Unbind a texture from the current OpenGL/ES/ES2 context. More...
void *	SDL_RenderGetMetalLayer (SDL_Renderer *renderer)
	Get the CAMetalLayer associated with the given Metal renderer. More...
void *	SDL_RenderGetMetalCommandEncoder (SDL_Renderer *renderer)
	Get the Metal command encoder for the current frame. More...
static SDL_BlendMode	SDL_GetShortBlendMode (SDL_BlendMode blendMode)
static SDL_BlendMode	SDL_GetLongBlendMode (SDL_BlendMode blendMode)
SDL_BlendMode	SDL_ComposeCustomBlendMode (SDL_BlendFactor srcColorFactor, SDL_BlendFactor dstColorFactor, SDL_BlendOperation colorOperation, SDL_BlendFactor srcAlphaFactor, SDL_BlendFactor dstAlphaFactor, SDL_BlendOperation alphaOperation)
	Create a custom blend mode, which may or may not be supported by a given renderer. More...
SDL_BlendFactor	SDL_GetBlendModeSrcColorFactor (SDL_BlendMode blendMode)
SDL_BlendFactor	SDL_GetBlendModeDstColorFactor (SDL_BlendMode blendMode)
SDL_BlendOperation	SDL_GetBlendModeColorOperation (SDL_BlendMode blendMode)
SDL_BlendFactor	SDL_GetBlendModeSrcAlphaFactor (SDL_BlendMode blendMode)
SDL_BlendFactor	SDL_GetBlendModeDstAlphaFactor (SDL_BlendMode blendMode)
SDL_BlendOperation	SDL_GetBlendModeAlphaOperation (SDL_BlendMode blendMode)

Variables
static const SDL_RenderDriver *	render_drivers []
static char	renderer_magic
static char	texture_magic

Macro Definition Documentation

CHECK_RENDERER_MAGIC

#define CHECK_RENDERER_MAGIC	(		renderer,
			retval
	)

Value:

    SDL_assert(renderer && renderer->magic == &renderer_magic); \
    if (!renderer || renderer->magic != &renderer_magic) { \
        SDL_SetError("Invalid renderer"); \
        return retval; \
    }

Definition at line 37 of file SDL_render.c.

CHECK_TEXTURE_MAGIC

#define CHECK_TEXTURE_MAGIC	(		texture,
			retval
	)

Value:

    SDL_assert(texture && texture->magic == &texture_magic); \
    if (!texture || texture->magic != &texture_magic) { \
        SDL_SetError("Invalid texture"); \
        return retval; \
    }

Definition at line 44 of file SDL_render.c.

SDL_BLENDMODE_ADD_FULL

#define SDL_BLENDMODE_ADD_FULL

Value:

    SDL_COMPOSE_BLENDMODE(SDL_BLENDFACTOR_SRC_ALPHA, SDL_BLENDFACTOR_ONE, SDL_BLENDOPERATION_ADD, \
                          SDL_BLENDFACTOR_ZERO, SDL_BLENDFACTOR_ONE, SDL_BLENDOPERATION_ADD)

Definition at line 69 of file SDL_render.c.

SDL_BLENDMODE_BLEND_FULL

#define SDL_BLENDMODE_BLEND_FULL

Value:

    SDL_COMPOSE_BLENDMODE(SDL_BLENDFACTOR_SRC_ALPHA, SDL_BLENDFACTOR_ONE_MINUS_SRC_ALPHA, SDL_BLENDOPERATION_ADD, \
                          SDL_BLENDFACTOR_ONE, SDL_BLENDFACTOR_ONE_MINUS_SRC_ALPHA, SDL_BLENDOPERATION_ADD)

Definition at line 65 of file SDL_render.c.

SDL_BLENDMODE_MOD_FULL

#define SDL_BLENDMODE_MOD_FULL

Value:

    SDL_COMPOSE_BLENDMODE(SDL_BLENDFACTOR_ZERO, SDL_BLENDFACTOR_SRC_COLOR, SDL_BLENDOPERATION_ADD, \
                          SDL_BLENDFACTOR_ZERO, SDL_BLENDFACTOR_ONE, SDL_BLENDOPERATION_ADD)

Definition at line 73 of file SDL_render.c.

SDL_BLENDMODE_MUL_FULL

#define SDL_BLENDMODE_MUL_FULL

Value:

    SDL_COMPOSE_BLENDMODE(SDL_BLENDFACTOR_DST_COLOR, SDL_BLENDFACTOR_ONE_MINUS_SRC_ALPHA, SDL_BLENDOPERATION_ADD, \
                          SDL_BLENDFACTOR_DST_ALPHA, SDL_BLENDFACTOR_ONE_MINUS_SRC_ALPHA, SDL_BLENDOPERATION_ADD)

Definition at line 77 of file SDL_render.c.

SDL_BLENDMODE_NONE_FULL

#define SDL_BLENDMODE_NONE_FULL

Value:

    SDL_COMPOSE_BLENDMODE(SDL_BLENDFACTOR_ONE, SDL_BLENDFACTOR_ZERO, SDL_BLENDOPERATION_ADD, \
                          SDL_BLENDFACTOR_ONE, SDL_BLENDFACTOR_ZERO, SDL_BLENDOPERATION_ADD)

Definition at line 61 of file SDL_render.c.

SDL_COMPOSE_BLENDMODE

#define SDL_COMPOSE_BLENDMODE	(		srcColorFactor,
			dstColorFactor,
			colorOperation,
			srcAlphaFactor,
			dstAlphaFactor,
			alphaOperation
	)

Value:

    (SDL_BlendMode)(((Uint32)colorOperation << 0) | \
                    ((Uint32)srcColorFactor << 4) | \
                    ((Uint32)dstColorFactor << 8) | \
                    ((Uint32)alphaOperation << 16) | \
                    ((Uint32)srcAlphaFactor << 20) | \
                    ((Uint32)dstAlphaFactor << 24))

Definition at line 52 of file SDL_render.c.

SDL_WINDOWRENDERDATA

#define SDL_WINDOWRENDERDATA   "_SDL_WindowRenderData"

Definition at line 35 of file SDL_render.c.

Function Documentation

AllocateRenderCommand()

static SDL_RenderCommand* AllocateRenderCommand ( SDL_Renderer *  renderer )

static

Definition at line 296 of file SDL_render.c.

{
    SDL_RenderCommand *retval = NULL;
 
    /* !!! FIXME: are there threading limitations in SDL's render API? If not, we need to mutex this. */
    retval = renderer->render_commands_pool;
    if (retval != NULL) {
        renderer->render_commands_pool = retval->next;
        retval->next = NULL;
    } else {
        retval = SDL_calloc(1, sizeof (*retval));
        if (!retval) {
            SDL_OutOfMemory();
            return NULL;
        }
    }
 
    SDL_assert((renderer->render_commands == NULL) == (renderer->render_commands_tail == NULL));
    if (renderer->render_commands_tail != NULL) {
        renderer->render_commands_tail->next = retval;
    } else {
        renderer->render_commands = retval;
    }
    renderer->render_commands_tail = retval;
 
    return retval;
}

References SDL_RenderCommand::next, NULL, SDL_Renderer::render_commands, SDL_Renderer::render_commands_pool, SDL_Renderer::render_commands_tail, renderer, retval, SDL_assert, SDL_calloc, and SDL_OutOfMemory.

Referenced by PrepQueueCmdDrawSolid(), PrepQueueCmdDrawTexture(), QueueCmdClear(), QueueCmdSetClipRect(), QueueCmdSetDrawColor(), and QueueCmdSetViewport().

DebugLogRenderCommands()

static SDL_INLINE void DebugLogRenderCommands ( const SDL_RenderCommand *  cmd )

static

Definition at line 117 of file SDL_render.c.

{
#if 0
    unsigned int i = 1;
    SDL_Log("Render commands to flush:");
    while (cmd) {
        switch (cmd->command) {
            case SDL_RENDERCMD_NO_OP:
                SDL_Log(" %u. no-op", i++);
                break;
 
            case SDL_RENDERCMD_SETVIEWPORT:
                SDL_Log(" %u. set viewport (first=%u, rect={(%d, %d), %dx%d})", i++,
                        (unsigned int) cmd->data.viewport.first,
                        cmd->data.viewport.rect.x, cmd->data.viewport.rect.y,
                        cmd->data.viewport.rect.w, cmd->data.viewport.rect.h);
                break;
 
            case SDL_RENDERCMD_SETCLIPRECT:
                SDL_Log(" %u. set cliprect (enabled=%s, rect={(%d, %d), %dx%d})", i++,
                        cmd->data.cliprect.enabled ? "true" : "false",
                        cmd->data.cliprect.rect.x, cmd->data.cliprect.rect.y,
                        cmd->data.cliprect.rect.w, cmd->data.cliprect.rect.h);
                break;
 
            case SDL_RENDERCMD_SETDRAWCOLOR:
                SDL_Log(" %u. set draw color (first=%u, r=%d, g=%d, b=%d, a=%d)", i++,
                        (unsigned int) cmd->data.color.first,
                        (int) cmd->data.color.r, (int) cmd->data.color.g,
                        (int) cmd->data.color.b, (int) cmd->data.color.a);
                break;
 
            case SDL_RENDERCMD_CLEAR:
                SDL_Log(" %u. clear (first=%u, r=%d, g=%d, b=%d, a=%d)", i++,
                        (unsigned int) cmd->data.color.first,
                        (int) cmd->data.color.r, (int) cmd->data.color.g,
                        (int) cmd->data.color.b, (int) cmd->data.color.a);
                break;
 
            case SDL_RENDERCMD_DRAW_POINTS:
                SDL_Log(" %u. draw points (first=%u, count=%u, r=%d, g=%d, b=%d, a=%d, blend=%d)", i++,
                        (unsigned int) cmd->data.draw.first,
                        (unsigned int) cmd->data.draw.count,
                        (int) cmd->data.draw.r, (int) cmd->data.draw.g,
                        (int) cmd->data.draw.b, (int) cmd->data.draw.a,
                        (int) cmd->data.draw.blend);
                break;
 
            case SDL_RENDERCMD_DRAW_LINES:
                SDL_Log(" %u. draw lines (first=%u, count=%u, r=%d, g=%d, b=%d, a=%d, blend=%d)", i++,
                        (unsigned int) cmd->data.draw.first,
                        (unsigned int) cmd->data.draw.count,
                        (int) cmd->data.draw.r, (int) cmd->data.draw.g,
                        (int) cmd->data.draw.b, (int) cmd->data.draw.a,
                        (int) cmd->data.draw.blend);
                break;
 
            case SDL_RENDERCMD_FILL_RECTS:
                SDL_Log(" %u. fill rects (first=%u, count=%u, r=%d, g=%d, b=%d, a=%d, blend=%d)", i++,
                        (unsigned int) cmd->data.draw.first,
                        (unsigned int) cmd->data.draw.count,
                        (int) cmd->data.draw.r, (int) cmd->data.draw.g,
                        (int) cmd->data.draw.b, (int) cmd->data.draw.a,
                        (int) cmd->data.draw.blend);
                break;
 
            case SDL_RENDERCMD_COPY:
                SDL_Log(" %u. copy (first=%u, count=%u, r=%d, g=%d, b=%d, a=%d, blend=%d, tex=%p)", i++,
                        (unsigned int) cmd->data.draw.first,
                        (unsigned int) cmd->data.draw.count,
                        (int) cmd->data.draw.r, (int) cmd->data.draw.g,
                        (int) cmd->data.draw.b, (int) cmd->data.draw.a,
                        (int) cmd->data.draw.blend, cmd->data.draw.texture);
                break;
 
 
            case SDL_RENDERCMD_COPY_EX:
                SDL_Log(" %u. copyex (first=%u, count=%u, r=%d, g=%d, b=%d, a=%d, blend=%d, tex=%p)", i++,
                        (unsigned int) cmd->data.draw.first,
                        (unsigned int) cmd->data.draw.count,
                        (int) cmd->data.draw.r, (int) cmd->data.draw.g,
                        (int) cmd->data.draw.b, (int) cmd->data.draw.a,
                        (int) cmd->data.draw.blend, cmd->data.draw.texture);
                break;
        }
        cmd = cmd->next;
    }
#endif
}

References SDL_RenderCommand::cliprect, SDL_RenderCommand::color, SDL_RenderCommand::command, SDL_RenderCommand::data, SDL_RenderCommand::draw, i, SDL_RenderCommand::next, SDL_Log, SDL_RENDERCMD_CLEAR, SDL_RENDERCMD_COPY, SDL_RENDERCMD_COPY_EX, SDL_RENDERCMD_DRAW_LINES, SDL_RENDERCMD_DRAW_POINTS, SDL_RENDERCMD_FILL_RECTS, SDL_RENDERCMD_NO_OP, SDL_RENDERCMD_SETCLIPRECT, SDL_RENDERCMD_SETDRAWCOLOR, SDL_RENDERCMD_SETVIEWPORT, and SDL_RenderCommand::viewport.

Referenced by FlushRenderCommands().

FlushRenderCommands()

static int FlushRenderCommands ( SDL_Renderer *  renderer )

static

Definition at line 208 of file SDL_render.c.

{
    int retval;
 
    SDL_assert((renderer->render_commands == NULL) == (renderer->render_commands_tail == NULL));
 
    if (renderer->render_commands == NULL) {  /* nothing to do! */
        SDL_assert(renderer->vertex_data_used == 0);
        return 0;
    }
 
    DebugLogRenderCommands(renderer->render_commands);
 
    retval = renderer->RunCommandQueue(renderer, renderer->render_commands, renderer->vertex_data, renderer->vertex_data_used);
 
    /* Move the whole render command queue to the unused pool so we can reuse them next time. */
    if (renderer->render_commands_tail != NULL) {
        renderer->render_commands_tail->next = renderer->render_commands_pool;
        renderer->render_commands_pool = renderer->render_commands;
        renderer->render_commands_tail = NULL;
        renderer->render_commands = NULL;
    }
    renderer->vertex_data_used = 0;
    renderer->render_command_generation++;
    renderer->color_queued = SDL_FALSE;
    renderer->viewport_queued = SDL_FALSE;
    renderer->cliprect_queued = SDL_FALSE;
    return retval;
}

References SDL_Renderer::cliprect_queued, SDL_Renderer::color_queued, DebugLogRenderCommands(), SDL_RenderCommand::next, NULL, SDL_Renderer::render_command_generation, SDL_Renderer::render_commands, SDL_Renderer::render_commands_pool, SDL_Renderer::render_commands_tail, renderer, retval, SDL_Renderer::RunCommandQueue, SDL_assert, SDL_FALSE, SDL_Renderer::vertex_data, SDL_Renderer::vertex_data_used, and SDL_Renderer::viewport_queued.

Referenced by FlushRenderCommandsIfNotBatching(), FlushRenderCommandsIfTextureNeeded(), SDL_RenderFlush(), SDL_RenderGetMetalCommandEncoder(), SDL_RenderGetMetalLayer(), SDL_RenderPresent(), SDL_RenderReadPixels(), and SDL_SetRenderTarget().

FlushRenderCommandsIfNotBatching()

static SDL_INLINE int FlushRenderCommandsIfNotBatching ( SDL_Renderer *  renderer )

static

Definition at line 250 of file SDL_render.c.

{
    return renderer->batching ? 0 : FlushRenderCommands(renderer);
}

References SDL_Renderer::batching, FlushRenderCommands(), and renderer.

Referenced by RenderDrawLinesWithRects(), RenderDrawLinesWithRectsF(), RenderDrawPointsWithRects(), RenderDrawPointsWithRectsF(), SDL_RenderClear(), SDL_RenderCopyExF(), SDL_RenderCopyF(), SDL_RenderDrawLines(), SDL_RenderDrawLinesF(), SDL_RenderDrawPoints(), SDL_RenderDrawPointsF(), SDL_RendererEventWatch(), SDL_RenderFillRects(), SDL_RenderFillRectsF(), SDL_RenderSetClipRect(), SDL_RenderSetViewport(), and SDL_SetRenderTarget().

FlushRenderCommandsIfTextureNeeded()

static int FlushRenderCommandsIfTextureNeeded ( SDL_Texture *  texture )

static

Definition at line 239 of file SDL_render.c.

{
    SDL_Renderer *renderer = texture->renderer;
    if (texture->last_command_generation == renderer->render_command_generation) {
        /* the current command queue depends on this texture, flush the queue now before it changes */
        return FlushRenderCommands(renderer);
    }
    return 0;
}

References FlushRenderCommands(), SDL_Renderer::render_command_generation, and renderer.

Referenced by SDL_DestroyTexture(), SDL_GL_BindTexture(), SDL_GL_UnbindTexture(), SDL_LockTexture(), SDL_UpdateTexture(), and SDL_UpdateYUVTexture().

GetClosestSupportedFormat()

static Uint32 GetClosestSupportedFormat ( SDL_Renderer *  renderer, Uint32  format  )

static

Definition at line 1024 of file SDL_render.c.

{
    Uint32 i;
 
    if (SDL_ISPIXELFORMAT_FOURCC(format)) {
        /* Look for an exact match */
        for (i = 0; i < renderer->info.num_texture_formats; ++i) {
            if (renderer->info.texture_formats[i] == format) {
                return renderer->info.texture_formats[i];
            }
        }
    } else {
        SDL_bool hasAlpha = SDL_ISPIXELFORMAT_ALPHA(format);
 
        /* We just want to match the first format that has the same channels */
        for (i = 0; i < renderer->info.num_texture_formats; ++i) {
            if (!SDL_ISPIXELFORMAT_FOURCC(renderer->info.texture_formats[i]) &&
                SDL_ISPIXELFORMAT_ALPHA(renderer->info.texture_formats[i]) == hasAlpha) {
                return renderer->info.texture_formats[i];
            }
        }
    }
    return renderer->info.texture_formats[0];
}

References i, SDL_Renderer::info, SDL_RendererInfo::num_texture_formats, renderer, SDL_ISPIXELFORMAT_ALPHA, SDL_ISPIXELFORMAT_FOURCC, and SDL_RendererInfo::texture_formats.

Referenced by SDL_CreateTexture().

GetWindowViewportValues()

static void GetWindowViewportValues ( SDL_Renderer *  renderer, int *  logical_w, int *  logical_h, SDL_Rect *  viewport, SDL_FPoint *  scale  )

static

Definition at line 576 of file SDL_render.c.

{
    SDL_LockMutex(renderer->target_mutex);
    *logical_w = renderer->target ? renderer->logical_w_backup : renderer->logical_w;
    *logical_h = renderer->target ? renderer->logical_h_backup : renderer->logical_h;
    *viewport = renderer->target ? renderer->viewport_backup : renderer->viewport;
    *scale = renderer->target ? renderer->scale_backup : renderer->scale;
    SDL_UnlockMutex(renderer->target_mutex);
}

References SDL_Renderer::logical_h, SDL_Renderer::logical_h_backup, SDL_Renderer::logical_w, SDL_Renderer::logical_w_backup, renderer, SDL_Renderer::scale, SDL_Renderer::scale_backup, SDL_LockMutex, SDL_UnlockMutex, SDL_Renderer::target, SDL_Renderer::target_mutex, SDL_Renderer::viewport, viewport, and SDL_Renderer::viewport_backup.

Referenced by SDL_RendererEventWatch().

IsSupportedBlendMode()

static SDL_bool IsSupportedBlendMode ( SDL_Renderer *  renderer, SDL_BlendMode  blendMode  )

static

Definition at line 993 of file SDL_render.c.

{
    switch (blendMode)
    {
    /* These are required to be supported by all renderers */
    case SDL_BLENDMODE_NONE:
    case SDL_BLENDMODE_BLEND:
    case SDL_BLENDMODE_ADD:
    case SDL_BLENDMODE_MOD:
    case SDL_BLENDMODE_MUL:
        return SDL_TRUE;
 
    default:
        return renderer->SupportsBlendMode && renderer->SupportsBlendMode(renderer, blendMode);
    }
}

References blendMode, renderer, SDL_BLENDMODE_ADD, SDL_BLENDMODE_BLEND, SDL_BLENDMODE_MOD, SDL_BLENDMODE_MUL, SDL_BLENDMODE_NONE, SDL_TRUE, and SDL_Renderer::SupportsBlendMode.

Referenced by SDL_SetRenderDrawBlendMode(), and SDL_SetTextureBlendMode().

IsSupportedFormat()

static SDL_bool IsSupportedFormat ( SDL_Renderer *  renderer, Uint32  format  )

static

Definition at line 1011 of file SDL_render.c.

{
    Uint32 i;
 
    for (i = 0; i < renderer->info.num_texture_formats; ++i) {
        if (renderer->info.texture_formats[i] == format) {
            return SDL_TRUE;
        }
    }
    return SDL_FALSE;
}

References i, SDL_Renderer::info, SDL_RendererInfo::num_texture_formats, renderer, SDL_FALSE, SDL_TRUE, and SDL_RendererInfo::texture_formats.

Referenced by SDL_CreateTexture().

PrepQueueCmdDraw()

static int PrepQueueCmdDraw ( SDL_Renderer *  renderer, const Uint8  r, const Uint8  g, const Uint8  b, const Uint8  a  )

static

Definition at line 416 of file SDL_render.c.

{
    int retval = QueueCmdSetDrawColor(renderer, r, g, b, a);
 
    /* Set the viewport and clip rect directly before draws, so the backends
     * don't have to worry about that state not being valid at draw time. */
    if (retval == 0 && !renderer->viewport_queued) {
        retval = QueueCmdSetViewport(renderer);
    }
    if (retval == 0 && !renderer->cliprect_queued) {
        retval = QueueCmdSetClipRect(renderer);
    }
    return retval;
}

References SDL_Renderer::cliprect_queued, QueueCmdSetClipRect(), QueueCmdSetDrawColor(), QueueCmdSetViewport(), renderer, retval, and SDL_Renderer::viewport_queued.

Referenced by PrepQueueCmdDrawSolid(), and PrepQueueCmdDrawTexture().

PrepQueueCmdDrawSolid()

static SDL_RenderCommand* PrepQueueCmdDrawSolid ( SDL_Renderer *  renderer, const SDL_RenderCommandType  cmdtype  )

static

Definition at line 432 of file SDL_render.c.

{
    /* !!! FIXME: drop this draw if viewport w or h is zero. */
    SDL_RenderCommand *cmd = NULL;
    if (PrepQueueCmdDraw(renderer, renderer->r, renderer->g, renderer->b, renderer->a) == 0) {
        cmd = AllocateRenderCommand(renderer);
        if (cmd != NULL) {
            cmd->command = cmdtype;
            cmd->data.draw.first = 0;  /* render backend will fill this in. */
            cmd->data.draw.count = 0;  /* render backend will fill this in. */
            cmd->data.draw.r = renderer->r;
            cmd->data.draw.g = renderer->g;
            cmd->data.draw.b = renderer->b;
            cmd->data.draw.a = renderer->a;
            cmd->data.draw.blend = renderer->blendMode;
            cmd->data.draw.texture = NULL;  /* no texture. */
        }
    }
    return cmd;
}

References SDL_Renderer::a, AllocateRenderCommand(), SDL_Renderer::b, SDL_Renderer::blendMode, SDL_RenderCommand::command, SDL_RenderCommand::data, SDL_RenderCommand::draw, SDL_Renderer::g, NULL, PrepQueueCmdDraw(), SDL_Renderer::r, and renderer.

Referenced by QueueCmdDrawLines(), QueueCmdDrawPoints(), and QueueCmdFillRects().

PrepQueueCmdDrawTexture()

static SDL_RenderCommand* PrepQueueCmdDrawTexture ( SDL_Renderer *  renderer, SDL_Texture *  texture, const SDL_RenderCommandType  cmdtype  )

static

Definition at line 496 of file SDL_render.c.

{
    /* !!! FIXME: drop this draw if viewport w or h is zero. */
    SDL_RenderCommand *cmd = NULL;
    if (PrepQueueCmdDraw(renderer, texture->r, texture->g, texture->b, texture->a) == 0) {
        cmd = AllocateRenderCommand(renderer);
        if (cmd != NULL) {
            cmd->command = cmdtype;
            cmd->data.draw.first = 0;  /* render backend will fill this in. */
            cmd->data.draw.count = 0;  /* render backend will fill this in. */
            cmd->data.draw.r = texture->r;
            cmd->data.draw.g = texture->g;
            cmd->data.draw.b = texture->b;
            cmd->data.draw.a = texture->a;
            cmd->data.draw.blend = texture->blendMode;
            cmd->data.draw.texture = texture;
        }
    }
    return cmd;
}

References AllocateRenderCommand(), SDL_RenderCommand::command, SDL_RenderCommand::data, SDL_RenderCommand::draw, NULL, PrepQueueCmdDraw(), SDL_Renderer::r, and renderer.

Referenced by QueueCmdCopy(), and QueueCmdCopyEx().

QueueCmdClear()

static int QueueCmdClear ( SDL_Renderer *  renderer )

static

Definition at line 399 of file SDL_render.c.

{
    SDL_RenderCommand *cmd = AllocateRenderCommand(renderer);
    if (cmd == NULL) {
        return -1;
    }
 
    cmd->command = SDL_RENDERCMD_CLEAR;
    cmd->data.color.first = 0;
    cmd->data.color.r = renderer->r;
    cmd->data.color.g = renderer->g;
    cmd->data.color.b = renderer->b;
    cmd->data.color.a = renderer->a;
    return 0;
}

References SDL_Renderer::a, AllocateRenderCommand(), SDL_Renderer::b, SDL_RenderCommand::color, SDL_RenderCommand::command, SDL_RenderCommand::data, SDL_Renderer::g, NULL, SDL_Renderer::r, renderer, and SDL_RENDERCMD_CLEAR.

Referenced by SDL_RenderClear().

QueueCmdCopy()

static int QueueCmdCopy ( SDL_Renderer *  renderer, SDL_Texture *  texture, const SDL_Rect *  srcrect, const SDL_FRect *  dstrect  )

static

Definition at line 518 of file SDL_render.c.

{
    SDL_RenderCommand *cmd = PrepQueueCmdDrawTexture(renderer, texture, SDL_RENDERCMD_COPY);
    int retval = -1;
    if (cmd != NULL) {
        retval = renderer->QueueCopy(renderer, cmd, texture, srcrect, dstrect);
        if (retval < 0) {
            cmd->command = SDL_RENDERCMD_NO_OP;
        }
    }
    return retval;
}

References SDL_RenderCommand::command, NULL, PrepQueueCmdDrawTexture(), SDL_Renderer::QueueCopy, renderer, retval, SDL_RENDERCMD_COPY, and SDL_RENDERCMD_NO_OP.

Referenced by SDL_RenderCopyF().

QueueCmdCopyEx()

static int QueueCmdCopyEx ( SDL_Renderer *  renderer, SDL_Texture *  texture, const SDL_Rect *  srcquad, const SDL_FRect *  dstrect, const double  angle, const SDL_FPoint *  center, const SDL_RendererFlip  flip  )

static

Definition at line 532 of file SDL_render.c.

{
    SDL_RenderCommand *cmd = PrepQueueCmdDrawTexture(renderer, texture, SDL_RENDERCMD_COPY_EX);
    int retval = -1;
    SDL_assert(renderer->QueueCopyEx != NULL);  /* should have caught at higher level. */
    if (cmd != NULL) {
        retval = renderer->QueueCopyEx(renderer, cmd, texture, srcquad, dstrect, angle, center, flip);
        if (retval < 0) {
            cmd->command = SDL_RENDERCMD_NO_OP;
        }
    }
    return retval;
}

References SDL_RenderCommand::command, NULL, PrepQueueCmdDrawTexture(), SDL_Renderer::QueueCopyEx, renderer, retval, SDL_assert, SDL_RENDERCMD_COPY_EX, and SDL_RENDERCMD_NO_OP.

Referenced by SDL_RenderCopyExF().

QueueCmdDrawLines()

static int QueueCmdDrawLines ( SDL_Renderer *  renderer, const SDL_FPoint *  points, const int  count  )

static

Definition at line 468 of file SDL_render.c.

{
    SDL_RenderCommand *cmd = PrepQueueCmdDrawSolid(renderer, SDL_RENDERCMD_DRAW_LINES);
    int retval = -1;
    if (cmd != NULL) {
        retval = renderer->QueueDrawLines(renderer, cmd, points, count);
        if (retval < 0) {
            cmd->command = SDL_RENDERCMD_NO_OP;
        }
    }
    return retval;
}

References SDL_RenderCommand::command, NULL, PrepQueueCmdDrawSolid(), SDL_Renderer::QueueDrawLines, renderer, retval, SDL_RENDERCMD_DRAW_LINES, and SDL_RENDERCMD_NO_OP.

Referenced by RenderDrawLinesWithRects(), RenderDrawLinesWithRectsF(), SDL_RenderDrawLines(), and SDL_RenderDrawLinesF().

QueueCmdDrawPoints()

static int QueueCmdDrawPoints ( SDL_Renderer *  renderer, const SDL_FPoint *  points, const int  count  )

static

Definition at line 454 of file SDL_render.c.

{
    SDL_RenderCommand *cmd = PrepQueueCmdDrawSolid(renderer, SDL_RENDERCMD_DRAW_POINTS);
    int retval = -1;
    if (cmd != NULL) {
        retval = renderer->QueueDrawPoints(renderer, cmd, points, count);
        if (retval < 0) {
            cmd->command = SDL_RENDERCMD_NO_OP;
        }
    }
    return retval;
}

References SDL_RenderCommand::command, NULL, PrepQueueCmdDrawSolid(), SDL_Renderer::QueueDrawPoints, renderer, retval, SDL_RENDERCMD_DRAW_POINTS, and SDL_RENDERCMD_NO_OP.

Referenced by SDL_RenderDrawPoints(), and SDL_RenderDrawPointsF().

QueueCmdFillRects()

static int QueueCmdFillRects ( SDL_Renderer *  renderer, const SDL_FRect *  rects, const int  count  )

static

Definition at line 482 of file SDL_render.c.

{
    SDL_RenderCommand *cmd = PrepQueueCmdDrawSolid(renderer, SDL_RENDERCMD_FILL_RECTS);
    int retval = -1;
    if (cmd != NULL) {
        retval = renderer->QueueFillRects(renderer, cmd, rects, count);
        if (retval < 0) {
            cmd->command = SDL_RENDERCMD_NO_OP;
        }
    }
    return retval;
}

References SDL_RenderCommand::command, NULL, PrepQueueCmdDrawSolid(), SDL_Renderer::QueueFillRects, renderer, retval, SDL_RENDERCMD_FILL_RECTS, and SDL_RENDERCMD_NO_OP.

Referenced by RenderDrawLinesWithRects(), RenderDrawLinesWithRectsF(), RenderDrawPointsWithRects(), RenderDrawPointsWithRectsF(), SDL_RenderFillRects(), and SDL_RenderFillRectsF().

QueueCmdSetClipRect()

static int QueueCmdSetClipRect ( SDL_Renderer *  renderer )

static

Definition at line 348 of file SDL_render.c.

{
    int retval = 0;
    if ((!renderer->cliprect_queued) ||
         (renderer->clipping_enabled != renderer->last_queued_cliprect_enabled) ||
         (SDL_memcmp(&renderer->clip_rect, &renderer->last_queued_cliprect, sizeof (SDL_Rect)) != 0)) {
        SDL_RenderCommand *cmd = AllocateRenderCommand(renderer);
        if (cmd == NULL) {
            retval = -1;
        } else {
            cmd->command = SDL_RENDERCMD_SETCLIPRECT;
            cmd->data.cliprect.enabled = renderer->clipping_enabled;
            SDL_memcpy(&cmd->data.cliprect.rect, &renderer->clip_rect, sizeof (cmd->data.cliprect.rect));
            SDL_memcpy(&renderer->last_queued_cliprect, &renderer->clip_rect, sizeof (SDL_Rect));
            renderer->last_queued_cliprect_enabled = renderer->clipping_enabled;
            renderer->cliprect_queued = SDL_TRUE;
        }
    }
    return retval;
}

References AllocateRenderCommand(), SDL_Renderer::clip_rect, SDL_Renderer::clipping_enabled, SDL_RenderCommand::cliprect, SDL_Renderer::cliprect_queued, SDL_RenderCommand::command, SDL_RenderCommand::data, SDL_Renderer::last_queued_cliprect, SDL_Renderer::last_queued_cliprect_enabled, NULL, renderer, retval, SDL_memcmp, SDL_memcpy, SDL_RENDERCMD_SETCLIPRECT, and SDL_TRUE.

Referenced by PrepQueueCmdDraw(), SDL_RenderSetClipRect(), and SDL_SetRenderTarget().

QueueCmdSetDrawColor()

static int QueueCmdSetDrawColor ( SDL_Renderer *  renderer, const Uint8  r, const Uint8  g, const Uint8  b, const Uint8  a  )

static

Definition at line 370 of file SDL_render.c.

{
    const Uint32 color = ((a << 24) | (r << 16) | (g << 8) | b);
    int retval = 0;
    
    if (!renderer->color_queued || (color != renderer->last_queued_color)) {
        SDL_RenderCommand *cmd = AllocateRenderCommand(renderer);
        retval = -1;
 
        if (cmd != NULL) {
            cmd->command = SDL_RENDERCMD_SETDRAWCOLOR;
            cmd->data.color.first = 0;  /* render backend will fill this in. */
            cmd->data.color.r = r;
            cmd->data.color.g = g;
            cmd->data.color.b = b;
            cmd->data.color.a = a;
            retval = renderer->QueueSetDrawColor(renderer, cmd);
            if (retval < 0) {
                cmd->command = SDL_RENDERCMD_NO_OP;
            } else {
                renderer->last_queued_color = color;
                renderer->color_queued = SDL_TRUE;
            }
        }
    }
    return retval;
}

References AllocateRenderCommand(), SDL_RenderCommand::color, SDL_Renderer::color_queued, SDL_RenderCommand::command, SDL_RenderCommand::data, SDL_Renderer::last_queued_color, NULL, SDL_Renderer::QueueSetDrawColor, renderer, retval, SDL_RENDERCMD_NO_OP, SDL_RENDERCMD_SETDRAWCOLOR, and SDL_TRUE.

Referenced by PrepQueueCmdDraw().

QueueCmdSetViewport()

static int QueueCmdSetViewport ( SDL_Renderer *  renderer )

static

Definition at line 325 of file SDL_render.c.

{
    int retval = 0;
    if (!renderer->viewport_queued || (SDL_memcmp(&renderer->viewport, &renderer->last_queued_viewport, sizeof (SDL_Rect)) != 0)) {
        SDL_RenderCommand *cmd = AllocateRenderCommand(renderer);
        retval = -1;
        if (cmd != NULL) {
            cmd->command = SDL_RENDERCMD_SETVIEWPORT;
            cmd->data.viewport.first = 0;  /* render backend will fill this in. */
            SDL_memcpy(&cmd->data.viewport.rect, &renderer->viewport, sizeof (renderer->viewport));
            retval = renderer->QueueSetViewport(renderer, cmd);
            if (retval < 0) {
                cmd->command = SDL_RENDERCMD_NO_OP;
            } else {
                SDL_memcpy(&renderer->last_queued_viewport, &renderer->viewport, sizeof (SDL_Rect));
                renderer->viewport_queued = SDL_TRUE;
            }
        }
    }
    return retval;
}

References AllocateRenderCommand(), SDL_RenderCommand::command, SDL_RenderCommand::data, SDL_Renderer::last_queued_viewport, NULL, SDL_Renderer::QueueSetViewport, renderer, retval, SDL_memcmp, SDL_memcpy, SDL_RENDERCMD_NO_OP, SDL_RENDERCMD_SETVIEWPORT, SDL_TRUE, SDL_RenderCommand::viewport, SDL_Renderer::viewport, and SDL_Renderer::viewport_queued.

Referenced by PrepQueueCmdDraw(), SDL_RendererEventWatch(), SDL_RenderSetViewport(), and SDL_SetRenderTarget().

RenderDrawLinesWithRects()

static int RenderDrawLinesWithRects ( SDL_Renderer *  renderer, const SDL_Point *  points, const int  count  )

static

Definition at line 2469 of file SDL_render.c.

{
    SDL_FRect *frect;
    SDL_FRect *frects;
    SDL_FPoint fpoints[2];
    int i, nrects = 0;
    int retval = 0;
    SDL_bool isstack;
 
    frects = SDL_small_alloc(SDL_FRect, count-1, &isstack);
    if (!frects) {
        return SDL_OutOfMemory();
    }
 
    for (i = 0; i < count-1; ++i) {
        if (points[i].x == points[i+1].x) {
            const int minY = SDL_min(points[i].y, points[i+1].y);
            const int maxY = SDL_max(points[i].y, points[i+1].y);
 
            frect = &frects[nrects++];
            frect->x = points[i].x * renderer->scale.x;
            frect->y = minY * renderer->scale.y;
            frect->w = renderer->scale.x;
            frect->h = (maxY - minY + 1) * renderer->scale.y;
        } else if (points[i].y == points[i+1].y) {
            const int minX = SDL_min(points[i].x, points[i+1].x);
            const int maxX = SDL_max(points[i].x, points[i+1].x);
 
            frect = &frects[nrects++];
            frect->x = minX * renderer->scale.x;
            frect->y = points[i].y * renderer->scale.y;
            frect->w = (maxX - minX + 1) * renderer->scale.x;
            frect->h = renderer->scale.y;
        } else {
            /* FIXME: We can't use a rect for this line... */
            fpoints[0].x = points[i].x * renderer->scale.x;
            fpoints[0].y = points[i].y * renderer->scale.y;
            fpoints[1].x = points[i+1].x * renderer->scale.x;
            fpoints[1].y = points[i+1].y * renderer->scale.y;
            retval += QueueCmdDrawLines(renderer, fpoints, 2);
        }
    }
 
    retval += QueueCmdFillRects(renderer, frects, nrects);
 
    SDL_small_free(frects, isstack);
 
    if (retval < 0) {
        retval = -1;
    }
    return retval < 0 ? retval : FlushRenderCommandsIfNotBatching(renderer);
}

References FlushRenderCommandsIfNotBatching(), SDL_FRect::h, i, QueueCmdDrawLines(), QueueCmdFillRects(), renderer, retval, SDL_Renderer::scale, SDL_max, SDL_min, SDL_OutOfMemory, SDL_small_alloc, SDL_small_free, SDL_FRect::w, SDL_FPoint::x, SDL_FRect::x, SDL_FPoint::y, and SDL_FRect::y.

Referenced by SDL_RenderDrawLines().

RenderDrawLinesWithRectsF()

static int RenderDrawLinesWithRectsF ( SDL_Renderer *  renderer, const SDL_FPoint *  points, const int  count  )

static

Definition at line 2524 of file SDL_render.c.

{
    SDL_FRect *frect;
    SDL_FRect *frects;
    SDL_FPoint fpoints[2];
    int i, nrects = 0;
    int retval = 0;
    SDL_bool isstack;
 
    frects = SDL_small_alloc(SDL_FRect, count-1, &isstack);
    if (!frects) {
        return SDL_OutOfMemory();
    }
 
    for (i = 0; i < count-1; ++i) {
        if (points[i].x == points[i+1].x) {
            const int minY = (int)SDL_min(points[i].y, points[i+1].y);
            const int maxY = (int)SDL_max(points[i].y, points[i+1].y);
 
            frect = &frects[nrects++];
            frect->x = points[i].x * renderer->scale.x;
            frect->y = minY * renderer->scale.y;
            frect->w = renderer->scale.x;
            frect->h = (maxY - minY + 1) * renderer->scale.y;
        } else if (points[i].y == points[i+1].y) {
            const int minX = (int)SDL_min(points[i].x, points[i+1].x);
            const int maxX = (int)SDL_max(points[i].x, points[i+1].x);
 
            frect = &frects[nrects++];
            frect->x = minX * renderer->scale.x;
            frect->y = points[i].y * renderer->scale.y;
            frect->w = (maxX - minX + 1) * renderer->scale.x;
            frect->h = renderer->scale.y;
        } else {
            /* FIXME: We can't use a rect for this line... */
            fpoints[0].x = points[i].x * renderer->scale.x;
            fpoints[0].y = points[i].y * renderer->scale.y;
            fpoints[1].x = points[i+1].x * renderer->scale.x;
            fpoints[1].y = points[i+1].y * renderer->scale.y;
            retval += QueueCmdDrawLines(renderer, fpoints, 2);
        }
    }
 
    retval += QueueCmdFillRects(renderer, frects, nrects);
 
    SDL_small_free(frects, isstack);
 
    if (retval < 0) {
        retval = -1;
    }
    return retval < 0 ? retval : FlushRenderCommandsIfNotBatching(renderer);
}

References FlushRenderCommandsIfNotBatching(), SDL_FRect::h, i, int(), QueueCmdDrawLines(), QueueCmdFillRects(), renderer, retval, SDL_Renderer::scale, SDL_max, SDL_min, SDL_OutOfMemory, SDL_small_alloc, SDL_small_free, SDL_FRect::w, SDL_FPoint::x, SDL_FRect::x, SDL_FPoint::y, and SDL_FRect::y.

Referenced by SDL_RenderDrawLinesF().

RenderDrawPointsWithRects()

static int RenderDrawPointsWithRects ( SDL_Renderer *  renderer, const SDL_Point *  points, const int  count  )

static

Definition at line 2307 of file SDL_render.c.

{
    int retval = -1;
    SDL_bool isstack;
    SDL_FRect *frects = SDL_small_alloc(SDL_FRect, count, &isstack);
    int i;
 
    if (!frects) {
        return SDL_OutOfMemory();
    }
 
    for (i = 0; i < count; ++i) {
        frects[i].x = points[i].x * renderer->scale.x;
        frects[i].y = points[i].y * renderer->scale.y;
        frects[i].w = renderer->scale.x;
        frects[i].h = renderer->scale.y;
    }
 
    retval = QueueCmdFillRects(renderer, frects, count);
 
    SDL_small_free(frects, isstack);
 
    return retval < 0 ? retval : FlushRenderCommandsIfNotBatching(renderer);
}

References FlushRenderCommandsIfNotBatching(), SDL_FRect::h, i, QueueCmdFillRects(), renderer, retval, SDL_Renderer::scale, SDL_OutOfMemory, SDL_small_alloc, SDL_small_free, SDL_FRect::w, SDL_FPoint::x, SDL_FRect::x, SDL_FPoint::y, and SDL_FRect::y.

Referenced by SDL_RenderDrawPoints().

RenderDrawPointsWithRectsF()

static int RenderDrawPointsWithRectsF ( SDL_Renderer *  renderer, const SDL_FPoint *  fpoints, const int  count  )

static

Definition at line 2377 of file SDL_render.c.

{
    int retval = -1;
    SDL_bool isstack;
    SDL_FRect *frects = SDL_small_alloc(SDL_FRect, count, &isstack);
    int i;
 
    if (!frects) {
        return SDL_OutOfMemory();
    }
 
    for (i = 0; i < count; ++i) {
        frects[i].x = fpoints[i].x * renderer->scale.x;
        frects[i].y = fpoints[i].y * renderer->scale.y;
        frects[i].w = renderer->scale.x;
        frects[i].h = renderer->scale.y;
    }
 
    retval = QueueCmdFillRects(renderer, frects, count);
 
    SDL_small_free(frects, isstack);
 
    return retval < 0 ? retval : FlushRenderCommandsIfNotBatching(renderer);
}

References FlushRenderCommandsIfNotBatching(), SDL_FRect::h, i, QueueCmdFillRects(), renderer, retval, SDL_Renderer::scale, SDL_OutOfMemory, SDL_small_alloc, SDL_small_free, SDL_FRect::w, SDL_FPoint::x, SDL_FRect::x, SDL_FPoint::y, and SDL_FRect::y.

Referenced by SDL_RenderDrawPointsF().

SDL_AllocateRenderVertices()

void* SDL_AllocateRenderVertices	(	SDL_Renderer *	renderer,
		const size_t	numbytes,
		const size_t	alignment,
		size_t *	offset
	)

Definition at line 262 of file SDL_render.c.

{
    const size_t needed = renderer->vertex_data_used + numbytes + alignment;
    size_t current_offset = renderer->vertex_data_used;
 
    size_t aligner = (alignment && ((current_offset & (alignment - 1)) != 0)) ? (alignment - (current_offset & (alignment - 1))) : 0;
    size_t aligned = current_offset + aligner;
 
    if (renderer->vertex_data_allocation < needed) {
        const size_t current_allocation = renderer->vertex_data ? renderer->vertex_data_allocation : 1024;
        size_t newsize = current_allocation * 2;
        void *ptr;
        while (newsize < needed) {
            newsize *= 2;
        }
        ptr = SDL_realloc(renderer->vertex_data, newsize);
        if (ptr == NULL) {
            SDL_OutOfMemory();
            return NULL;
        }
        renderer->vertex_data = ptr;
        renderer->vertex_data_allocation = newsize;
    }
 
    if (offset) {
        *offset = aligned;
    }
 
    renderer->vertex_data_used += aligner + numbytes;
 
    return ((Uint8 *) renderer->vertex_data) + aligned;
}

References NULL, numbytes, ptr, renderer, SDL_OutOfMemory, SDL_realloc, SDL_Renderer::vertex_data, SDL_Renderer::vertex_data_allocation, and SDL_Renderer::vertex_data_used.

Referenced by SW_QueueCopy(), SW_QueueCopyEx(), SW_QueueDrawPoints(), and SW_QueueFillRects().

SDL_ComposeCustomBlendMode()

SDL_BlendMode SDL_ComposeCustomBlendMode	(	SDL_BlendFactor	srcColorFactor,
		SDL_BlendFactor	dstColorFactor,
		SDL_BlendOperation	colorOperation,
		SDL_BlendFactor	srcAlphaFactor,
		SDL_BlendFactor	dstAlphaFactor,
		SDL_BlendOperation	alphaOperation
	)

Create a custom blend mode, which may or may not be supported by a given renderer.

Parameters

srcColorFactor	source color factor
dstColorFactor	destination color factor
colorOperation	color operation
srcAlphaFactor	source alpha factor
dstAlphaFactor	destination alpha factor
alphaOperation	alpha operation

The result of the blend mode operation will be: dstRGB = dstRGB * dstColorFactor colorOperation srcRGB * srcColorFactor and dstA = dstA * dstAlphaFactor alphaOperation srcA * srcAlphaFactor

Definition at line 3375 of file SDL_render.c.

{
    SDL_BlendMode blendMode = SDL_COMPOSE_BLENDMODE(srcColorFactor, dstColorFactor, colorOperation,
                                                    srcAlphaFactor, dstAlphaFactor, alphaOperation);
    return SDL_GetShortBlendMode(blendMode);
}

References blendMode, SDL_COMPOSE_BLENDMODE, and SDL_GetShortBlendMode().

SDL_CreateRenderer()

SDL_Renderer* SDL_CreateRenderer	(	SDL_Window *	window,
		int	index,
		Uint32	flags
	)

Create a 2D rendering context for a window.

Parameters

window	The window where rendering is displayed.
index	The index of the rendering driver to initialize, or -1 to initialize the first one supporting the requested flags.
flags	SDL_RendererFlags.

Returns

A valid rendering context or NULL if there was an error.

See also

SDL_CreateSoftwareRenderer()

SDL_GetRendererInfo()

SDL_DestroyRenderer()

Definition at line 786 of file SDL_render.c.

{
#if !SDL_RENDER_DISABLED
    SDL_Renderer *renderer = NULL;
    int n = SDL_GetNumRenderDrivers();
    SDL_bool batching = SDL_TRUE;
    const char *hint;
 
#if defined(__ANDROID__)
    Android_ActivityMutex_Lock_Running();
#endif
 
    if (!window) {
        SDL_SetError("Invalid window");
        goto error;
    }
 
    if (SDL_GetRenderer(window)) {
        SDL_SetError("Renderer already associated with window");
        goto error;
    }
 
    if (SDL_GetHint(SDL_HINT_RENDER_VSYNC)) {
        if (SDL_GetHintBoolean(SDL_HINT_RENDER_VSYNC, SDL_TRUE)) {
            flags |= SDL_RENDERER_PRESENTVSYNC;
        } else {
            flags &= ~SDL_RENDERER_PRESENTVSYNC;
        }
    }
 
    if (index < 0) {
        hint = SDL_GetHint(SDL_HINT_RENDER_DRIVER);
        if (hint) {
            for (index = 0; index < n; ++index) {
                const SDL_RenderDriver *driver = render_drivers[index];
 
                if (SDL_strcasecmp(hint, driver->info.name) == 0) {
                    /* Create a new renderer instance */
                    renderer = driver->CreateRenderer(window, flags);
                    if (renderer) {
                        batching = SDL_FALSE;
                    }
                    break;
                }
            }
        }
 
        if (!renderer) {
            for (index = 0; index < n; ++index) {
                const SDL_RenderDriver *driver = render_drivers[index];
 
                if ((driver->info.flags & flags) == flags) {
                    /* Create a new renderer instance */
                    renderer = driver->CreateRenderer(window, flags);
                    if (renderer) {
                        /* Yay, we got one! */
                        break;
                    }
                }
            }
        }
        if (index == n) {
            SDL_SetError("Couldn't find matching render driver");
            goto error;
        }
    } else {
        if (index >= SDL_GetNumRenderDrivers()) {
            SDL_SetError("index must be -1 or in the range of 0 - %d",
                         SDL_GetNumRenderDrivers() - 1);
            goto error;
        }
        /* Create a new renderer instance */
        renderer = render_drivers[index]->CreateRenderer(window, flags);
        batching = SDL_FALSE;
    }
 
    if (!renderer) {
        goto error;
    }
 
    VerifyDrawQueueFunctions(renderer);
 
    /* let app/user override batching decisions. */
    if (renderer->always_batch) {
        batching = SDL_TRUE;
    } else if (SDL_GetHint(SDL_HINT_RENDER_BATCHING)) {
        batching = SDL_GetHintBoolean(SDL_HINT_RENDER_BATCHING, SDL_TRUE);
    }
 
    renderer->batching = batching;
    renderer->magic = &renderer_magic;
    renderer->window = window;
    renderer->target_mutex = SDL_CreateMutex();
    renderer->scale.x = 1.0f;
    renderer->scale.y = 1.0f;
    renderer->dpi_scale.x = 1.0f;
    renderer->dpi_scale.y = 1.0f;
 
    /* new textures start at zero, so we start at 1 so first render doesn't flush by accident. */
    renderer->render_command_generation = 1;
 
    if (window && renderer->GetOutputSize) {
        int window_w, window_h;
        int output_w, output_h;
        if (renderer->GetOutputSize(renderer, &output_w, &output_h) == 0) {
            SDL_GetWindowSize(renderer->window, &window_w, &window_h);
            renderer->dpi_scale.x = (float)window_w / output_w;
            renderer->dpi_scale.y = (float)window_h / output_h;
        }
    }
 
    renderer->relative_scaling = SDL_GetHintBoolean(SDL_HINT_MOUSE_RELATIVE_SCALING, SDL_TRUE);
 
    if (SDL_GetWindowFlags(window) & (SDL_WINDOW_HIDDEN|SDL_WINDOW_MINIMIZED)) {
        renderer->hidden = SDL_TRUE;
    } else {
        renderer->hidden = SDL_FALSE;
    }
 
    SDL_SetWindowData(window, SDL_WINDOWRENDERDATA, renderer);
 
    SDL_RenderSetViewport(renderer, NULL);
 
    SDL_AddEventWatch(SDL_RendererEventWatch, renderer);
 
    SDL_LogInfo(SDL_LOG_CATEGORY_RENDER,
                "Created renderer: %s", renderer->info.name);
 
#if defined(__ANDROID__)
    Android_ActivityMutex_Unlock();
#endif
    return renderer;
 
error:
 
#if defined(__ANDROID__)
    Android_ActivityMutex_Unlock();
#endif
    return NULL;
 
#else
    SDL_SetError("SDL not built with rendering support");
    return NULL;
#endif
}

References SDL_Renderer::always_batch, Android_ActivityMutex_Lock_Running(), Android_ActivityMutex_Unlock(), SDL_Renderer::batching, SDL_RenderDriver::CreateRenderer, SDL_Renderer::dpi_scale, SDL_RendererInfo::flags, SDL_Renderer::GetOutputSize, SDL_Renderer::hidden, SDL_Renderer::info, SDL_RenderDriver::info, SDL_Renderer::magic, SDL_RendererInfo::name, NULL, SDL_Renderer::relative_scaling, SDL_Renderer::render_command_generation, render_drivers, renderer, renderer_magic, SDL_Renderer::scale, SDL_AddEventWatch, SDL_CreateMutex, SDL_FALSE, SDL_GetHint, SDL_GetHintBoolean, SDL_GetNumRenderDrivers(), SDL_GetRenderer(), SDL_GetWindowFlags, SDL_GetWindowSize, SDL_HINT_MOUSE_RELATIVE_SCALING, SDL_HINT_RENDER_BATCHING, SDL_HINT_RENDER_DRIVER, SDL_HINT_RENDER_VSYNC, SDL_LOG_CATEGORY_RENDER, SDL_LogInfo, SDL_RENDERER_PRESENTVSYNC, SDL_RendererEventWatch(), SDL_RenderSetViewport(), SDL_SetError, SDL_SetWindowData, SDL_strcasecmp, SDL_TRUE, SDL_WINDOW_HIDDEN, SDL_WINDOW_MINIMIZED, SDL_WINDOWRENDERDATA, SDL_Renderer::target_mutex, VerifyDrawQueueFunctions(), SDL_Renderer::window, window_h, window_w, SDL_FPoint::x, and SDL_FPoint::y.

Referenced by SDL_CreateWindowAndRenderer().

SDL_CreateSoftwareRenderer()

SDL_Renderer* SDL_CreateSoftwareRenderer

(

SDL_Surface *

surface

)

Create a 2D software rendering context for a surface.

Parameters

surface

The surface where rendering is done.

Returns

A valid rendering context or NULL if there was an error.

See also

SDL_CreateRenderer()

SDL_DestroyRenderer()

Definition at line 933 of file SDL_render.c.

{
#if !SDL_RENDER_DISABLED && SDL_VIDEO_RENDER_SW
    SDL_Renderer *renderer;
 
    renderer = SW_CreateRendererForSurface(surface);
 
    if (renderer) {
        VerifyDrawQueueFunctions(renderer);
        renderer->magic = &renderer_magic;
        renderer->target_mutex = SDL_CreateMutex();
        renderer->scale.x = 1.0f;
        renderer->scale.y = 1.0f;
 
        /* new textures start at zero, so we start at 1 so first render doesn't flush by accident. */
        renderer->render_command_generation = 1;
 
        SDL_RenderSetViewport(renderer, NULL);
    }
    return renderer;
#else
    SDL_SetError("SDL not built with rendering support");
    return NULL;
#endif /* !SDL_RENDER_DISABLED */
}

References SDL_Renderer::magic, NULL, SDL_Renderer::render_command_generation, renderer, renderer_magic, SDL_Renderer::scale, SDL_CreateMutex, SDL_RenderSetViewport(), SDL_SetError, SW_CreateRendererForSurface(), SDL_Renderer::target_mutex, VerifyDrawQueueFunctions(), SDL_FPoint::x, and SDL_FPoint::y.

SDL_CreateTexture()

SDL_Texture* SDL_CreateTexture	(	SDL_Renderer *	renderer,
		Uint32	format,
		int	access,
		int	w,
		int	h
	)

Create a texture for a rendering context.

Parameters

renderer	The renderer.
format	The format of the texture.
access	One of the enumerated values in SDL_TextureAccess.
w	The width of the texture in pixels.
h	The height of the texture in pixels.

Returns

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.

Note

The contents of the texture are not defined at creation.

See also

SDL_QueryTexture()

SDL_UpdateTexture()

SDL_DestroyTexture()

Definition at line 1066 of file SDL_render.c.

{
    SDL_Texture *texture;
 
    CHECK_RENDERER_MAGIC(renderer, NULL);
 
    if (!format) {
        format = renderer->info.texture_formats[0];
    }
    if (SDL_BYTESPERPIXEL(format) == 0) {
        SDL_SetError("Invalid texture format");
        return NULL;
    }
    if (SDL_ISPIXELFORMAT_INDEXED(format)) {
        SDL_SetError("Palettized textures are not supported");
        return NULL;
    }
    if (w <= 0 || h <= 0) {
        SDL_SetError("Texture dimensions can't be 0");
        return NULL;
    }
    if ((renderer->info.max_texture_width && w > renderer->info.max_texture_width) ||
        (renderer->info.max_texture_height && h > renderer->info.max_texture_height)) {
        SDL_SetError("Texture dimensions are limited to %dx%d", renderer->info.max_texture_width, renderer->info.max_texture_height);
        return NULL;
    }
    texture = (SDL_Texture *) SDL_calloc(1, sizeof(*texture));
    if (!texture) {
        SDL_OutOfMemory();
        return NULL;
    }
    texture->magic = &texture_magic;
    texture->format = format;
    texture->access = access;
    texture->w = w;
    texture->h = h;
    texture->r = 255;
    texture->g = 255;
    texture->b = 255;
    texture->a = 255;
    texture->scaleMode = SDL_GetScaleMode();
    texture->renderer = renderer;
    texture->next = renderer->textures;
    if (renderer->textures) {
        renderer->textures->prev = texture;
    }
    renderer->textures = texture;
 
    if (IsSupportedFormat(renderer, format)) {
        if (renderer->CreateTexture(renderer, texture) < 0) {
            SDL_DestroyTexture(texture);
            return NULL;
        }
    } else {
        texture->native = SDL_CreateTexture(renderer,
                                GetClosestSupportedFormat(renderer, format),
                                access, w, h);
        if (!texture->native) {
            SDL_DestroyTexture(texture);
            return NULL;
        }
 
        /* Swap textures to have texture before texture->native in the list */
        texture->native->next = texture->next;
        if (texture->native->next) {
            texture->native->next->prev = texture->native;
        }
        texture->prev = texture->native->prev;
        if (texture->prev) {
            texture->prev->next = texture;
        }
        texture->native->prev = texture;
        texture->next = texture->native;
        renderer->textures = texture;
 
        if (SDL_ISPIXELFORMAT_FOURCC(texture->format)) {
#if SDL_HAVE_YUV
            texture->yuv = SDL_SW_CreateYUVTexture(format, w, h);
#else
            SDL_SetError("SDL not built with YUV support");
#endif
            if (!texture->yuv) {
                SDL_DestroyTexture(texture);
                return NULL;
            }
        } else if (access == SDL_TEXTUREACCESS_STREAMING) {
            /* The pitch is 4 byte aligned */
            texture->pitch = (((w * SDL_BYTESPERPIXEL(format)) + 3) & ~3);
            texture->pixels = SDL_calloc(1, texture->pitch * h);
            if (!texture->pixels) {
                SDL_DestroyTexture(texture);
                return NULL;
            }
        }
    }
    return texture;
}

References CHECK_RENDERER_MAGIC, SDL_Renderer::CreateTexture, GetClosestSupportedFormat(), SDL_Renderer::info, IsSupportedFormat(), SDL_RendererInfo::max_texture_height, SDL_RendererInfo::max_texture_width, NULL, SDL_Texture::prev, renderer, SDL_BYTESPERPIXEL, SDL_calloc, SDL_CreateTexture(), SDL_DestroyTexture(), SDL_GetScaleMode(), SDL_ISPIXELFORMAT_FOURCC, SDL_ISPIXELFORMAT_INDEXED, SDL_OutOfMemory, SDL_SetError, SDL_SW_CreateYUVTexture(), SDL_TEXTUREACCESS_STREAMING, SDL_RendererInfo::texture_formats, texture_magic, and SDL_Renderer::textures.

Referenced by SDL_CreateTexture(), and SDL_CreateTextureFromSurface().

SDL_CreateTextureFromSurface()

SDL_Texture* SDL_CreateTextureFromSurface	(	SDL_Renderer *	renderer,
		SDL_Surface *	surface
	)

Create a texture from an existing surface.

Parameters

renderer	The renderer.
surface	The surface containing pixel data used to fill the texture.

Returns

The created texture is returned, or NULL on error.

Note

The surface is not modified or freed by this function.

See also

SDL_QueryTexture()

SDL_DestroyTexture()

Definition at line 1165 of file SDL_render.c.

{
    const SDL_PixelFormat *fmt;
    SDL_bool needAlpha;
    SDL_bool direct_update;
    int i;
    Uint32 format = SDL_PIXELFORMAT_UNKNOWN;
    SDL_Texture *texture;
 
    CHECK_RENDERER_MAGIC(renderer, NULL);
 
    if (!surface) {
        SDL_SetError("SDL_CreateTextureFromSurface() passed NULL surface");
        return NULL;
    }
 
    /* See what the best texture format is */
    fmt = surface->format;
    if (fmt->Amask || SDL_HasColorKey(surface)) {
        needAlpha = SDL_TRUE;
    } else {
        needAlpha = SDL_FALSE;
    }
 
    /* If Palette contains alpha values, promotes to alpha format */
    if (fmt->palette) {
        SDL_bool is_opaque, has_alpha_channel;
        SDL_DetectPalette(fmt->palette, &is_opaque, &has_alpha_channel);
        if (!is_opaque) {
            needAlpha = SDL_TRUE;
        }
    }
 
    /* Try to have the best pixel format for the texture */
    /* No alpha, but a colorkey => promote to alpha */
    if (!fmt->Amask && SDL_HasColorKey(surface)) {
        if (fmt->format == SDL_PIXELFORMAT_RGB888) {
            for (i = 0; i < (int)renderer->info.num_texture_formats; ++i) {
                if (renderer->info.texture_formats[i] == SDL_PIXELFORMAT_ARGB8888) {
                    format = SDL_PIXELFORMAT_ARGB8888;
                    break;
                }
            }
        } else if (fmt->format == SDL_PIXELFORMAT_BGR888) {
            for (i = 0; i < (int)renderer->info.num_texture_formats; ++i) {
                if (renderer->info.texture_formats[i] == SDL_PIXELFORMAT_ABGR8888) {
                    format = SDL_PIXELFORMAT_ABGR8888;
                    break;
                }
            }
        }
    } else {
        /* Exact match would be fine */
        for (i = 0; i < (int)renderer->info.num_texture_formats; ++i) {
            if (renderer->info.texture_formats[i] == fmt->format) {
                format = fmt->format;
                break;
            }
        }
    }
 
    /* Fallback, choose a valid pixel format */
    if (format == SDL_PIXELFORMAT_UNKNOWN) {
        format = renderer->info.texture_formats[0];
        for (i = 0; i < (int)renderer->info.num_texture_formats; ++i) {
            if (!SDL_ISPIXELFORMAT_FOURCC(renderer->info.texture_formats[i]) &&
                    SDL_ISPIXELFORMAT_ALPHA(renderer->info.texture_formats[i]) == needAlpha) {
                format = renderer->info.texture_formats[i];
                break;
            }
        }
    }
 
    texture = SDL_CreateTexture(renderer, format, SDL_TEXTUREACCESS_STATIC,
                                surface->w, surface->h);
    if (!texture) {
        return NULL;
    }
 
    if (format == surface->format->format) {
        if (surface->format->Amask && SDL_HasColorKey(surface)) {
            /* Surface and Renderer formats are identicals. 
             * Intermediate conversion is needed to convert color key to alpha (SDL_ConvertColorkeyToAlpha()). */
            direct_update = SDL_FALSE;
        } else {
            /* Update Texture directly */
            direct_update = SDL_TRUE;
        }
    } else {
        /* Surface and Renderer formats are differents, it needs an intermediate conversion. */
        direct_update = SDL_FALSE;
    }
 
    if (direct_update) {
        if (SDL_MUSTLOCK(surface)) {
            SDL_LockSurface(surface);
            SDL_UpdateTexture(texture, NULL, surface->pixels, surface->pitch);
            SDL_UnlockSurface(surface);
        } else {
            SDL_UpdateTexture(texture, NULL, surface->pixels, surface->pitch);
        }
    } else {
        SDL_PixelFormat *dst_fmt;
        SDL_Surface *temp = NULL;
 
        /* Set up a destination surface for the texture update */
        dst_fmt = SDL_AllocFormat(format);
        if (!dst_fmt) {
           SDL_DestroyTexture(texture);
           return NULL;
        }
        temp = SDL_ConvertSurface(surface, dst_fmt, 0);
        SDL_FreeFormat(dst_fmt);
        if (temp) {
            SDL_UpdateTexture(texture, NULL, temp->pixels, temp->pitch);
            SDL_FreeSurface(temp);
        } else {
            SDL_DestroyTexture(texture);
            return NULL;
        }
    }
 
    {
        Uint8 r, g, b, a;
        SDL_BlendMode blendMode;
 
        SDL_GetSurfaceColorMod(surface, &r, &g, &b);
        SDL_SetTextureColorMod(texture, r, g, b);
 
        SDL_GetSurfaceAlphaMod(surface, &a);
        SDL_SetTextureAlphaMod(texture, a);
 
        if (SDL_HasColorKey(surface)) {
            /* We converted to a texture with alpha format */
            SDL_SetTextureBlendMode(texture, SDL_BLENDMODE_BLEND);
        } else {
            SDL_GetSurfaceBlendMode(surface, &blendMode);
            SDL_SetTextureBlendMode(texture, blendMode);
        }
    }
    return texture;
}

References SDL_PixelFormat::Amask, blendMode, CHECK_RENDERER_MAGIC, SDL_PixelFormat::format, i, SDL_Renderer::info, int(), NULL, SDL_RendererInfo::num_texture_formats, SDL_PixelFormat::palette, SDL_Surface::pitch, SDL_Surface::pixels, renderer, SDL_AllocFormat, SDL_BLENDMODE_BLEND, SDL_ConvertSurface, SDL_CreateTexture(), SDL_DestroyTexture(), SDL_DetectPalette(), SDL_FALSE, SDL_FreeFormat, SDL_FreeSurface, SDL_GetSurfaceAlphaMod, SDL_GetSurfaceBlendMode, SDL_GetSurfaceColorMod, SDL_HasColorKey, SDL_ISPIXELFORMAT_ALPHA, SDL_ISPIXELFORMAT_FOURCC, SDL_LockSurface, SDL_MUSTLOCK, SDL_PIXELFORMAT_ABGR8888, SDL_PIXELFORMAT_ARGB8888, SDL_PIXELFORMAT_BGR888, SDL_PIXELFORMAT_RGB888, SDL_PIXELFORMAT_UNKNOWN, SDL_SetError, SDL_SetTextureAlphaMod(), SDL_SetTextureBlendMode(), SDL_SetTextureColorMod(), SDL_TEXTUREACCESS_STATIC, SDL_TRUE, SDL_UnlockSurface, SDL_UpdateTexture(), and SDL_RendererInfo::texture_formats.

SDL_CreateWindowAndRenderer()

int SDL_CreateWindowAndRenderer	(	int	width,
		int	height,
		Uint32	window_flags,
		SDL_Window **	window,
		SDL_Renderer **	renderer
	)

Create a window and default renderer.

Parameters

width	The width of the window
height	The height of the window
window_flags	The flags used to create the window
window	A pointer filled with the window, or NULL on error
renderer	A pointer filled with the renderer, or NULL on error

Returns

0 on success, or -1 on error

Definition at line 752 of file SDL_render.c.

{
    *window = SDL_CreateWindow(NULL, SDL_WINDOWPOS_UNDEFINED,
                                     SDL_WINDOWPOS_UNDEFINED,
                                     width, height, window_flags);
    if (!*window) {
        *renderer = NULL;
        return -1;
    }
 
    *renderer = SDL_CreateRenderer(*window, -1, 0);
    if (!*renderer) {
        return -1;
    }
 
    return 0;
}

References NULL, renderer, SDL_CreateRenderer(), SDL_CreateWindow, and SDL_WINDOWPOS_UNDEFINED.

SDL_DestroyRenderer()

void SDL_DestroyRenderer

(

SDL_Renderer *

renderer

)

Destroy the rendering context for a window and free associated textures.

See also

SDL_CreateRenderer()

Definition at line 3227 of file SDL_render.c.

{
    SDL_RenderCommand *cmd;
 
    CHECK_RENDERER_MAGIC(renderer, );
 
    SDL_DelEventWatch(SDL_RendererEventWatch, renderer);
 
    if (renderer->render_commands_tail != NULL) {
        renderer->render_commands_tail->next = renderer->render_commands_pool;
        cmd = renderer->render_commands;
    } else {
        cmd = renderer->render_commands_pool;
    }
 
    renderer->render_commands_pool = NULL;
    renderer->render_commands_tail = NULL;
    renderer->render_commands = NULL;
 
    while (cmd != NULL) {
        SDL_RenderCommand *next = cmd->next;
        SDL_free(cmd);
        cmd = next;
    }
 
    SDL_free(renderer->vertex_data);
 
    /* Free existing textures for this renderer */
    while (renderer->textures) {
        SDL_Texture *tex = renderer->textures; (void) tex;
        SDL_DestroyTexture(renderer->textures);
        SDL_assert(tex != renderer->textures);  /* satisfy static analysis. */
    }
 
    if (renderer->window) {
        SDL_SetWindowData(renderer->window, SDL_WINDOWRENDERDATA, NULL);
    }
 
    /* It's no longer magical... */
    renderer->magic = NULL;
 
    /* Free the target mutex */
    SDL_DestroyMutex(renderer->target_mutex);
    renderer->target_mutex = NULL;
 
    /* Free the renderer instance */
    renderer->DestroyRenderer(renderer);
}

References CHECK_RENDERER_MAGIC, SDL_Renderer::DestroyRenderer, SDL_Renderer::magic, SDL_RenderCommand::next, NULL, SDL_Renderer::render_commands, SDL_Renderer::render_commands_pool, SDL_Renderer::render_commands_tail, renderer, SDL_assert, SDL_DelEventWatch, SDL_DestroyMutex, SDL_DestroyTexture(), SDL_free, SDL_RendererEventWatch(), SDL_SetWindowData, SDL_WINDOWRENDERDATA, SDL_Renderer::target_mutex, SDL_Renderer::textures, SDL_Renderer::vertex_data, void, and SDL_Renderer::window.

SDL_DestroyTexture()

void SDL_DestroyTexture

(

SDL_Texture *

texture

)

Destroy the specified texture.

See also

SDL_CreateTexture()

SDL_CreateTextureFromSurface()

Definition at line 3184 of file SDL_render.c.

{
    SDL_Renderer *renderer;
 
    CHECK_TEXTURE_MAGIC(texture, );
 
    renderer = texture->renderer;
    if (texture == renderer->target) {
        SDL_SetRenderTarget(renderer, NULL);  /* implies command queue flush */
    } else {
        FlushRenderCommandsIfTextureNeeded(texture);
    }
 
    texture->magic = NULL;
 
    if (texture->next) {
        texture->next->prev = texture->prev;
    }
    if (texture->prev) {
        texture->prev->next = texture->next;
    } else {
        renderer->textures = texture->next;
    }
 
    if (texture->native) {
        SDL_DestroyTexture(texture->native);
    }
#if SDL_HAVE_YUV
    if (texture->yuv) {
        SDL_SW_DestroyYUVTexture(texture->yuv);
    }
#endif
    SDL_free(texture->pixels);
 
    renderer->DestroyTexture(renderer, texture);
 
    SDL_FreeSurface(texture->locked_surface);
    texture->locked_surface = NULL;
 
    SDL_free(texture);
}

References CHECK_TEXTURE_MAGIC, SDL_Renderer::DestroyTexture, FlushRenderCommandsIfTextureNeeded(), SDL_Texture::next, NULL, renderer, SDL_DestroyTexture(), SDL_free, SDL_FreeSurface, SDL_SetRenderTarget(), SDL_SW_DestroyYUVTexture(), SDL_Renderer::target, and SDL_Renderer::textures.

Referenced by SDL_CreateTexture(), SDL_CreateTextureFromSurface(), SDL_DestroyRenderer(), and SDL_DestroyTexture().

SDL_FRectEmpty()

SDL_FORCE_INLINE SDL_bool SDL_FRectEmpty

(

const SDL_FRect *

r

)

Definition at line 2898 of file SDL_render.c.

{
    return ((!r) || (r->w <= 0.0f) || (r->h <= 0.0f)) ? SDL_TRUE : SDL_FALSE;
}

References SDL_FALSE, and SDL_TRUE.

Referenced by SDL_HasIntersectionF().

SDL_GetBlendModeAlphaOperation()

SDL_BlendOperation SDL_GetBlendModeAlphaOperation

(

SDL_BlendMode

blendMode

)

Definition at line 3421 of file SDL_render.c.

{
    blendMode = SDL_GetLongBlendMode(blendMode);
    return (SDL_BlendOperation)(((Uint32)blendMode >> 16) & 0xF);
}

References blendMode, and SDL_GetLongBlendMode().

SDL_GetBlendModeColorOperation()

SDL_BlendOperation SDL_GetBlendModeColorOperation

(

SDL_BlendMode

blendMode

)

Definition at line 3400 of file SDL_render.c.

{
    blendMode = SDL_GetLongBlendMode(blendMode);
    return (SDL_BlendOperation)(((Uint32)blendMode >> 0) & 0xF);
}

References blendMode, and SDL_GetLongBlendMode().

SDL_GetBlendModeDstAlphaFactor()

SDL_BlendFactor SDL_GetBlendModeDstAlphaFactor

(

SDL_BlendMode

blendMode

)

Definition at line 3414 of file SDL_render.c.

{
    blendMode = SDL_GetLongBlendMode(blendMode);
    return (SDL_BlendFactor)(((Uint32)blendMode >> 24) & 0xF);
}

References blendMode, and SDL_GetLongBlendMode().

SDL_GetBlendModeDstColorFactor()

SDL_BlendFactor SDL_GetBlendModeDstColorFactor

(

SDL_BlendMode

blendMode

)

Definition at line 3393 of file SDL_render.c.

{
    blendMode = SDL_GetLongBlendMode(blendMode);
    return (SDL_BlendFactor)(((Uint32)blendMode >> 8) & 0xF);
}

References blendMode, and SDL_GetLongBlendMode().

SDL_GetBlendModeSrcAlphaFactor()

SDL_BlendFactor SDL_GetBlendModeSrcAlphaFactor

(

SDL_BlendMode

blendMode

)

Definition at line 3407 of file SDL_render.c.

{
    blendMode = SDL_GetLongBlendMode(blendMode);
    return (SDL_BlendFactor)(((Uint32)blendMode >> 20) & 0xF);
}

References blendMode, and SDL_GetLongBlendMode().

SDL_GetBlendModeSrcColorFactor()

SDL_BlendFactor SDL_GetBlendModeSrcColorFactor

(

SDL_BlendMode

blendMode

)

Definition at line 3386 of file SDL_render.c.

{
    blendMode = SDL_GetLongBlendMode(blendMode);
    return (SDL_BlendFactor)(((Uint32)blendMode >> 4) & 0xF);
}

References blendMode, and SDL_GetLongBlendMode().

SDL_GetLongBlendMode()

static SDL_BlendMode SDL_GetLongBlendMode ( SDL_BlendMode  blendMode )

static

Definition at line 3354 of file SDL_render.c.

{
    if (blendMode == SDL_BLENDMODE_NONE) {
        return SDL_BLENDMODE_NONE_FULL;
    }
    if (blendMode == SDL_BLENDMODE_BLEND) {
        return SDL_BLENDMODE_BLEND_FULL;
    }
    if (blendMode == SDL_BLENDMODE_ADD) {
        return SDL_BLENDMODE_ADD_FULL;
    }
    if (blendMode == SDL_BLENDMODE_MOD) {
        return SDL_BLENDMODE_MOD_FULL;
    }
    if (blendMode == SDL_BLENDMODE_MUL) {
        return SDL_BLENDMODE_MUL_FULL;
    }
    return blendMode;
}

References blendMode, SDL_BLENDMODE_ADD, SDL_BLENDMODE_ADD_FULL, SDL_BLENDMODE_BLEND, SDL_BLENDMODE_BLEND_FULL, SDL_BLENDMODE_MOD, SDL_BLENDMODE_MOD_FULL, SDL_BLENDMODE_MUL, SDL_BLENDMODE_MUL_FULL, SDL_BLENDMODE_NONE, and SDL_BLENDMODE_NONE_FULL.

Referenced by SDL_GetBlendModeAlphaOperation(), SDL_GetBlendModeColorOperation(), SDL_GetBlendModeDstAlphaFactor(), SDL_GetBlendModeDstColorFactor(), SDL_GetBlendModeSrcAlphaFactor(), and SDL_GetBlendModeSrcColorFactor().

SDL_GetNumRenderDrivers()

int SDL_GetNumRenderDrivers

(

void

)

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.

See also

SDL_GetRenderDriverInfo()

SDL_CreateRenderer()

Definition at line 552 of file SDL_render.c.

{
#if !SDL_RENDER_DISABLED
    return SDL_arraysize(render_drivers);
#else
    return 0;
#endif
}

References render_drivers, and SDL_arraysize.

Referenced by SDL_CreateRenderer(), and SDL_GetRenderDriverInfo().

SDL_GetRenderDrawBlendMode()

int SDL_GetRenderDrawBlendMode	(	SDL_Renderer *	renderer,
		SDL_BlendMode *	blendMode
	)

Get the blend mode used for drawing operations.

Parameters

renderer	The renderer from which blend mode should be queried.
blendMode	A pointer filled in with the current blend mode.

Returns

0 on success, or -1 on error

See also

SDL_SetRenderDrawBlendMode()

Definition at line 2267 of file SDL_render.c.

{
    CHECK_RENDERER_MAGIC(renderer, -1);
 
    *blendMode = renderer->blendMode;
    return 0;
}

References SDL_Renderer::blendMode, blendMode, CHECK_RENDERER_MAGIC, and renderer.

SDL_GetRenderDrawColor()

int SDL_GetRenderDrawColor	(	SDL_Renderer *	renderer,
		Uint8 *	r,
		Uint8 *	g,
		Uint8 *	b,
		Uint8 *	a
	)

Get the color used for drawing operations (Rect, Line and Clear).

Parameters

renderer	The renderer from which drawing color should be queried.
r	A pointer to the red value used to draw on the rendering target.
g	A pointer to the green value used to draw on the rendering target.
b	A pointer to the blue value used to draw on the rendering target.
a	A pointer to the alpha value used to draw on the rendering target, usually SDL_ALPHA_OPAQUE (255).

Returns

0 on success, or -1 on error

Definition at line 2234 of file SDL_render.c.

{
    CHECK_RENDERER_MAGIC(renderer, -1);
 
    if (r) {
        *r = renderer->r;
    }
    if (g) {
        *g = renderer->g;
    }
    if (b) {
        *b = renderer->b;
    }
    if (a) {
        *a = renderer->a;
    }
    return 0;
}

References SDL_Renderer::a, SDL_Renderer::b, CHECK_RENDERER_MAGIC, SDL_Renderer::g, SDL_Renderer::r, and renderer.

SDL_GetRenderDriverInfo()

int SDL_GetRenderDriverInfo	(	int	index,
		SDL_RendererInfo *	info
	)

Get information about a specific 2D rendering driver for the current display.

Parameters

index	The index of the driver to query information about.
info	A pointer to an SDL_RendererInfo struct to be filled with information on the rendering driver.

Returns

0 on success, -1 if the index was out of range.

See also

SDL_CreateRenderer()

Definition at line 562 of file SDL_render.c.

{
#if !SDL_RENDER_DISABLED
    if (index < 0 || index >= SDL_GetNumRenderDrivers()) {
        return SDL_SetError("index must be in the range of 0 - %d",
                            SDL_GetNumRenderDrivers() - 1);
    }
    *info = render_drivers[index]->info;
    return 0;
#else
    return SDL_SetError("SDL not built with rendering support");
#endif
}

References SDL_RenderDriver::info, render_drivers, SDL_GetNumRenderDrivers(), and SDL_SetError.

SDL_GetRenderer()

SDL_Renderer* SDL_GetRenderer

(

SDL_Window *

window

)

Get the renderer associated with a window.

Definition at line 960 of file SDL_render.c.

{
    return (SDL_Renderer *)SDL_GetWindowData(window, SDL_WINDOWRENDERDATA);
}

References SDL_GetWindowData, and SDL_WINDOWRENDERDATA.

Referenced by SDL_CreateRenderer().

SDL_GetRendererInfo()

int SDL_GetRendererInfo	(	SDL_Renderer *	renderer,
		SDL_RendererInfo *	info
	)

Get information about a rendering context.

Definition at line 966 of file SDL_render.c.

{
    CHECK_RENDERER_MAGIC(renderer, -1);
 
    *info = renderer->info;
    return 0;
}

References CHECK_RENDERER_MAGIC, SDL_Renderer::info, and renderer.

SDL_GetRendererOutputSize()

int SDL_GetRendererOutputSize	(	SDL_Renderer *	renderer,
		int *	w,
		int *	h
	)

Get the output size in pixels of a rendering context.

Definition at line 975 of file SDL_render.c.

{
    CHECK_RENDERER_MAGIC(renderer, -1);
 
    if (renderer->target) {
        return SDL_QueryTexture(renderer->target, NULL, NULL, w, h);
    } else if (renderer->GetOutputSize) {
        return renderer->GetOutputSize(renderer, w, h);
    } else if (renderer->window) {
        SDL_GetWindowSize(renderer->window, w, h);
        return 0;
    } else {
        SDL_assert(0 && "This should never happen");
        return SDL_SetError("Renderer doesn't support querying output size");
    }
}

References CHECK_RENDERER_MAGIC, SDL_Renderer::GetOutputSize, NULL, renderer, SDL_assert, SDL_GetWindowSize, SDL_QueryTexture(), SDL_SetError, SDL_Renderer::target, and SDL_Renderer::window.

Referenced by SDL_RenderSetViewport(), and UpdateLogicalSize().

SDL_GetRenderTarget()

SDL_Texture* SDL_GetRenderTarget

(

SDL_Renderer *

renderer

)

Get the current render target or NULL for the default render target.

Returns

The current render target

See also

SDL_SetRenderTarget()

Definition at line 1956 of file SDL_render.c.

{
    return renderer->target;
}

References renderer, and SDL_Renderer::target.

Referenced by SDL_RendererEventWatch().

SDL_GetScaleMode()

static SDL_ScaleMode SDL_GetScaleMode ( void  )

static

Definition at line 1050 of file SDL_render.c.

{
    const char *hint = SDL_GetHint(SDL_HINT_RENDER_SCALE_QUALITY);
 
    if (!hint || SDL_strcasecmp(hint, "nearest") == 0) {
        return SDL_ScaleModeNearest;
    } else if (SDL_strcasecmp(hint, "linear") == 0) {
        return SDL_ScaleModeLinear;
    } else if (SDL_strcasecmp(hint, "best") == 0) {
        return SDL_ScaleModeBest;
    } else {
        return (SDL_ScaleMode)SDL_atoi(hint);
    }
}

References SDL_atoi, SDL_GetHint, SDL_HINT_RENDER_SCALE_QUALITY, SDL_ScaleModeBest, SDL_ScaleModeLinear, SDL_ScaleModeNearest, and SDL_strcasecmp.

Referenced by SDL_CreateTexture().

SDL_GetShortBlendMode()

static SDL_BlendMode SDL_GetShortBlendMode ( SDL_BlendMode  blendMode )

static

Definition at line 3333 of file SDL_render.c.

{
    if (blendMode == SDL_BLENDMODE_NONE_FULL) {
        return SDL_BLENDMODE_NONE;
    }
    if (blendMode == SDL_BLENDMODE_BLEND_FULL) {
        return SDL_BLENDMODE_BLEND;
    }
    if (blendMode == SDL_BLENDMODE_ADD_FULL) {
        return SDL_BLENDMODE_ADD;
    }
    if (blendMode == SDL_BLENDMODE_MOD_FULL) {
        return SDL_BLENDMODE_MOD;
    }
    if (blendMode == SDL_BLENDMODE_MUL_FULL) {
        return SDL_BLENDMODE_MUL;
    }
    return blendMode;
}

References blendMode, SDL_BLENDMODE_ADD, SDL_BLENDMODE_ADD_FULL, SDL_BLENDMODE_BLEND, SDL_BLENDMODE_BLEND_FULL, SDL_BLENDMODE_MOD, SDL_BLENDMODE_MOD_FULL, SDL_BLENDMODE_MUL, SDL_BLENDMODE_MUL_FULL, SDL_BLENDMODE_NONE, and SDL_BLENDMODE_NONE_FULL.

Referenced by SDL_ComposeCustomBlendMode().

SDL_GetTextureAlphaMod()

int SDL_GetTextureAlphaMod	(	SDL_Texture *	texture,
		Uint8 *	alpha
	)

Get the additional alpha value used in render copy operations.

Parameters

texture	The texture to query.
alpha	A pointer filled in with the current alpha value.

Returns

0 on success, or -1 if the texture is not valid.

See also

SDL_SetTextureAlphaMod()

Definition at line 1384 of file SDL_render.c.

{
    CHECK_TEXTURE_MAGIC(texture, -1);
 
    if (alpha) {
        *alpha = texture->a;
    }
    return 0;
}

References CHECK_TEXTURE_MAGIC.

SDL_GetTextureBlendMode()

int SDL_GetTextureBlendMode	(	SDL_Texture *	texture,
		SDL_BlendMode *	blendMode
	)

Get the blend mode used for texture copy operations.

Parameters

texture	The texture to query.
blendMode	A pointer filled in with the current blend mode.

Returns

0 on success, or -1 if the texture is not valid.

See also

SDL_SetTextureBlendMode()

Definition at line 1413 of file SDL_render.c.

{
    CHECK_TEXTURE_MAGIC(texture, -1);
 
    if (blendMode) {
        *blendMode = texture->blendMode;
    }
    return 0;
}

References blendMode, and CHECK_TEXTURE_MAGIC.

SDL_GetTextureColorMod()

int SDL_GetTextureColorMod	(	SDL_Texture *	texture,
		Uint8 *	r,
		Uint8 *	g,
		Uint8 *	b
	)

Get the additional color value used in render copy operations.

Parameters

texture	The texture to query.
r	A pointer filled in with the current red color value.
g	A pointer filled in with the current green color value.
b	A pointer filled in with the current blue color value.

Returns

0 on success, or -1 if the texture is not valid.

See also

SDL_SetTextureColorMod()

Definition at line 1349 of file SDL_render.c.

{
    CHECK_TEXTURE_MAGIC(texture, -1);
 
    if (r) {
        *r = texture->r;
    }
    if (g) {
        *g = texture->g;
    }
    if (b) {
        *b = texture->b;
    }
    return 0;
}

References CHECK_TEXTURE_MAGIC.

SDL_GetTextureScaleMode()

int SDL_GetTextureScaleMode	(	SDL_Texture *	texture,
		SDL_ScaleMode *	scaleMode
	)

Get the scale mode used for texture scale operations.

Parameters

texture	The texture to query.
scaleMode	A pointer filled in with the current scale mode.

Returns

0 on success, or -1 if the texture is not valid.

See also

SDL_SetTextureScaleMode()

Definition at line 1440 of file SDL_render.c.

{
    CHECK_TEXTURE_MAGIC(texture, -1);
 
    if (scaleMode) {
        *scaleMode = texture->scaleMode;
    }
    return 0;
}

References CHECK_TEXTURE_MAGIC.

SDL_GL_BindTexture()

int SDL_GL_BindTexture	(	SDL_Texture *	texture,
		float *	texw,
		float *	texh
	)

Bind the texture to the current OpenGL/ES/ES2 context for use with OpenGL instructions.

Parameters

texture	The SDL texture to bind
texw	A pointer to a float that will be filled with the texture width
texh	A pointer to a float that will be filled with the texture height

Returns

0 on success, or -1 if the operation is not supported

Definition at line 3276 of file SDL_render.c.

{
    SDL_Renderer *renderer;
 
    CHECK_TEXTURE_MAGIC(texture, -1);
    renderer = texture->renderer;
    if (texture->native) {
        return SDL_GL_BindTexture(texture->native, texw, texh);
    } else if (renderer && renderer->GL_BindTexture) {
        FlushRenderCommandsIfTextureNeeded(texture);  /* in case the app is going to mess with it. */
        return renderer->GL_BindTexture(renderer, texture, texw, texh);
    } else {
        return SDL_Unsupported();
    }
}

References CHECK_TEXTURE_MAGIC, FlushRenderCommandsIfTextureNeeded(), SDL_Renderer::GL_BindTexture, renderer, SDL_GL_BindTexture(), and SDL_Unsupported.

Referenced by SDL_GL_BindTexture().

SDL_GL_UnbindTexture()

int SDL_GL_UnbindTexture

(

SDL_Texture *

texture

)

Unbind a texture from the current OpenGL/ES/ES2 context.

Parameters

texture

The SDL texture to unbind

Returns

0 on success, or -1 if the operation is not supported

Definition at line 3292 of file SDL_render.c.

{
    SDL_Renderer *renderer;
 
    CHECK_TEXTURE_MAGIC(texture, -1);
    renderer = texture->renderer;
    if (texture->native) {
        return SDL_GL_UnbindTexture(texture->native);
    } else if (renderer && renderer->GL_UnbindTexture) {
        FlushRenderCommandsIfTextureNeeded(texture);  /* in case the app messed with it. */
        return renderer->GL_UnbindTexture(renderer, texture);
    }
 
    return SDL_Unsupported();
}

References CHECK_TEXTURE_MAGIC, FlushRenderCommandsIfTextureNeeded(), SDL_Renderer::GL_UnbindTexture, renderer, SDL_GL_UnbindTexture(), and SDL_Unsupported.

Referenced by SDL_GL_UnbindTexture().

SDL_HasIntersectionF()

static SDL_bool SDL_HasIntersectionF ( const SDL_FRect *  A, const SDL_FRect *  B  )

static

Definition at line 2905 of file SDL_render.c.

{
    float Amin, Amax, Bmin, Bmax;
 
    if (!A) {
        SDL_InvalidParamError("A");
        return SDL_FALSE;
    }
 
    if (!B) {
        SDL_InvalidParamError("B");
        return SDL_FALSE;
    }
 
    /* Special cases for empty rects */
    if (SDL_FRectEmpty(A) || SDL_FRectEmpty(B)) {
        return SDL_FALSE;
    }
 
    /* Horizontal intersection */
    Amin = A->x;
    Amax = Amin + A->w;
    Bmin = B->x;
    Bmax = Bmin + B->w;
    if (Bmin > Amin)
        Amin = Bmin;
    if (Bmax < Amax)
        Amax = Bmax;
    if (Amax <= Amin)
        return SDL_FALSE;
 
    /* Vertical intersection */
    Amin = A->y;
    Amax = Amin + A->h;
    Bmin = B->y;
    Bmax = Bmin + B->h;
    if (Bmin > Amin)
        Amin = Bmin;
    if (Bmax < Amax)
        Amax = Bmax;
    if (Amax <= Amin)
        return SDL_FALSE;
 
    return SDL_TRUE;
}

References SDL_FRect::h, SDL_FALSE, SDL_FRectEmpty(), SDL_InvalidParamError, SDL_TRUE, SDL_FRect::w, SDL_FRect::x, and SDL_FRect::y.

Referenced by SDL_RenderCopyF().

SDL_LockTexture()

int SDL_LockTexture	(	SDL_Texture *	texture,
		const SDL_Rect *	rect,
		void **	pixels,
		int *	pitch
	)

Lock a portion of the texture for write-only pixel access.

Parameters

texture	The texture to lock for access, which was created with SDL_TEXTUREACCESS_STREAMING.
rect	A pointer to the rectangle to lock for access. If the rect is NULL, the entire texture will be locked.
pixels	This is filled in with a pointer to the locked pixels, appropriately offset by the locked area.
pitch	This is filled in with the pitch of the locked pixels.

Returns

0 on success, or -1 if the texture is not valid or was not created with SDL_TEXTUREACCESS_STREAMING.

See also

SDL_UnlockTexture()

Definition at line 1722 of file SDL_render.c.

{
    SDL_Rect full_rect;
 
    CHECK_TEXTURE_MAGIC(texture, -1);
 
    if (texture->access != SDL_TEXTUREACCESS_STREAMING) {
        return SDL_SetError("SDL_LockTexture(): texture must be streaming");
    }
 
    if (!rect) {
        full_rect.x = 0;
        full_rect.y = 0;
        full_rect.w = texture->w;
        full_rect.h = texture->h;
        rect = &full_rect;
    }
 
#if SDL_HAVE_YUV
    if (texture->yuv) {
        if (FlushRenderCommandsIfTextureNeeded(texture) < 0) {
            return -1;
        }
        return SDL_LockTextureYUV(texture, rect, pixels, pitch);
    } else
#endif
    if (texture->native) {
        /* Calls a real SDL_LockTexture/SDL_UnlockTexture on unlock, flushing then. */
        return SDL_LockTextureNative(texture, rect, pixels, pitch);
    } else {
        SDL_Renderer *renderer = texture->renderer;
        if (FlushRenderCommandsIfTextureNeeded(texture) < 0) {
            return -1;
        }
        return renderer->LockTexture(renderer, texture, rect, pixels, pitch);
    }
}

References CHECK_TEXTURE_MAGIC, FlushRenderCommandsIfTextureNeeded(), SDL_Rect::h, SDL_Renderer::LockTexture, rect, renderer, SDL_LockTextureNative(), SDL_LockTextureYUV(), SDL_SetError, SDL_TEXTUREACCESS_STREAMING, SDL_Rect::w, SDL_Rect::x, and SDL_Rect::y.

Referenced by SDL_LockTextureToSurface(), SDL_UnlockTextureNative(), SDL_UnlockTextureYUV(), SDL_UpdateTextureNative(), SDL_UpdateTextureYUV(), and SDL_UpdateTextureYUVPlanar().

SDL_LockTextureNative()

static int SDL_LockTextureNative ( SDL_Texture *  texture, const SDL_Rect *  rect, void **  pixels, int *  pitch  )

static

Definition at line 1710 of file SDL_render.c.

{
    texture->locked_rect = *rect;
    *pixels = (void *) ((Uint8 *) texture->pixels +
                        rect->y * texture->pitch +
                        rect->x * SDL_BYTESPERPIXEL(texture->format));
    *pitch = texture->pitch;
    return 0;
}

References rect, SDL_BYTESPERPIXEL, SDL_Rect::x, and SDL_Rect::y.

Referenced by SDL_LockTexture().

SDL_LockTextureToSurface()

int SDL_LockTextureToSurface	(	SDL_Texture *	texture,
		const SDL_Rect *	rect,
		SDL_Surface **	surface
	)

Lock a portion of the texture for write-only pixel access. Expose it as a SDL surface.

Parameters

texture	The texture to lock for access, which was created with SDL_TEXTUREACCESS_STREAMING.
rect	A pointer to the rectangle to lock for access. If the rect is NULL, the entire texture will be locked.
surface	This is filled in with a SDL surface representing the locked area Surface is freed internally after calling SDL_UnlockTexture or SDL_DestroyTexture.

Returns

0 on success, or -1 if the texture is not valid or was not created with SDL_TEXTUREACCESS_STREAMING.

See also

SDL_UnlockTexture()

Definition at line 1762 of file SDL_render.c.

{
    SDL_Rect real_rect;
    void *pixels = NULL;
    int pitch = 0; /* fix static analysis */
    int ret;
 
    if (texture == NULL || surface == NULL) {
        return -1;
    }
 
    real_rect.x = 0;
    real_rect.y = 0;
    real_rect.w = texture->w;
    real_rect.h = texture->h;
 
    if (rect) {
        SDL_IntersectRect(rect, &real_rect, &real_rect);
    }
 
    ret = SDL_LockTexture(texture, &real_rect, &pixels, &pitch);
    if (ret < 0) {
        return ret;
    }
 
    texture->locked_surface = SDL_CreateRGBSurfaceWithFormatFrom(pixels, real_rect.w, real_rect.h, 0, pitch, texture->format);
    if (texture->locked_surface == NULL) {
        SDL_UnlockTexture(texture);
        return -1;
    }
 
    *surface = texture->locked_surface;
    return 0;
}

References SDL_Rect::h, NULL, rect, SDL_CreateRGBSurfaceWithFormatFrom, SDL_IntersectRect, SDL_LockTexture(), SDL_UnlockTexture(), SDL_Rect::w, SDL_Rect::x, and SDL_Rect::y.

SDL_LockTextureYUV()

static int SDL_LockTextureYUV ( SDL_Texture *  texture, const SDL_Rect *  rect, void **  pixels, int *  pitch  )

static

Definition at line 1702 of file SDL_render.c.

{
    return SDL_SW_LockYUVTexture(texture->yuv, rect, pixels, pitch);
}

References rect, and SDL_SW_LockYUVTexture().

Referenced by SDL_LockTexture().

SDL_QueryTexture()

int SDL_QueryTexture	(	SDL_Texture *	texture,
		Uint32 *	format,
		int *	access,
		int *	w,
		int *	h
	)

Query the attributes of a texture.

Parameters

texture	A texture to be queried.
format	A pointer filled in with the raw format of the texture. The actual format may differ, but pixel transfers will use this format.
access	A pointer filled in with the actual access to the texture.
w	A pointer filled in with the width of the texture in pixels.
h	A pointer filled in with the height of the texture in pixels.

Returns

0 on success, or -1 if the texture is not valid.

Definition at line 1309 of file SDL_render.c.

{
    CHECK_TEXTURE_MAGIC(texture, -1);
 
    if (format) {
        *format = texture->format;
    }
    if (access) {
        *access = texture->access;
    }
    if (w) {
        *w = texture->w;
    }
    if (h) {
        *h = texture->h;
    }
    return 0;
}

References CHECK_TEXTURE_MAGIC.

Referenced by SDL_GetRendererOutputSize().

SDL_RenderClear()

int SDL_RenderClear

(

SDL_Renderer *

renderer

)

Clear the current rendering target with the drawing color.

This function clears the entire rendering target, ignoring the viewport and the clip rectangle.

Returns

0 on success, or -1 on error

Definition at line 2276 of file SDL_render.c.

{
    int retval;
    CHECK_RENDERER_MAGIC(renderer, -1);
    retval = QueueCmdClear(renderer);
    return retval < 0 ? retval : FlushRenderCommandsIfNotBatching(renderer);
}

References CHECK_RENDERER_MAGIC, FlushRenderCommandsIfNotBatching(), QueueCmdClear(), renderer, and retval.

SDL_RenderCopy()

int 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 target.

Parameters

renderer	The renderer which should copy parts of a texture.
texture	The source texture.
srcrect	A pointer to the source rectangle, or NULL for the entire texture.
dstrect	A pointer to the destination rectangle, or NULL for the entire rendering target.

Returns

0 on success, or -1 on error

Definition at line 2952 of file SDL_render.c.

{
    SDL_FRect dstfrect;
    SDL_FRect *pdstfrect = NULL;
    if (dstrect) {
        dstfrect.x = (float) dstrect->x;
        dstfrect.y = (float) dstrect->y;
        dstfrect.w = (float) dstrect->w;
        dstfrect.h = (float) dstrect->h;
        pdstfrect = &dstfrect;
    }
    return SDL_RenderCopyF(renderer, texture, srcrect, pdstfrect);
}

References SDL_Rect::h, SDL_FRect::h, NULL, renderer, SDL_RenderCopyF(), SDL_Rect::w, SDL_FRect::w, SDL_Rect::x, SDL_FRect::x, SDL_Rect::y, and SDL_FRect::y.

SDL_RenderCopyEx()

int 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
	)

Copy a portion of the source texture to the current rendering target, rotating it by angle around the given center.

Parameters

renderer	The renderer which should copy parts of a texture.
texture	The source texture.
srcrect	A pointer to the source rectangle, or NULL for the entire texture.
dstrect	A pointer to the destination rectangle, or NULL for the entire rendering target.
angle	An angle in degrees that indicates the rotation that will be applied to dstrect, rotating it in a clockwise direction
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).
flip	An SDL_RendererFlip value stating which flipping actions should be performed on the texture

Returns

0 on success, or -1 on error

Definition at line 3027 of file SDL_render.c.

{
    SDL_FRect dstfrect;
    SDL_FRect *pdstfrect = NULL;
    SDL_FPoint fcenter;
    SDL_FPoint *pfcenter = NULL;
 
    if (dstrect) {
        dstfrect.x = (float) dstrect->x;
        dstfrect.y = (float) dstrect->y;
        dstfrect.w = (float) dstrect->w;
        dstfrect.h = (float) dstrect->h;
        pdstfrect = &dstfrect;
    }
 
    if (center) {
        fcenter.x = (float) center->x;
        fcenter.y = (float) center->y;
        pfcenter = &fcenter;
    }
 
    return SDL_RenderCopyExF(renderer, texture, srcrect, pdstfrect, angle, pfcenter, flip);
}

References SDL_Rect::h, SDL_FRect::h, NULL, renderer, SDL_RenderCopyExF(), SDL_Rect::w, SDL_FRect::w, SDL_Point::x, SDL_FPoint::x, SDL_Rect::x, SDL_FRect::x, SDL_Point::y, SDL_FPoint::y, SDL_Rect::y, and SDL_FRect::y.

SDL_RenderCopyExF()

int 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
	)

Copy a portion of the source texture to the current rendering target, rotating it by angle around the given center.

Parameters

renderer	The renderer which should copy parts of a texture.
texture	The source texture.
srcrect	A pointer to the source rectangle, or NULL for the entire texture.
dstrect	A pointer to the destination rectangle, or NULL for the entire rendering target.
angle	An angle in degrees that indicates the rotation that will be applied to dstrect, rotating it in a clockwise direction
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).
flip	An SDL_RendererFlip value stating which flipping actions should be performed on the texture

Returns

0 on success, or -1 on error

Definition at line 3054 of file SDL_render.c.

{
    SDL_Rect real_srcrect;
    SDL_FRect real_dstrect;
    SDL_FPoint real_center;
    int retval;
 
    if (flip == SDL_FLIP_NONE && (int)(angle/360) == angle/360) { /* fast path when we don't need rotation or flipping */
        return SDL_RenderCopyF(renderer, texture, srcrect, dstrect);
    }
 
    CHECK_RENDERER_MAGIC(renderer, -1);
    CHECK_TEXTURE_MAGIC(texture, -1);
 
    if (renderer != texture->renderer) {
        return SDL_SetError("Texture was not created with this renderer");
    }
    if (!renderer->QueueCopyEx) {
        return SDL_SetError("Renderer does not support RenderCopyEx");
    }
 
    /* Don't draw while we're hidden */
    if (renderer->hidden) {
        return 0;
    }
 
    real_srcrect.x = 0;
    real_srcrect.y = 0;
    real_srcrect.w = texture->w;
    real_srcrect.h = texture->h;
    if (srcrect) {
        if (!SDL_IntersectRect(srcrect, &real_srcrect, &real_srcrect)) {
            return 0;
        }
    }
 
    /* We don't intersect the dstrect with the viewport as RenderCopy does because of potential rotation clipping issues... TODO: should we? */
    if (dstrect) {
        real_dstrect = *dstrect;
    } else {
        SDL_Rect r;
        SDL_zero(r);
        SDL_RenderGetViewport(renderer, &r);
        real_dstrect.x = 0.0f;
        real_dstrect.y = 0.0f;
        real_dstrect.w = (float) r.w;
        real_dstrect.h = (float) r.h;
    }
 
    if (texture->native) {
        texture = texture->native;
    }
 
    if (center) {
        real_center = *center;
    } else {
        real_center.x = real_dstrect.w / 2.0f;
        real_center.y = real_dstrect.h / 2.0f;
    }
 
    real_dstrect.x *= renderer->scale.x;
    real_dstrect.y *= renderer->scale.y;
    real_dstrect.w *= renderer->scale.x;
    real_dstrect.h *= renderer->scale.y;
 
    real_center.x *= renderer->scale.x;
    real_center.y *= renderer->scale.y;
 
    texture->last_command_generation = renderer->render_command_generation;
 
    retval = QueueCmdCopyEx(renderer, texture, &real_srcrect, &real_dstrect, angle, &real_center, flip);
    return retval < 0 ? retval : FlushRenderCommandsIfNotBatching(renderer);
}

References CHECK_RENDERER_MAGIC, CHECK_TEXTURE_MAGIC, FlushRenderCommandsIfNotBatching(), SDL_Rect::h, SDL_FRect::h, SDL_Renderer::hidden, QueueCmdCopyEx(), SDL_Renderer::QueueCopyEx, SDL_Renderer::render_command_generation, renderer, retval, SDL_Renderer::scale, SDL_FLIP_NONE, SDL_IntersectRect, SDL_RenderCopyF(), SDL_RenderGetViewport(), SDL_SetError, SDL_zero, SDL_Rect::w, SDL_FRect::w, SDL_FPoint::x, SDL_Rect::x, SDL_FRect::x, SDL_FPoint::y, SDL_Rect::y, and SDL_FRect::y.

Referenced by SDL_RenderCopyEx().

SDL_RenderCopyF()

int SDL_RenderCopyF	(	SDL_Renderer *	renderer,
		SDL_Texture *	texture,
		const SDL_Rect *	srcrect,
		const SDL_FRect *	dstrect
	)

Copy a portion of the texture to the current rendering target.

Parameters

renderer	The renderer which should copy parts of a texture.
texture	The source texture.
srcrect	A pointer to the source rectangle, or NULL for the entire texture.
dstrect	A pointer to the destination rectangle, or NULL for the entire rendering target.

Returns

0 on success, or -1 on error

Definition at line 2968 of file SDL_render.c.

{
    SDL_Rect real_srcrect;
    SDL_FRect real_dstrect;
    SDL_Rect r;
    int retval;
 
    CHECK_RENDERER_MAGIC(renderer, -1);
    CHECK_TEXTURE_MAGIC(texture, -1);
 
    if (renderer != texture->renderer) {
        return SDL_SetError("Texture was not created with this renderer");
    }
 
    /* Don't draw while we're hidden */
    if (renderer->hidden) {
        return 0;
    }
 
    real_srcrect.x = 0;
    real_srcrect.y = 0;
    real_srcrect.w = texture->w;
    real_srcrect.h = texture->h;
    if (srcrect) {
        if (!SDL_IntersectRect(srcrect, &real_srcrect, &real_srcrect)) {
            return 0;
        }
    }
 
    SDL_zero(r);
    SDL_RenderGetViewport(renderer, &r);
    real_dstrect.x = 0.0f;
    real_dstrect.y = 0.0f;
    real_dstrect.w = (float) r.w;
    real_dstrect.h = (float) r.h;
    if (dstrect) {
        if (!SDL_HasIntersectionF(dstrect, &real_dstrect)) {
            return 0;
        }
        real_dstrect = *dstrect;
    }
 
    if (texture->native) {
        texture = texture->native;
    }
 
    real_dstrect.x *= renderer->scale.x;
    real_dstrect.y *= renderer->scale.y;
    real_dstrect.w *= renderer->scale.x;
    real_dstrect.h *= renderer->scale.y;
 
    texture->last_command_generation = renderer->render_command_generation;
 
    retval = QueueCmdCopy(renderer, texture, &real_srcrect, &real_dstrect);
    return retval < 0 ? retval : FlushRenderCommandsIfNotBatching(renderer);
}

References CHECK_RENDERER_MAGIC, CHECK_TEXTURE_MAGIC, FlushRenderCommandsIfNotBatching(), SDL_Rect::h, SDL_FRect::h, SDL_Renderer::hidden, QueueCmdCopy(), SDL_Renderer::render_command_generation, renderer, retval, SDL_Renderer::scale, SDL_HasIntersectionF(), SDL_IntersectRect, SDL_RenderGetViewport(), SDL_SetError, SDL_zero, SDL_Rect::w, SDL_FRect::w, SDL_FPoint::x, SDL_Rect::x, SDL_FRect::x, SDL_FPoint::y, SDL_Rect::y, and SDL_FRect::y.

Referenced by SDL_RenderCopy(), and SDL_RenderCopyExF().

SDL_RenderDrawLine()

int SDL_RenderDrawLine	(	SDL_Renderer *	renderer,
		int	x1,
		int	y1,
		int	x2,
		int	y2
	)

Draw a line on the current rendering target.

Parameters

renderer	The renderer which should draw a line.
x1	The x coordinate of the start point.
y1	The y coordinate of the start point.
x2	The x coordinate of the end point.
y2	The y coordinate of the end point.

Returns

0 on success, or -1 on error

Definition at line 2447 of file SDL_render.c.

{
    SDL_FPoint points[2];
    points[0].x = (float) x1;
    points[0].y = (float) y1;
    points[1].x = (float) x2;
    points[1].y = (float) y2;
    return SDL_RenderDrawLinesF(renderer, points, 2);
}

References renderer, SDL_RenderDrawLinesF(), and SDL_FPoint::x.

SDL_RenderDrawLineF()

int SDL_RenderDrawLineF	(	SDL_Renderer *	renderer,
		float	x1,
		float	y1,
		float	x2,
		float	y2
	)

Draw a line on the current rendering target.

Parameters

renderer	The renderer which should draw a line.
x1	The x coordinate of the start point.
y1	The y coordinate of the start point.
x2	The x coordinate of the end point.
y2	The y coordinate of the end point.

Returns

0 on success, or -1 on error

Definition at line 2458 of file SDL_render.c.

{
    SDL_FPoint points[2];
    points[0].x = x1;
    points[0].y = y1;
    points[1].x = x2;
    points[1].y = y2;
    return SDL_RenderDrawLinesF(renderer, points, 2);
}

References renderer, SDL_RenderDrawLinesF(), and SDL_FPoint::x.

SDL_RenderDrawLines()

int SDL_RenderDrawLines	(	SDL_Renderer *	renderer,
		const SDL_Point *	points,
		int	count
	)

Draw a series of connected lines on the current rendering target.

Parameters

renderer	The renderer which should draw multiple lines.
points	The points along the lines
count	The number of points, drawing count-1 lines

Returns

0 on success, or -1 on error

Definition at line 2579 of file SDL_render.c.

{
    SDL_FPoint *fpoints;
    int i;
    int retval;
    SDL_bool isstack;
 
    CHECK_RENDERER_MAGIC(renderer, -1);
 
    if (!points) {
        return SDL_SetError("SDL_RenderDrawLines(): Passed NULL points");
    }
    if (count < 2) {
        return 0;
    }
 
    /* Don't draw while we're hidden */
    if (renderer->hidden) {
        return 0;
    }
 
    if (renderer->scale.x != 1.0f || renderer->scale.y != 1.0f) {
        return RenderDrawLinesWithRects(renderer, points, count);
    }
 
    fpoints = SDL_small_alloc(SDL_FPoint, count, &isstack);
    if (!fpoints) {
        return SDL_OutOfMemory();
    }
    for (i = 0; i < count; ++i) {
        fpoints[i].x = points[i].x * renderer->scale.x;
        fpoints[i].y = points[i].y * renderer->scale.y;
    }
 
    retval = QueueCmdDrawLines(renderer, fpoints, count);
 
    SDL_small_free(fpoints, isstack);
 
    return retval < 0 ? retval : FlushRenderCommandsIfNotBatching(renderer);
}

References CHECK_RENDERER_MAGIC, FlushRenderCommandsIfNotBatching(), SDL_Renderer::hidden, i, QueueCmdDrawLines(), RenderDrawLinesWithRects(), renderer, retval, SDL_Renderer::scale, SDL_OutOfMemory, SDL_SetError, SDL_small_alloc, SDL_small_free, SDL_FPoint::x, and SDL_FPoint::y.

SDL_RenderDrawLinesF()

int SDL_RenderDrawLinesF	(	SDL_Renderer *	renderer,
		const SDL_FPoint *	points,
		int	count
	)

Draw a series of connected lines on the current rendering target.

Parameters

renderer	The renderer which should draw multiple lines.
points	The points along the lines
count	The number of points, drawing count-1 lines

Returns

0 on success, or -1 on error

Definition at line 2622 of file SDL_render.c.

{
    SDL_FPoint *fpoints;
    int i;
    int retval;
    SDL_bool isstack;
 
    CHECK_RENDERER_MAGIC(renderer, -1);
 
    if (!points) {
        return SDL_SetError("SDL_RenderDrawLines(): Passed NULL points");
    }
    if (count < 2) {
        return 0;
    }
 
    /* Don't draw while we're hidden */
    if (renderer->hidden) {
        return 0;
    }
 
    if (renderer->scale.x != 1.0f || renderer->scale.y != 1.0f) {
        return RenderDrawLinesWithRectsF(renderer, points, count);
    }
 
    fpoints = SDL_small_alloc(SDL_FPoint, count, &isstack);
    if (!fpoints) {
        return SDL_OutOfMemory();
    }
    for (i = 0; i < count; ++i) {
        fpoints[i].x = points[i].x * renderer->scale.x;
        fpoints[i].y = points[i].y * renderer->scale.y;
    }
 
    retval = QueueCmdDrawLines(renderer, fpoints, count);
 
    SDL_small_free(fpoints, isstack);
 
    return retval < 0 ? retval : FlushRenderCommandsIfNotBatching(renderer);
}

References CHECK_RENDERER_MAGIC, FlushRenderCommandsIfNotBatching(), SDL_Renderer::hidden, i, QueueCmdDrawLines(), RenderDrawLinesWithRectsF(), renderer, retval, SDL_Renderer::scale, SDL_OutOfMemory, SDL_SetError, SDL_small_alloc, SDL_small_free, SDL_FPoint::x, and SDL_FPoint::y.

Referenced by SDL_RenderDrawLine(), SDL_RenderDrawLineF(), and SDL_RenderDrawRectF().

SDL_RenderDrawPoint()

int SDL_RenderDrawPoint	(	SDL_Renderer *	renderer,
		int	x,
		int	y
	)

Draw a point on the current rendering target.

Parameters

renderer	The renderer which should draw a point.
x	The x coordinate of the point.
y	The y coordinate of the point.

Returns

0 on success, or -1 on error

Definition at line 2289 of file SDL_render.c.

{
    SDL_FPoint fpoint;
    fpoint.x = (float) x;
    fpoint.y = (float) y;
    return SDL_RenderDrawPointsF(renderer, &fpoint, 1);
}

References renderer, SDL_RenderDrawPointsF(), SDL_FPoint::x, and SDL_FPoint::y.

SDL_RenderDrawPointF()

int SDL_RenderDrawPointF	(	SDL_Renderer *	renderer,
		float	x,
		float	y
	)

Draw a point on the current rendering target.

Parameters

renderer	The renderer which should draw a point.
x	The x coordinate of the point.
y	The y coordinate of the point.

Returns

0 on success, or -1 on error

Definition at line 2298 of file SDL_render.c.

{
    SDL_FPoint fpoint;
    fpoint.x = x;
    fpoint.y = y;
    return SDL_RenderDrawPointsF(renderer, &fpoint, 1);
}

References renderer, SDL_RenderDrawPointsF(), SDL_FPoint::x, and SDL_FPoint::y.

SDL_RenderDrawPoints()

int SDL_RenderDrawPoints	(	SDL_Renderer *	renderer,
		const SDL_Point *	points,
		int	count
	)

Draw multiple points on the current rendering target.

Parameters

renderer	The renderer which should draw multiple points.
points	The points to draw
count	The number of points to draw

Returns

0 on success, or -1 on error

Definition at line 2334 of file SDL_render.c.

{
    SDL_FPoint *fpoints;
    int i;
    int retval;
    SDL_bool isstack;
 
    CHECK_RENDERER_MAGIC(renderer, -1);
 
    if (!points) {
        return SDL_SetError("SDL_RenderDrawPoints(): Passed NULL points");
    }
    if (count < 1) {
        return 0;
    }
 
    /* Don't draw while we're hidden */
    if (renderer->hidden) {
        return 0;
    }
 
    if (renderer->scale.x != 1.0f || renderer->scale.y != 1.0f) {
        return RenderDrawPointsWithRects(renderer, points, count);
    }
 
    fpoints = SDL_small_alloc(SDL_FPoint, count, &isstack);
    if (!fpoints) {
        return SDL_OutOfMemory();
    }
    for (i = 0; i < count; ++i) {
        fpoints[i].x = points[i].x * renderer->scale.x;
        fpoints[i].y = points[i].y * renderer->scale.y;
    }
 
    retval = QueueCmdDrawPoints(renderer, fpoints, count);
 
    SDL_small_free(fpoints, isstack);
 
    return retval < 0 ? retval : FlushRenderCommandsIfNotBatching(renderer);
}

References CHECK_RENDERER_MAGIC, FlushRenderCommandsIfNotBatching(), SDL_Renderer::hidden, i, QueueCmdDrawPoints(), RenderDrawPointsWithRects(), renderer, retval, SDL_Renderer::scale, SDL_OutOfMemory, SDL_SetError, SDL_small_alloc, SDL_small_free, SDL_FPoint::x, and SDL_FPoint::y.

SDL_RenderDrawPointsF()

int SDL_RenderDrawPointsF	(	SDL_Renderer *	renderer,
		const SDL_FPoint *	points,
		int	count
	)

Draw multiple points on the current rendering target.

Parameters

renderer	The renderer which should draw multiple points.
points	The points to draw
count	The number of points to draw

Returns

0 on success, or -1 on error

Definition at line 2404 of file SDL_render.c.

{
    SDL_FPoint *fpoints;
    int i;
    int retval;
    SDL_bool isstack;
 
    CHECK_RENDERER_MAGIC(renderer, -1);
 
    if (!points) {
        return SDL_SetError("SDL_RenderDrawFPoints(): Passed NULL points");
    }
    if (count < 1) {
        return 0;
    }
 
    /* Don't draw while we're hidden */
    if (renderer->hidden) {
        return 0;
    }
 
    if (renderer->scale.x != 1.0f || renderer->scale.y != 1.0f) {
        return RenderDrawPointsWithRectsF(renderer, points, count);
    }
 
    fpoints = SDL_small_alloc(SDL_FPoint, count, &isstack);
    if (!fpoints) {
        return SDL_OutOfMemory();
    }
    for (i = 0; i < count; ++i) {
        fpoints[i].x = points[i].x * renderer->scale.x;
        fpoints[i].y = points[i].y * renderer->scale.y;
    }
 
    retval = QueueCmdDrawPoints(renderer, fpoints, count);
 
    SDL_small_free(fpoints, isstack);
 
    return retval < 0 ? retval : FlushRenderCommandsIfNotBatching(renderer);
}

References CHECK_RENDERER_MAGIC, FlushRenderCommandsIfNotBatching(), SDL_Renderer::hidden, i, QueueCmdDrawPoints(), RenderDrawPointsWithRectsF(), renderer, retval, SDL_Renderer::scale, SDL_OutOfMemory, SDL_SetError, SDL_small_alloc, SDL_small_free, SDL_FPoint::x, and SDL_FPoint::y.

Referenced by SDL_RenderDrawPoint(), and SDL_RenderDrawPointF().

SDL_RenderDrawRect()

int SDL_RenderDrawRect	(	SDL_Renderer *	renderer,
		const SDL_Rect *	rect
	)

Draw a rectangle on the current rendering target.

Parameters

renderer	The renderer which should draw a rectangle.
rect	A pointer to the destination rectangle, or NULL to outline the entire rendering target.

Returns

0 on success, or -1 on error

Definition at line 2665 of file SDL_render.c.

{
    SDL_FRect frect;
    SDL_FRect *prect = NULL;
 
    if (rect) {
        frect.x = (float) rect->x;
        frect.y = (float) rect->y;
        frect.w = (float) rect->w;
        frect.h = (float) rect->h;
        prect = &frect;
    }
 
    return SDL_RenderDrawRectF(renderer, prect);
}

References SDL_Rect::h, SDL_FRect::h, NULL, rect, renderer, SDL_RenderDrawRectF(), SDL_Rect::w, SDL_FRect::w, SDL_Rect::x, SDL_FRect::x, SDL_Rect::y, and SDL_FRect::y.

Referenced by SDL_RenderDrawRects().

SDL_RenderDrawRectF()

int SDL_RenderDrawRectF	(	SDL_Renderer *	renderer,
		const SDL_FRect *	rect
	)

Draw a rectangle on the current rendering target.

Parameters

renderer	The renderer which should draw a rectangle.
rect	A pointer to the destination rectangle, or NULL to outline the entire rendering target.

Returns

0 on success, or -1 on error

Definition at line 2682 of file SDL_render.c.

{
    SDL_FRect frect;
    SDL_FPoint points[5];
 
    CHECK_RENDERER_MAGIC(renderer, -1);
 
    /* If 'rect' == NULL, then outline the whole surface */
    if (!rect) {
        SDL_Rect r;
        SDL_RenderGetViewport(renderer, &r);
        frect.x = 0.0f;
        frect.y = 0.0f;
        frect.w = (float) r.w;
        frect.h = (float) r.h;
        rect = &frect;
    }
 
    points[0].x = rect->x;
    points[0].y = rect->y;
    points[1].x = rect->x+rect->w-1;
    points[1].y = rect->y;
    points[2].x = rect->x+rect->w-1;
    points[2].y = rect->y+rect->h-1;
    points[3].x = rect->x;
    points[3].y = rect->y+rect->h-1;
    points[4].x = rect->x;
    points[4].y = rect->y;
    return SDL_RenderDrawLinesF(renderer, points, 5);
}

References CHECK_RENDERER_MAGIC, SDL_Rect::h, SDL_FRect::h, rect, renderer, SDL_RenderDrawLinesF(), SDL_RenderGetViewport(), SDL_Rect::w, SDL_FRect::w, SDL_Rect::x, SDL_FRect::x, SDL_Rect::y, and SDL_FRect::y.

Referenced by SDL_RenderDrawRect(), and SDL_RenderDrawRectsF().

SDL_RenderDrawRects()

int SDL_RenderDrawRects	(	SDL_Renderer *	renderer,
		const SDL_Rect *	rects,
		int	count
	)

Draw some number of rectangles on the current rendering target.

Parameters

renderer	The renderer which should draw multiple rectangles.
rects	A pointer to an array of destination rectangles.
count	The number of rectangles.

Returns

0 on success, or -1 on error

Definition at line 2714 of file SDL_render.c.

{
    int i;
 
    CHECK_RENDERER_MAGIC(renderer, -1);
 
    if (!rects) {
        return SDL_SetError("SDL_RenderDrawRects(): Passed NULL rects");
    }
    if (count < 1) {
        return 0;
    }
 
    /* Don't draw while we're hidden */
    if (renderer->hidden) {
        return 0;
    }
 
    for (i = 0; i < count; ++i) {
        if (SDL_RenderDrawRect(renderer, &rects[i]) < 0) {
            return -1;
        }
    }
    return 0;
}

References CHECK_RENDERER_MAGIC, SDL_Renderer::hidden, i, renderer, SDL_RenderDrawRect(), and SDL_SetError.

SDL_RenderDrawRectsF()

int SDL_RenderDrawRectsF	(	SDL_Renderer *	renderer,
		const SDL_FRect *	rects,
		int	count
	)

Draw some number of rectangles on the current rendering target.

Parameters

renderer	The renderer which should draw multiple rectangles.
rects	A pointer to an array of destination rectangles.
count	The number of rectangles.

Returns

0 on success, or -1 on error

Definition at line 2742 of file SDL_render.c.

{
    int i;
 
    CHECK_RENDERER_MAGIC(renderer, -1);
 
    if (!rects) {
        return SDL_SetError("SDL_RenderDrawRects(): Passed NULL rects");
    }
    if (count < 1) {
        return 0;
    }
 
    /* Don't draw while we're hidden */
    if (renderer->hidden) {
        return 0;
    }
 
    for (i = 0; i < count; ++i) {
        if (SDL_RenderDrawRectF(renderer, &rects[i]) < 0) {
            return -1;
        }
    }
    return 0;
}

References CHECK_RENDERER_MAGIC, SDL_Renderer::hidden, i, renderer, SDL_RenderDrawRectF(), and SDL_SetError.

SDL_RendererEventWatch()

static int SDL_RendererEventWatch ( void *  userdata, SDL_Event *  event  )

static

Definition at line 587 of file SDL_render.c.

{
    SDL_Renderer *renderer = (SDL_Renderer *)userdata;
 
    if (event->type == SDL_WINDOWEVENT) {
        SDL_Window *window = SDL_GetWindowFromID(event->window.windowID);
        if (window == renderer->window) {
            if (renderer->WindowEvent) {
                renderer->WindowEvent(renderer, &event->window);
            }
 
            if (event->window.event == SDL_WINDOWEVENT_SIZE_CHANGED) {
                /* Make sure we're operating on the default render target */
                SDL_Texture *saved_target = SDL_GetRenderTarget(renderer);
                if (saved_target) {
                    SDL_SetRenderTarget(renderer, NULL);
                }
 
                if (renderer->logical_w) {
                    UpdateLogicalSize(renderer);
                } else {
                    /* Window was resized, reset viewport */
                    int w, h;
 
                    if (renderer->GetOutputSize) {
                        renderer->GetOutputSize(renderer, &w, &h);
                    } else {
                        SDL_GetWindowSize(renderer->window, &w, &h);
                    }
 
                    if (renderer->target) {
                        renderer->viewport_backup.x = 0;
                        renderer->viewport_backup.y = 0;
                        renderer->viewport_backup.w = w;
                        renderer->viewport_backup.h = h;
                    } else {
                        renderer->viewport.x = 0;
                        renderer->viewport.y = 0;
                        renderer->viewport.w = w;
                        renderer->viewport.h = h;
                        QueueCmdSetViewport(renderer);
                        FlushRenderCommandsIfNotBatching(renderer);
                    }
                }
 
                if (saved_target) {
                    SDL_SetRenderTarget(renderer, saved_target);
                }
            } else if (event->window.event == SDL_WINDOWEVENT_HIDDEN) {
                renderer->hidden = SDL_TRUE;
            } else if (event->window.event == SDL_WINDOWEVENT_SHOWN) {
                if (!(SDL_GetWindowFlags(window) & SDL_WINDOW_MINIMIZED)) {
                    renderer->hidden = SDL_FALSE;
                }
            } else if (event->window.event == SDL_WINDOWEVENT_MINIMIZED) {
                renderer->hidden = SDL_TRUE;
            } else if (event->window.event == SDL_WINDOWEVENT_RESTORED || 
                       event->window.event == SDL_WINDOWEVENT_MAXIMIZED) {
                if (!(SDL_GetWindowFlags(window) & SDL_WINDOW_HIDDEN)) {
                    renderer->hidden = SDL_FALSE;
                }
            }
        }
    } else if (event->type == SDL_MOUSEMOTION) {
        SDL_Window *window = SDL_GetWindowFromID(event->motion.windowID);
        if (window == renderer->window) {
            int logical_w, logical_h;
            SDL_Rect viewport;
            SDL_FPoint scale;
            GetWindowViewportValues(renderer, &logical_w, &logical_h, &viewport, &scale);
            if (logical_w) {
                event->motion.x -= (int)(viewport.x * renderer->dpi_scale.x);
                event->motion.y -= (int)(viewport.y * renderer->dpi_scale.y);
                event->motion.x = (int)(event->motion.x / (scale.x * renderer->dpi_scale.x));
                event->motion.y = (int)(event->motion.y / (scale.y * renderer->dpi_scale.y));
                if (event->motion.xrel != 0 && renderer->relative_scaling) {
                    float rel = renderer->xrel + event->motion.xrel / (scale.x * renderer->dpi_scale.x);
                    float trunc = SDL_truncf(rel);
                    renderer->xrel = rel - trunc;
                    event->motion.xrel = (Sint32) trunc;
                }
                if (event->motion.yrel != 0 && renderer->relative_scaling) {
                    float rel = renderer->yrel + event->motion.yrel / (scale.y * renderer->dpi_scale.y);
                    float trunc = SDL_truncf(rel);
                    renderer->yrel = rel - trunc;
                    event->motion.yrel = (Sint32) trunc;
                }
            }
        }
    } else if (event->type == SDL_MOUSEBUTTONDOWN ||
               event->type == SDL_MOUSEBUTTONUP) {
        SDL_Window *window = SDL_GetWindowFromID(event->button.windowID);
        if (window == renderer->window) {
            int logical_w, logical_h;
            SDL_Rect viewport;
            SDL_FPoint scale;
            GetWindowViewportValues(renderer, &logical_w, &logical_h, &viewport, &scale);
            if (logical_w) {
                event->button.x -= (int)(viewport.x * renderer->dpi_scale.x);
                event->button.y -= (int)(viewport.y * renderer->dpi_scale.y);
                event->button.x = (int)(event->button.x / (scale.x * renderer->dpi_scale.x));
                event->button.y = (int)(event->button.y / (scale.y * renderer->dpi_scale.y));
            }
        }                               
    } else if (event->type == SDL_FINGERDOWN ||
               event->type == SDL_FINGERUP ||
               event->type == SDL_FINGERMOTION) {
        int logical_w, logical_h;
        float physical_w, physical_h;
        SDL_Rect viewport;
        SDL_FPoint scale;
        GetWindowViewportValues(renderer, &logical_w, &logical_h, &viewport, &scale);
 
        /* !!! FIXME: we probably should drop events that are outside of the
           !!! FIXME: viewport, but we can't do that from an event watcher,
           !!! FIXME: and we would have to track if a touch happened outside
           !!! FIXME: the viewport and then slid into it to insert extra
           !!! FIXME: events, which is a mess, so for now we just clamp these
           !!! FIXME: events to the edge. */
 
        if (renderer->GetOutputSize) {
            int w, h;
            renderer->GetOutputSize(renderer, &w, &h);
            physical_w = (float) w;
            physical_h = (float) h;
        } else {
            int w, h;
            SDL_GetWindowSize(renderer->window, &w, &h);
            physical_w = ((float) w) * renderer->dpi_scale.x;
            physical_h = ((float) h) * renderer->dpi_scale.y;
        }
 
        if (physical_w == 0.0f) {  /* nowhere for the touch to go, avoid division by zero and put it dead center. */
            event->tfinger.x = 0.5f;
        } else {
            const float normalized_viewport_x = ((float) viewport.x) / physical_w;
            const float normalized_viewport_w = ((float) viewport.w) / physical_w;
            if (event->tfinger.x <= normalized_viewport_x) {
                event->tfinger.x = 0.0f;  /* to the left of the viewport, clamp to the edge. */
            } else if (event->tfinger.x >= (normalized_viewport_x + normalized_viewport_w)) {
                event->tfinger.x = 1.0f;  /* to the right of the viewport, clamp to the edge. */
            } else {
                event->tfinger.x = (event->tfinger.x - normalized_viewport_x) / normalized_viewport_w;
            }
        }
 
        if (physical_h == 0.0f) {  /* nowhere for the touch to go, avoid division by zero and put it dead center. */
            event->tfinger.y = 0.5f;
        } else {
            const float normalized_viewport_y = ((float) viewport.y) / physical_h;
            const float normalized_viewport_h = ((float) viewport.h) / physical_h;
            if (event->tfinger.y <= normalized_viewport_y) {
                event->tfinger.y = 0.0f;  /* to the left of the viewport, clamp to the edge. */
            } else if (event->tfinger.y >= (normalized_viewport_y + normalized_viewport_h)) {
                event->tfinger.y = 1.0f;  /* to the right of the viewport, clamp to the edge. */
            } else {
                event->tfinger.y = (event->tfinger.y - normalized_viewport_y) / normalized_viewport_h;
            }
        }
    }
 
    return 0;
}

References SDL_Renderer::dpi_scale, FlushRenderCommandsIfNotBatching(), SDL_Renderer::GetOutputSize, GetWindowViewportValues(), SDL_Rect::h, SDL_Renderer::hidden, int(), SDL_Renderer::logical_w, NULL, QueueCmdSetViewport(), SDL_Renderer::relative_scaling, renderer, SDL_FALSE, SDL_FINGERDOWN, SDL_FINGERMOTION, SDL_FINGERUP, SDL_GetRenderTarget(), SDL_GetWindowFlags, SDL_GetWindowFromID, SDL_GetWindowSize, SDL_MOUSEBUTTONDOWN, SDL_MOUSEBUTTONUP, SDL_MOUSEMOTION, SDL_SetRenderTarget(), SDL_TRUE, SDL_truncf, SDL_WINDOW_HIDDEN, SDL_WINDOW_MINIMIZED, SDL_WINDOWEVENT, SDL_WINDOWEVENT_HIDDEN, SDL_WINDOWEVENT_MAXIMIZED, SDL_WINDOWEVENT_MINIMIZED, SDL_WINDOWEVENT_RESTORED, SDL_WINDOWEVENT_SHOWN, SDL_WINDOWEVENT_SIZE_CHANGED, SDL_Renderer::target, UpdateLogicalSize(), SDL_Renderer::viewport, viewport, SDL_Renderer::viewport_backup, SDL_Rect::w, SDL_Renderer::window, SDL_Renderer::WindowEvent, SDL_FPoint::x, SDL_Rect::x, SDL_Renderer::xrel, SDL_FPoint::y, SDL_Rect::y, and SDL_Renderer::yrel.

Referenced by SDL_CreateRenderer(), and SDL_DestroyRenderer().

SDL_RenderFillRect()

int SDL_RenderFillRect	(	SDL_Renderer *	renderer,
		const SDL_Rect *	rect
	)

Fill a rectangle on the current rendering target with the drawing color.

Parameters

renderer	The renderer which should fill a rectangle.
rect	A pointer to the destination rectangle, or NULL for the entire rendering target.

Returns

0 on success, or -1 on error

Definition at line 2770 of file SDL_render.c.

{
    SDL_FRect frect;
 
    CHECK_RENDERER_MAGIC(renderer, -1);
 
    /* If 'rect' == NULL, then outline the whole surface */
    if (rect) {
        frect.x = (float) rect->x;
        frect.y = (float) rect->y;
        frect.w = (float) rect->w;
        frect.h = (float) rect->h;
    } else {
        SDL_Rect r;
        SDL_zero(r);
        SDL_RenderGetViewport(renderer, &r);
        frect.x = 0.0f;
        frect.y = 0.0f;
        frect.w = (float) r.w;
        frect.h = (float) r.h;
    }
    return SDL_RenderFillRectsF(renderer, &frect, 1);
}

References CHECK_RENDERER_MAGIC, SDL_Rect::h, SDL_FRect::h, rect, renderer, SDL_RenderFillRectsF(), SDL_RenderGetViewport(), SDL_zero, SDL_Rect::w, SDL_FRect::w, SDL_Rect::x, SDL_FRect::x, SDL_Rect::y, and SDL_FRect::y.

SDL_RenderFillRectF()

int SDL_RenderFillRectF	(	SDL_Renderer *	renderer,
		const SDL_FRect *	rect
	)

Fill a rectangle on the current rendering target with the drawing color.

Parameters

renderer	The renderer which should fill a rectangle.
rect	A pointer to the destination rectangle, or NULL for the entire rendering target.

Returns

0 on success, or -1 on error

Definition at line 2795 of file SDL_render.c.

{
    SDL_FRect frect;
 
    CHECK_RENDERER_MAGIC(renderer, -1);
 
    /* If 'rect' == NULL, then outline the whole surface */
    if (!rect) {
        SDL_Rect r;
        SDL_zero(r);
        SDL_RenderGetViewport(renderer, &r);
        frect.x = 0.0f;
        frect.y = 0.0f;
        frect.w = (float) r.w;
        frect.h = (float) r.h;
        rect = &frect;
    }
    return SDL_RenderFillRectsF(renderer, rect, 1);
}

References CHECK_RENDERER_MAGIC, SDL_FRect::h, rect, renderer, SDL_RenderFillRectsF(), SDL_RenderGetViewport(), SDL_zero, SDL_FRect::w, SDL_FRect::x, and SDL_FRect::y.

SDL_RenderFillRects()

int SDL_RenderFillRects	(	SDL_Renderer *	renderer,
		const SDL_Rect *	rects,
		int	count
	)

Fill some number of rectangles on the current rendering target with the drawing color.

Parameters

renderer	The renderer which should fill multiple rectangles.
rects	A pointer to an array of destination rectangles.
count	The number of rectangles.

Returns

0 on success, or -1 on error

Definition at line 2816 of file SDL_render.c.

{
    SDL_FRect *frects;
    int i;
    int retval;
    SDL_bool isstack;
 
    CHECK_RENDERER_MAGIC(renderer, -1);
 
    if (!rects) {
        return SDL_SetError("SDL_RenderFillRects(): Passed NULL rects");
    }
    if (count < 1) {
        return 0;
    }
 
    /* Don't draw while we're hidden */
    if (renderer->hidden) {
        return 0;
    }
 
    frects = SDL_small_alloc(SDL_FRect, count, &isstack);
    if (!frects) {
        return SDL_OutOfMemory();
    }
    for (i = 0; i < count; ++i) {
        frects[i].x = rects[i].x * renderer->scale.x;
        frects[i].y = rects[i].y * renderer->scale.y;
        frects[i].w = rects[i].w * renderer->scale.x;
        frects[i].h = rects[i].h * renderer->scale.y;
    }
 
    retval = QueueCmdFillRects(renderer, frects, count);
 
    SDL_small_free(frects, isstack);
 
    return retval < 0 ? retval : FlushRenderCommandsIfNotBatching(renderer);
}

References CHECK_RENDERER_MAGIC, FlushRenderCommandsIfNotBatching(), SDL_FRect::h, SDL_Renderer::hidden, i, QueueCmdFillRects(), renderer, retval, SDL_Renderer::scale, SDL_OutOfMemory, SDL_SetError, SDL_small_alloc, SDL_small_free, SDL_FRect::w, SDL_FPoint::x, SDL_FRect::x, SDL_FPoint::y, and SDL_FRect::y.

SDL_RenderFillRectsF()

int SDL_RenderFillRectsF	(	SDL_Renderer *	renderer,
		const SDL_FRect *	rects,
		int	count
	)

Fill some number of rectangles on the current rendering target with the drawing color.

Parameters

renderer	The renderer which should fill multiple rectangles.
rects	A pointer to an array of destination rectangles.
count	The number of rectangles.

Returns

0 on success, or -1 on error

Definition at line 2857 of file SDL_render.c.

{
    SDL_FRect *frects;
    int i;
    int retval;
    SDL_bool isstack;
 
    CHECK_RENDERER_MAGIC(renderer, -1);
 
    if (!rects) {
        return SDL_SetError("SDL_RenderFillFRects(): Passed NULL rects");
    }
    if (count < 1) {
        return 0;
    }
 
    /* Don't draw while we're hidden */
    if (renderer->hidden) {
        return 0;
    }
 
    frects = SDL_small_alloc(SDL_FRect, count, &isstack);
    if (!frects) {
        return SDL_OutOfMemory();
    }
    for (i = 0; i < count; ++i) {
        frects[i].x = rects[i].x * renderer->scale.x;
        frects[i].y = rects[i].y * renderer->scale.y;
        frects[i].w = rects[i].w * renderer->scale.x;
        frects[i].h = rects[i].h * renderer->scale.y;
    }
 
    retval = QueueCmdFillRects(renderer, frects, count);
 
    SDL_small_free(frects, isstack);
 
    return retval < 0 ? retval : FlushRenderCommandsIfNotBatching(renderer);
}

References CHECK_RENDERER_MAGIC, FlushRenderCommandsIfNotBatching(), SDL_FRect::h, SDL_Renderer::hidden, i, QueueCmdFillRects(), renderer, retval, SDL_Renderer::scale, SDL_OutOfMemory, SDL_SetError, SDL_small_alloc, SDL_small_free, SDL_FRect::w, SDL_FPoint::x, SDL_FRect::x, SDL_FPoint::y, and SDL_FRect::y.

Referenced by SDL_RenderFillRect(), and SDL_RenderFillRectF().

SDL_RenderFlush()

int SDL_RenderFlush

(

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.

Definition at line 256 of file SDL_render.c.

{
    return FlushRenderCommands(renderer);
}

References FlushRenderCommands(), and renderer.

SDL_RenderGetClipRect()

void SDL_RenderGetClipRect	(	SDL_Renderer *	renderer,
		SDL_Rect *	rect
	)

Get the clip rectangle for the current target.

Parameters

renderer	The renderer from which clip rectangle should be queried.
rect	A pointer filled in with the current clip rectangle, or an empty rectangle if clipping is disabled.

See also

SDL_RenderSetClipRect()

Definition at line 2178 of file SDL_render.c.

{
    CHECK_RENDERER_MAGIC(renderer, )
 
    if (rect) {
        rect->x = (int)(renderer->clip_rect.x / renderer->scale.x);
        rect->y = (int)(renderer->clip_rect.y / renderer->scale.y);
        rect->w = (int)(renderer->clip_rect.w / renderer->scale.x);
        rect->h = (int)(renderer->clip_rect.h / renderer->scale.y);
    }
}

References CHECK_RENDERER_MAGIC, SDL_Renderer::clip_rect, SDL_Rect::h, int(), rect, renderer, SDL_Renderer::scale, SDL_Rect::w, SDL_FPoint::x, SDL_Rect::x, SDL_FPoint::y, and SDL_Rect::y.

SDL_RenderGetIntegerScale()

SDL_bool SDL_RenderGetIntegerScale

(

SDL_Renderer *

renderer

)

Get whether integer scales are forced for resolution-independent rendering.

Parameters

renderer

The renderer from which integer scaling should be queried.

See also

SDL_RenderSetIntegerScale()

Definition at line 2114 of file SDL_render.c.

{
    CHECK_RENDERER_MAGIC(renderer, SDL_FALSE);
 
    return renderer->integer_scale;
}

References CHECK_RENDERER_MAGIC, SDL_Renderer::integer_scale, renderer, and SDL_FALSE.

SDL_RenderGetLogicalSize()

void SDL_RenderGetLogicalSize	(	SDL_Renderer *	renderer,
		int *	w,
		int *	h
	)

Get device independent resolution for rendering.

Parameters

renderer	The renderer from which resolution should be queried.
w	A pointer filled with the width of the logical resolution
h	A pointer filled with the height of the logical resolution

See also

SDL_RenderSetLogicalSize()

Definition at line 2091 of file SDL_render.c.

{
    CHECK_RENDERER_MAGIC(renderer, );
 
    if (w) {
        *w = renderer->logical_w;
    }
    if (h) {
        *h = renderer->logical_h;
    }
}

References CHECK_RENDERER_MAGIC, SDL_Renderer::logical_h, SDL_Renderer::logical_w, and renderer.

SDL_RenderGetMetalCommandEncoder()

void* SDL_RenderGetMetalCommandEncoder

(

SDL_Renderer *

renderer

)

Get the Metal command encoder for the current frame.

Parameters

renderer

The renderer to query

Returns

id<MTLRenderCommandEncoder> on success, or NULL if the renderer isn't a Metal renderer

See also

SDL_RenderGetMetalLayer()

Definition at line 3321 of file SDL_render.c.

{
    CHECK_RENDERER_MAGIC(renderer, NULL);
 
    if (renderer->GetMetalCommandEncoder) {
        FlushRenderCommands(renderer);  /* in case the app is going to mess with it. */
        return renderer->GetMetalCommandEncoder(renderer);
    }
    return NULL;
}

References CHECK_RENDERER_MAGIC, FlushRenderCommands(), SDL_Renderer::GetMetalCommandEncoder, NULL, and renderer.

SDL_RenderGetMetalLayer()

void* SDL_RenderGetMetalLayer

(

SDL_Renderer *

renderer

)

Get the CAMetalLayer associated with the given Metal renderer.

Parameters

renderer

The renderer to query

Returns

CAMetalLayer* on success, or NULL if the renderer isn't a Metal renderer

See also

SDL_RenderGetMetalCommandEncoder()

Definition at line 3309 of file SDL_render.c.

{
    CHECK_RENDERER_MAGIC(renderer, NULL);
 
    if (renderer->GetMetalLayer) {
        FlushRenderCommands(renderer);  /* in case the app is going to mess with it. */
        return renderer->GetMetalLayer(renderer);
    }
    return NULL;
}

References CHECK_RENDERER_MAGIC, FlushRenderCommands(), SDL_Renderer::GetMetalLayer, NULL, and renderer.

SDL_RenderGetScale()

void SDL_RenderGetScale	(	SDL_Renderer *	renderer,
		float *	scaleX,
		float *	scaleY
	)

Get the drawing scale for the current target.

Parameters

renderer	The renderer from which drawing scale should be queried.
scaleX	A pointer filled in with the horizontal scaling factor
scaleY	A pointer filled in with the vertical scaling factor

See also

SDL_RenderSetScale()

Definition at line 2208 of file SDL_render.c.

{
    CHECK_RENDERER_MAGIC(renderer, );
 
    if (scaleX) {
        *scaleX = renderer->scale.x;
    }
    if (scaleY) {
        *scaleY = renderer->scale.y;
    }
}

References CHECK_RENDERER_MAGIC, renderer, SDL_Renderer::scale, SDL_FPoint::x, and SDL_FPoint::y.

SDL_RenderGetViewport()

void SDL_RenderGetViewport	(	SDL_Renderer *	renderer,
		SDL_Rect *	rect
	)

Get the drawing area for the current target.

See also

SDL_RenderSetViewport()

Definition at line 2144 of file SDL_render.c.

{
    CHECK_RENDERER_MAGIC(renderer, );
 
    if (rect) {
        rect->x = (int)(renderer->viewport.x / renderer->scale.x);
        rect->y = (int)(renderer->viewport.y / renderer->scale.y);
        rect->w = (int)(renderer->viewport.w / renderer->scale.x);
        rect->h = (int)(renderer->viewport.h / renderer->scale.y);
    }
}

References CHECK_RENDERER_MAGIC, SDL_Rect::h, int(), rect, renderer, SDL_Renderer::scale, SDL_Renderer::viewport, SDL_Rect::w, SDL_FPoint::x, SDL_Rect::x, SDL_FPoint::y, and SDL_Rect::y.

Referenced by SDL_RenderCopyExF(), SDL_RenderCopyF(), SDL_RenderDrawRectF(), SDL_RenderFillRect(), and SDL_RenderFillRectF().

SDL_RenderIsClipEnabled()

SDL_bool SDL_RenderIsClipEnabled

(

SDL_Renderer *

renderer

)

Get whether clipping is enabled on the given renderer.

Parameters

renderer

The renderer from which clip state should be queried.

See also

SDL_RenderGetClipRect()

Definition at line 2191 of file SDL_render.c.

{
    CHECK_RENDERER_MAGIC(renderer, SDL_FALSE)
    return renderer->clipping_enabled;
}

References CHECK_RENDERER_MAGIC, SDL_Renderer::clipping_enabled, renderer, and SDL_FALSE.

SDL_RenderPresent()

void SDL_RenderPresent

(

SDL_Renderer *

renderer

)

Update the screen with rendering performed.

Definition at line 3170 of file SDL_render.c.

{
    CHECK_RENDERER_MAGIC(renderer, );
 
    FlushRenderCommands(renderer);  /* time to send everything to the GPU! */
 
    /* Don't present while we're hidden */
    if (renderer->hidden) {
        return;
    }
    renderer->RenderPresent(renderer);
}

References CHECK_RENDERER_MAGIC, FlushRenderCommands(), SDL_Renderer::hidden, renderer, and SDL_Renderer::RenderPresent.

SDL_RenderReadPixels()

int SDL_RenderReadPixels	(	SDL_Renderer *	renderer,
		const SDL_Rect *	rect,
		Uint32	format,
		void *	pixels,
		int	pitch
	)

Read pixels from the current rendering target.

Parameters

renderer	The renderer from which pixels should be read.
rect	A pointer to the rectangle to read, or NULL for the entire render target.
format	The desired format of the pixel data, or 0 to use the format of the rendering target
pixels	A pointer to be filled in with the pixel data
pitch	The pitch of the pixels parameter.

Returns

0 on success, or -1 if pixel reading is not supported.

Warning

This is a very slow operation, and should not be used frequently.

Definition at line 3131 of file SDL_render.c.

{
    SDL_Rect real_rect;
 
    CHECK_RENDERER_MAGIC(renderer, -1);
 
    if (!renderer->RenderReadPixels) {
        return SDL_Unsupported();
    }
 
    FlushRenderCommands(renderer);  /* we need to render before we read the results. */
 
    if (!format) {
        format = SDL_GetWindowPixelFormat(renderer->window);
    }
 
    real_rect.x = renderer->viewport.x;
    real_rect.y = renderer->viewport.y;
    real_rect.w = renderer->viewport.w;
    real_rect.h = renderer->viewport.h;
    if (rect) {
        if (!SDL_IntersectRect(rect, &real_rect, &real_rect)) {
            return 0;
        }
        if (real_rect.y > rect->y) {
            pixels = (Uint8 *)pixels + pitch * (real_rect.y - rect->y);
        }
        if (real_rect.x > rect->x) {
            int bpp = SDL_BYTESPERPIXEL(format);
            pixels = (Uint8 *)pixels + bpp * (real_rect.x - rect->x);
        }
    }
 
    return renderer->RenderReadPixels(renderer, &real_rect,
                                      format, pixels, pitch);
}

References bpp, CHECK_RENDERER_MAGIC, FlushRenderCommands(), SDL_Rect::h, rect, renderer, SDL_Renderer::RenderReadPixels, SDL_BYTESPERPIXEL, SDL_GetWindowPixelFormat, SDL_IntersectRect, SDL_Unsupported, SDL_Renderer::viewport, SDL_Rect::w, SDL_Renderer::window, SDL_Rect::x, and SDL_Rect::y.

SDL_RenderSetClipRect()

int SDL_RenderSetClipRect	(	SDL_Renderer *	renderer,
		const SDL_Rect *	rect
	)

Set the clip rectangle for the current target.

Parameters

renderer	The renderer for which clip rectangle should be set.
rect	A pointer to the rectangle to set as the clip rectangle, relative to the viewport, or NULL to disable clipping.

Returns

0 on success, or -1 on error

See also

SDL_RenderGetClipRect()

Definition at line 2157 of file SDL_render.c.

{
    int retval;
    CHECK_RENDERER_MAGIC(renderer, -1)
 
    if (rect) {
        renderer->clipping_enabled = SDL_TRUE;
        renderer->clip_rect.x = (int)SDL_floor(rect->x * renderer->scale.x);
        renderer->clip_rect.y = (int)SDL_floor(rect->y * renderer->scale.y);
        renderer->clip_rect.w = (int)SDL_ceil(rect->w * renderer->scale.x);
        renderer->clip_rect.h = (int)SDL_ceil(rect->h * renderer->scale.y);
    } else {
        renderer->clipping_enabled = SDL_FALSE;
        SDL_zero(renderer->clip_rect);
    }
 
    retval = QueueCmdSetClipRect(renderer);
    return retval < 0 ? retval : FlushRenderCommandsIfNotBatching(renderer);
}

References CHECK_RENDERER_MAGIC, SDL_Renderer::clip_rect, SDL_Renderer::clipping_enabled, FlushRenderCommandsIfNotBatching(), SDL_Rect::h, int(), QueueCmdSetClipRect(), rect, renderer, retval, SDL_Renderer::scale, SDL_ceil, SDL_FALSE, SDL_floor, SDL_TRUE, SDL_zero, SDL_Rect::w, SDL_FPoint::x, SDL_Rect::x, SDL_FPoint::y, and SDL_Rect::y.

SDL_RenderSetIntegerScale()

int SDL_RenderSetIntegerScale	(	SDL_Renderer *	renderer,
		SDL_bool	enable
	)

Set whether to force integer scales for resolution-independent rendering.

Parameters

renderer	The renderer for which integer scaling should be set.
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.

See also

SDL_RenderSetLogicalSize()

Definition at line 2104 of file SDL_render.c.

{
    CHECK_RENDERER_MAGIC(renderer, -1);
 
    renderer->integer_scale = enable;
 
    return UpdateLogicalSize(renderer);
}

References CHECK_RENDERER_MAGIC, SDL_Renderer::integer_scale, renderer, and UpdateLogicalSize().

SDL_RenderSetLogicalSize()

int SDL_RenderSetLogicalSize	(	SDL_Renderer *	renderer,
		int	w,
		int	h
	)

Set device independent resolution for rendering.

Parameters

renderer	The renderer for which resolution should be set.
w	The width of the logical resolution
h	The height of the logical resolution

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 events in the window will be filtered and scaled so they seem to arrive within the logical resolution.

Note

If this function results in scaling or subpixel drawing by the rendering backend, it will be handled using the appropriate quality hints.

See also

SDL_RenderGetLogicalSize()

SDL_RenderSetScale()

SDL_RenderSetViewport()

Definition at line 2071 of file SDL_render.c.

{
    CHECK_RENDERER_MAGIC(renderer, -1);
 
    if (!w || !h) {
        /* Clear any previous logical resolution */
        renderer->logical_w = 0;
        renderer->logical_h = 0;
        SDL_RenderSetViewport(renderer, NULL);
        SDL_RenderSetScale(renderer, 1.0f, 1.0f);
        return 0;
    }
 
    renderer->logical_w = w;
    renderer->logical_h = h;
 
    return UpdateLogicalSize(renderer);
}

References CHECK_RENDERER_MAGIC, SDL_Renderer::logical_h, SDL_Renderer::logical_w, NULL, renderer, SDL_RenderSetScale(), SDL_RenderSetViewport(), and UpdateLogicalSize().

SDL_RenderSetScale()

int SDL_RenderSetScale	(	SDL_Renderer *	renderer,
		float	scaleX,
		float	scaleY
	)

Set the drawing scale for rendering on the current target.

Parameters

renderer	The renderer for which the drawing scale should be set.
scaleX	The horizontal scaling factor
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.

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.

See also

SDL_RenderGetScale()

SDL_RenderSetLogicalSize()

Definition at line 2198 of file SDL_render.c.

{
    CHECK_RENDERER_MAGIC(renderer, -1);
 
    renderer->scale.x = scaleX;
    renderer->scale.y = scaleY;
    return 0;
}

References CHECK_RENDERER_MAGIC, renderer, SDL_Renderer::scale, SDL_FPoint::x, and SDL_FPoint::y.

Referenced by SDL_RenderSetLogicalSize(), and UpdateLogicalSize().

SDL_RenderSetViewport()

int SDL_RenderSetViewport	(	SDL_Renderer *	renderer,
		const SDL_Rect *	rect
	)

Set the drawing area for rendering on the current target.

Parameters

renderer	The renderer for which the drawing area should be set.
rect	The rectangle representing the drawing area, or NULL to set the viewport to the entire target.

The x,y of the viewport rect represents the origin for rendering.

Returns

0 on success, or -1 on error

Note

If the window associated with the renderer is resized, the viewport is automatically reset.

See also

SDL_RenderGetViewport()

SDL_RenderSetLogicalSize()

Definition at line 2122 of file SDL_render.c.

{
    int retval;
    CHECK_RENDERER_MAGIC(renderer, -1);
 
    if (rect) {
        renderer->viewport.x = (int)SDL_floor(rect->x * renderer->scale.x);
        renderer->viewport.y = (int)SDL_floor(rect->y * renderer->scale.y);
        renderer->viewport.w = (int)SDL_ceil(rect->w * renderer->scale.x);
        renderer->viewport.h = (int)SDL_ceil(rect->h * renderer->scale.y);
    } else {
        renderer->viewport.x = 0;
        renderer->viewport.y = 0;
        if (SDL_GetRendererOutputSize(renderer, &renderer->viewport.w, &renderer->viewport.h) < 0) {
            return -1;
        }
    }
    retval = QueueCmdSetViewport(renderer);
    return retval < 0 ? retval : FlushRenderCommandsIfNotBatching(renderer);
}

References CHECK_RENDERER_MAGIC, FlushRenderCommandsIfNotBatching(), SDL_Rect::h, int(), QueueCmdSetViewport(), rect, renderer, retval, SDL_Renderer::scale, SDL_ceil, SDL_floor, SDL_GetRendererOutputSize(), SDL_Renderer::viewport, SDL_Rect::w, SDL_FPoint::x, SDL_Rect::x, SDL_FPoint::y, and SDL_Rect::y.

Referenced by SDL_CreateRenderer(), SDL_CreateSoftwareRenderer(), SDL_RenderSetLogicalSize(), and UpdateLogicalSize().

SDL_RenderTargetSupported()

SDL_bool SDL_RenderTargetSupported

(

SDL_Renderer *

renderer

)

Determines whether a window supports the use of render targets.

Parameters

renderer

The renderer that will be checked

Returns

SDL_TRUE if supported, SDL_FALSE if not.

Definition at line 1867 of file SDL_render.c.

{
    if (!renderer || !renderer->SetRenderTarget) {
        return SDL_FALSE;
    }
    return (renderer->info.flags & SDL_RENDERER_TARGETTEXTURE) != 0;
}

References SDL_RendererInfo::flags, SDL_Renderer::info, renderer, SDL_FALSE, SDL_RENDERER_TARGETTEXTURE, and SDL_Renderer::SetRenderTarget.

Referenced by SDL_SetRenderTarget().

SDL_SetRenderDrawBlendMode()

int SDL_SetRenderDrawBlendMode	(	SDL_Renderer *	renderer,
		SDL_BlendMode	blendMode
	)

Set the blend mode used for drawing operations (Fill and Line).

Parameters

renderer	The renderer for which blend mode should be set.
blendMode	SDL_BlendMode to use for blending.

Returns

0 on success, or -1 on error

Note

If the blend mode is not supported, the closest supported mode is chosen.

See also

SDL_GetRenderDrawBlendMode()

Definition at line 2255 of file SDL_render.c.

{
    CHECK_RENDERER_MAGIC(renderer, -1);
 
    if (!IsSupportedBlendMode(renderer, blendMode)) {
        return SDL_Unsupported();
    }
    renderer->blendMode = blendMode;
    return 0;
}

References SDL_Renderer::blendMode, blendMode, CHECK_RENDERER_MAGIC, IsSupportedBlendMode(), renderer, and SDL_Unsupported.

SDL_SetRenderDrawColor()

int SDL_SetRenderDrawColor	(	SDL_Renderer *	renderer,
		Uint8	r,
		Uint8	g,
		Uint8	b,
		Uint8	a
	)

Set the color used for drawing operations (Rect, Line and Clear).

Parameters

renderer	The renderer for which drawing color should be set.
r	The red value used to draw on the rendering target.
g	The green value used to draw on the rendering target.
b	The blue value used to draw on the rendering target.
a	The alpha value used to draw on the rendering target, usually SDL_ALPHA_OPAQUE (255).

Returns

0 on success, or -1 on error

Definition at line 2221 of file SDL_render.c.

{
    CHECK_RENDERER_MAGIC(renderer, -1);
 
    renderer->r = r;
    renderer->g = g;
    renderer->b = b;
    renderer->a = a;
    return 0;
}

References SDL_Renderer::a, SDL_Renderer::b, CHECK_RENDERER_MAGIC, SDL_Renderer::g, SDL_Renderer::r, and renderer.

SDL_SetRenderTarget()

int SDL_SetRenderTarget	(	SDL_Renderer *	renderer,
		SDL_Texture *	texture
	)

Set a texture as the current rendering target.

Parameters

renderer	The renderer.
texture	The targeted texture, which must be created with the SDL_TEXTUREACCESS_TARGET flag, or NULL for the default render target

Returns

0 on success, or -1 on error

See also

SDL_GetRenderTarget()

Definition at line 1876 of file SDL_render.c.

{
    if (!SDL_RenderTargetSupported(renderer)) {
        return SDL_Unsupported();
    }
 
    /* texture == NULL is valid and means reset the target to the window */
    if (texture) {
        CHECK_TEXTURE_MAGIC(texture, -1);
        if (renderer != texture->renderer) {
            return SDL_SetError("Texture was not created with this renderer");
        }
        if (texture->access != SDL_TEXTUREACCESS_TARGET) {
            return SDL_SetError("Texture not created with SDL_TEXTUREACCESS_TARGET");
        }
        if (texture->native) {
            /* Always render to the native texture */
            texture = texture->native;
        }
    }
 
    if (texture == renderer->target) {
        /* Nothing to do! */
        return 0;
    }
 
    FlushRenderCommands(renderer);  /* time to send everything to the GPU! */
 
    SDL_LockMutex(renderer->target_mutex);
 
    if (texture && !renderer->target) {
        /* Make a backup of the viewport */
        renderer->viewport_backup = renderer->viewport;
        renderer->clip_rect_backup = renderer->clip_rect;
        renderer->clipping_enabled_backup = renderer->clipping_enabled;
        renderer->scale_backup = renderer->scale;
        renderer->logical_w_backup = renderer->logical_w;
        renderer->logical_h_backup = renderer->logical_h;
    }
    renderer->target = texture;
 
    if (renderer->SetRenderTarget(renderer, texture) < 0) {
        SDL_UnlockMutex(renderer->target_mutex);
        return -1;
    }
 
    if (texture) {
        renderer->viewport.x = 0;
        renderer->viewport.y = 0;
        renderer->viewport.w = texture->w;
        renderer->viewport.h = texture->h;
        SDL_zero(renderer->clip_rect);
        renderer->clipping_enabled = SDL_FALSE;
        renderer->scale.x = 1.0f;
        renderer->scale.y = 1.0f;
        renderer->logical_w = texture->w;
        renderer->logical_h = texture->h;
    } else {
        renderer->viewport = renderer->viewport_backup;
        renderer->clip_rect = renderer->clip_rect_backup;
        renderer->clipping_enabled = renderer->clipping_enabled_backup;
        renderer->scale = renderer->scale_backup;
        renderer->logical_w = renderer->logical_w_backup;
        renderer->logical_h = renderer->logical_h_backup;
    }
 
    SDL_UnlockMutex(renderer->target_mutex);
 
    if (QueueCmdSetViewport(renderer) < 0) {
        return -1;
    }
    if (QueueCmdSetClipRect(renderer) < 0) {
        return -1;
    }
 
    /* All set! */
    return FlushRenderCommandsIfNotBatching(renderer);
}

References CHECK_TEXTURE_MAGIC, SDL_Renderer::clip_rect, SDL_Renderer::clip_rect_backup, SDL_Renderer::clipping_enabled, SDL_Renderer::clipping_enabled_backup, FlushRenderCommands(), FlushRenderCommandsIfNotBatching(), SDL_Rect::h, SDL_Renderer::logical_h, SDL_Renderer::logical_h_backup, SDL_Renderer::logical_w, SDL_Renderer::logical_w_backup, QueueCmdSetClipRect(), QueueCmdSetViewport(), renderer, SDL_Renderer::scale, SDL_Renderer::scale_backup, SDL_FALSE, SDL_LockMutex, SDL_RenderTargetSupported(), SDL_SetError, SDL_TEXTUREACCESS_TARGET, SDL_UnlockMutex, SDL_Unsupported, SDL_zero, SDL_Renderer::SetRenderTarget, SDL_Renderer::target, SDL_Renderer::target_mutex, SDL_Renderer::viewport, SDL_Renderer::viewport_backup, SDL_Rect::w, SDL_FPoint::x, SDL_Rect::x, SDL_FPoint::y, and SDL_Rect::y.

Referenced by SDL_DestroyTexture(), and SDL_RendererEventWatch().

SDL_SetTextureAlphaMod()

int SDL_SetTextureAlphaMod	(	SDL_Texture *	texture,
		Uint8	alpha
	)

Set an additional alpha value used in render copy operations.

Parameters

texture	The texture to update.
alpha	The alpha value multiplied into copy operations.

Returns

0 on success, or -1 if the texture is not valid or alpha modulation is not supported.

See also

SDL_GetTextureAlphaMod()

Definition at line 1367 of file SDL_render.c.

{
    CHECK_TEXTURE_MAGIC(texture, -1);
 
    if (alpha < 255) {
        texture->modMode |= SDL_TEXTUREMODULATE_ALPHA;
    } else {
        texture->modMode &= ~SDL_TEXTUREMODULATE_ALPHA;
    }
    texture->a = alpha;
    if (texture->native) {
        return SDL_SetTextureAlphaMod(texture->native, alpha);
    }
    return 0;
}

References CHECK_TEXTURE_MAGIC, SDL_SetTextureAlphaMod(), and SDL_TEXTUREMODULATE_ALPHA.

Referenced by SDL_CreateTextureFromSurface(), and SDL_SetTextureAlphaMod().

SDL_SetTextureBlendMode()

int SDL_SetTextureBlendMode	(	SDL_Texture *	texture,
		SDL_BlendMode	blendMode
	)

Set the blend mode used for texture copy operations.

Parameters

texture	The texture to update.
blendMode	SDL_BlendMode to use for texture blending.

Returns

0 on success, or -1 if the texture is not valid or the blend mode is not supported.

Note

If the blend mode is not supported, the closest supported mode is chosen.

See also

SDL_GetTextureBlendMode()

Definition at line 1395 of file SDL_render.c.

{
    SDL_Renderer *renderer;
 
    CHECK_TEXTURE_MAGIC(texture, -1);
 
    renderer = texture->renderer;
    if (!IsSupportedBlendMode(renderer, blendMode)) {
        return SDL_Unsupported();
    }
    texture->blendMode = blendMode;
    if (texture->native) {
        return SDL_SetTextureBlendMode(texture->native, blendMode);
    }
    return 0;
}

References blendMode, CHECK_TEXTURE_MAGIC, IsSupportedBlendMode(), renderer, SDL_SetTextureBlendMode(), and SDL_Unsupported.

Referenced by SDL_CreateTextureFromSurface(), and SDL_SetTextureBlendMode().

SDL_SetTextureColorMod()

int SDL_SetTextureColorMod	(	SDL_Texture *	texture,
		Uint8	r,
		Uint8	g,
		Uint8	b
	)

Set an additional color value used in render copy operations.

Parameters

texture	The texture to update.
r	The red color value multiplied into copy operations.
g	The green color value multiplied into copy operations.
b	The blue color value multiplied into copy operations.

Returns

0 on success, or -1 if the texture is not valid or color modulation is not supported.

See also

SDL_GetTextureColorMod()

Definition at line 1330 of file SDL_render.c.

{
    CHECK_TEXTURE_MAGIC(texture, -1);
 
    if (r < 255 || g < 255 || b < 255) {
        texture->modMode |= SDL_TEXTUREMODULATE_COLOR;
    } else {
        texture->modMode &= ~SDL_TEXTUREMODULATE_COLOR;
    }
    texture->r = r;
    texture->g = g;
    texture->b = b;
    if (texture->native) {
        return SDL_SetTextureColorMod(texture->native, r, g, b);
    }
    return 0;
}

References CHECK_TEXTURE_MAGIC, SDL_SetTextureColorMod(), and SDL_TEXTUREMODULATE_COLOR.

Referenced by SDL_CreateTextureFromSurface(), and SDL_SetTextureColorMod().

SDL_SetTextureScaleMode()

int SDL_SetTextureScaleMode	(	SDL_Texture *	texture,
		SDL_ScaleMode	scaleMode
	)

Set the scale mode used for texture scale operations.

Parameters

texture	The texture to update.
scaleMode	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.

See also

SDL_GetTextureScaleMode()

Definition at line 1424 of file SDL_render.c.

{
    SDL_Renderer *renderer;
 
    CHECK_TEXTURE_MAGIC(texture, -1);
 
    renderer = texture->renderer;
    renderer->SetTextureScaleMode(renderer, texture, scaleMode);
    texture->scaleMode = scaleMode;
    if (texture->native) {
        return SDL_SetTextureScaleMode(texture->native, scaleMode);
    }
    return 0;
}

References CHECK_TEXTURE_MAGIC, renderer, SDL_SetTextureScaleMode(), and SDL_Renderer::SetTextureScaleMode.

Referenced by SDL_SetTextureScaleMode().

SDL_UnlockTexture()

void SDL_UnlockTexture

(

SDL_Texture *

texture

)

Unlock a texture, uploading the changes to video memory, if needed. If SDL_LockTextureToSurface() was called for locking, the SDL surface is freed.

See also

SDL_LockTexture()

SDL_LockTextureToSurface()

Definition at line 1843 of file SDL_render.c.

{
    CHECK_TEXTURE_MAGIC(texture, );
 
    if (texture->access != SDL_TEXTUREACCESS_STREAMING) {
        return;
    }
#if SDL_HAVE_YUV
    if (texture->yuv) {
        SDL_UnlockTextureYUV(texture);
    } else
#endif
    if (texture->native) {
        SDL_UnlockTextureNative(texture);
    } else {
        SDL_Renderer *renderer = texture->renderer;
        renderer->UnlockTexture(renderer, texture);
    }
 
    SDL_FreeSurface(texture->locked_surface);
    texture->locked_surface = NULL;
}

References CHECK_TEXTURE_MAGIC, NULL, renderer, SDL_FreeSurface, SDL_TEXTUREACCESS_STREAMING, SDL_UnlockTextureNative(), SDL_UnlockTextureYUV(), and SDL_Renderer::UnlockTexture.

Referenced by SDL_LockTextureToSurface(), SDL_UnlockTextureNative(), SDL_UnlockTextureYUV(), SDL_UpdateTextureNative(), SDL_UpdateTextureYUV(), and SDL_UpdateTextureYUVPlanar().

SDL_UnlockTextureNative()

static void SDL_UnlockTextureNative ( SDL_Texture *  texture )

static

Definition at line 1822 of file SDL_render.c.

{
    SDL_Texture *native = texture->native;
    void *native_pixels = NULL;
    int native_pitch = 0;
    const SDL_Rect *rect = &texture->locked_rect;
    const void* pixels = (void *) ((Uint8 *) texture->pixels +
                        rect->y * texture->pitch +
                        rect->x * SDL_BYTESPERPIXEL(texture->format));
    int pitch = texture->pitch;
 
    if (SDL_LockTexture(native, rect, &native_pixels, &native_pitch) < 0) {
        return;
    }
    SDL_ConvertPixels(rect->w, rect->h,
                      texture->format, pixels, pitch,
                      native->format, native_pixels, native_pitch);
    SDL_UnlockTexture(native);
}

References SDL_Texture::format, SDL_Rect::h, SDL_Texture::native, NULL, rect, SDL_BYTESPERPIXEL, SDL_ConvertPixels, SDL_LockTexture(), SDL_UnlockTexture(), SDL_Rect::w, SDL_Rect::x, and SDL_Rect::y.

Referenced by SDL_UnlockTexture().

SDL_UnlockTextureYUV()

static void SDL_UnlockTextureYUV ( SDL_Texture *  texture )

static

Definition at line 1800 of file SDL_render.c.

{
    SDL_Texture *native = texture->native;
    void *native_pixels = NULL;
    int native_pitch = 0;
    SDL_Rect rect;
 
    rect.x = 0;
    rect.y = 0;
    rect.w = texture->w;
    rect.h = texture->h;
 
    if (SDL_LockTexture(native, &rect, &native_pixels, &native_pitch) < 0) {
        return;
    }
    SDL_SW_CopyYUVToRGB(texture->yuv, &rect, native->format,
                        rect.w, rect.h, native_pixels, native_pitch);
    SDL_UnlockTexture(native);
}

References SDL_Texture::format, SDL_Rect::h, SDL_Texture::native, NULL, rect, SDL_LockTexture(), SDL_SW_CopyYUVToRGB(), SDL_UnlockTexture(), SDL_Rect::w, SDL_Rect::x, and SDL_Rect::y.

Referenced by SDL_UnlockTexture().

SDL_UpdateTexture()

int SDL_UpdateTexture	(	SDL_Texture *	texture,
		const SDL_Rect *	rect,
		const void *	pixels,
		int	pitch
	)

Update the given texture rectangle with new pixel data.

Parameters

texture	The texture to update
rect	A pointer to the rectangle of pixels to update, or NULL to update the entire texture.
pixels	The raw pixel data in the format of the texture.
pitch	The number of bytes in a row of pixel data, including padding between lines.

The pixel data must be in the format of the texture. The pixel format can be queried with SDL_QueryTexture.

Returns

0 on success, or -1 if the texture is not valid.

Note

This is a fairly slow function.

Definition at line 1540 of file SDL_render.c.

{
    SDL_Rect full_rect;
 
    CHECK_TEXTURE_MAGIC(texture, -1);
 
    if (!pixels) {
        return SDL_InvalidParamError("pixels");
    }
    if (!pitch) {
        return SDL_InvalidParamError("pitch");
    }
 
    if (!rect) {
        full_rect.x = 0;
        full_rect.y = 0;
        full_rect.w = texture->w;
        full_rect.h = texture->h;
        rect = &full_rect;
    }
 
    if ((rect->w == 0) || (rect->h == 0)) {
        return 0;  /* nothing to do. */
#if SDL_HAVE_YUV
    } else if (texture->yuv) {
        return SDL_UpdateTextureYUV(texture, rect, pixels, pitch);
#endif
    } else if (texture->native) {
        return SDL_UpdateTextureNative(texture, rect, pixels, pitch);
    } else {
        SDL_Renderer *renderer = texture->renderer;
        if (FlushRenderCommandsIfTextureNeeded(texture) < 0) {
            return -1;
        }
        return renderer->UpdateTexture(renderer, texture, rect, pixels, pitch);
    }
}

References CHECK_TEXTURE_MAGIC, FlushRenderCommandsIfTextureNeeded(), SDL_Rect::h, rect, renderer, SDL_InvalidParamError, SDL_UpdateTextureNative(), SDL_UpdateTextureYUV(), SDL_Renderer::UpdateTexture, SDL_Rect::w, SDL_Rect::x, and SDL_Rect::y.

Referenced by SDL_CreateTextureFromSurface(), SDL_UpdateTextureNative(), SDL_UpdateTextureYUV(), and SDL_UpdateTextureYUVPlanar().

SDL_UpdateTextureNative()

static int SDL_UpdateTextureNative ( SDL_Texture *  texture, const SDL_Rect *  rect, const void *  pixels, int  pitch  )

static

Definition at line 1499 of file SDL_render.c.

{
    SDL_Texture *native = texture->native;
 
    if (!rect->w || !rect->h) {
        return 0;  /* nothing to do. */
    }
 
    if (texture->access == SDL_TEXTUREACCESS_STREAMING) {
        /* We can lock the texture and copy to it */
        void *native_pixels = NULL;
        int native_pitch = 0;
 
        if (SDL_LockTexture(native, rect, &native_pixels, &native_pitch) < 0) {
            return -1;
        }
        SDL_ConvertPixels(rect->w, rect->h,
                          texture->format, pixels, pitch,
                          native->format, native_pixels, native_pitch);
        SDL_UnlockTexture(native);
    } else {
        /* Use a temporary buffer for updating */
        const int temp_pitch = (((rect->w * SDL_BYTESPERPIXEL(native->format)) + 3) & ~3);
        const size_t alloclen = rect->h * temp_pitch;
        if (alloclen > 0) {
            void *temp_pixels = SDL_malloc(alloclen);
            if (!temp_pixels) {
                return SDL_OutOfMemory();
            }
            SDL_ConvertPixels(rect->w, rect->h,
                              texture->format, pixels, pitch,
                              native->format, temp_pixels, temp_pitch);
            SDL_UpdateTexture(native, rect, temp_pixels, temp_pitch);
            SDL_free(temp_pixels);
        }
    }
    return 0;
}

References SDL_Texture::format, SDL_Rect::h, SDL_Texture::native, NULL, rect, SDL_BYTESPERPIXEL, SDL_ConvertPixels, SDL_free, SDL_LockTexture(), SDL_malloc, SDL_OutOfMemory, SDL_TEXTUREACCESS_STREAMING, SDL_UnlockTexture(), SDL_UpdateTexture(), and SDL_Rect::w.

Referenced by SDL_UpdateTexture().

SDL_UpdateTextureYUV()

static int SDL_UpdateTextureYUV ( SDL_Texture *  texture, const SDL_Rect *  rect, const void *  pixels, int  pitch  )

static

Definition at line 1452 of file SDL_render.c.

{
    SDL_Texture *native = texture->native;
    SDL_Rect full_rect;
 
    if (SDL_SW_UpdateYUVTexture(texture->yuv, rect, pixels, pitch) < 0) {
        return -1;
    }
 
    full_rect.x = 0;
    full_rect.y = 0;
    full_rect.w = texture->w;
    full_rect.h = texture->h;
    rect = &full_rect;
 
    if (texture->access == SDL_TEXTUREACCESS_STREAMING) {
        /* We can lock the texture and copy to it */
        void *native_pixels = NULL;
        int native_pitch = 0;
 
        if (SDL_LockTexture(native, rect, &native_pixels, &native_pitch) < 0) {
            return -1;
        }
        SDL_SW_CopyYUVToRGB(texture->yuv, rect, native->format,
                            rect->w, rect->h, native_pixels, native_pitch);
        SDL_UnlockTexture(native);
    } else {
        /* Use a temporary buffer for updating */
        const int temp_pitch = (((rect->w * SDL_BYTESPERPIXEL(native->format)) + 3) & ~3);
        const size_t alloclen = rect->h * temp_pitch;
        if (alloclen > 0) {
            void *temp_pixels = SDL_malloc(alloclen);
            if (!temp_pixels) {
                return SDL_OutOfMemory();
            }
            SDL_SW_CopyYUVToRGB(texture->yuv, rect, native->format,
                                rect->w, rect->h, temp_pixels, temp_pitch);
            SDL_UpdateTexture(native, rect, temp_pixels, temp_pitch);
            SDL_free(temp_pixels);
        }
    }
    return 0;
}

References SDL_Texture::format, SDL_Rect::h, SDL_Texture::native, NULL, rect, SDL_BYTESPERPIXEL, SDL_free, SDL_LockTexture(), SDL_malloc, SDL_OutOfMemory, SDL_SW_CopyYUVToRGB(), SDL_SW_UpdateYUVTexture(), SDL_TEXTUREACCESS_STREAMING, SDL_UnlockTexture(), SDL_UpdateTexture(), SDL_Rect::w, SDL_Rect::x, and SDL_Rect::y.

Referenced by SDL_UpdateTexture().

SDL_UpdateTextureYUVPlanar()

static int SDL_UpdateTextureYUVPlanar ( SDL_Texture *  texture, const SDL_Rect *  rect, const Uint8 *  Yplane, int  Ypitch, const Uint8 *  Uplane, int  Upitch, const Uint8 *  Vplane, int  Vpitch  )

static

Definition at line 1581 of file SDL_render.c.

{
    SDL_Texture *native = texture->native;
    SDL_Rect full_rect;
 
    if (SDL_SW_UpdateYUVTexturePlanar(texture->yuv, rect, Yplane, Ypitch, Uplane, Upitch, Vplane, Vpitch) < 0) {
        return -1;
    }
 
    full_rect.x = 0;
    full_rect.y = 0;
    full_rect.w = texture->w;
    full_rect.h = texture->h;
    rect = &full_rect;
 
    if (!rect->w || !rect->h) {
        return 0;  /* nothing to do. */
    }
 
    if (texture->access == SDL_TEXTUREACCESS_STREAMING) {
        /* We can lock the texture and copy to it */
        void *native_pixels = NULL;
        int native_pitch = 0;
 
        if (SDL_LockTexture(native, rect, &native_pixels, &native_pitch) < 0) {
            return -1;
        }
        SDL_SW_CopyYUVToRGB(texture->yuv, rect, native->format,
                            rect->w, rect->h, native_pixels, native_pitch);
        SDL_UnlockTexture(native);
    } else {
        /* Use a temporary buffer for updating */
        const int temp_pitch = (((rect->w * SDL_BYTESPERPIXEL(native->format)) + 3) & ~3);
        const size_t alloclen = rect->h * temp_pitch;
        if (alloclen > 0) {
            void *temp_pixels = SDL_malloc(alloclen);
            if (!temp_pixels) {
                return SDL_OutOfMemory();
            }
            SDL_SW_CopyYUVToRGB(texture->yuv, rect, native->format,
                                rect->w, rect->h, temp_pixels, temp_pitch);
            SDL_UpdateTexture(native, rect, temp_pixels, temp_pitch);
            SDL_free(temp_pixels);
        }
    }
    return 0;
}

References SDL_Texture::format, SDL_Rect::h, SDL_Texture::native, NULL, rect, SDL_BYTESPERPIXEL, SDL_free, SDL_LockTexture(), SDL_malloc, SDL_OutOfMemory, SDL_SW_CopyYUVToRGB(), SDL_SW_UpdateYUVTexturePlanar(), SDL_TEXTUREACCESS_STREAMING, SDL_UnlockTexture(), SDL_UpdateTexture(), SDL_Rect::w, SDL_Rect::x, and SDL_Rect::y.

Referenced by SDL_UpdateYUVTexture().

SDL_UpdateYUVTexture()

int 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 YV12 or IYUV texture with new pixel data.

Parameters

texture	The texture to update
rect	A pointer to the rectangle of pixels to update, or NULL to update the entire texture.
Yplane	The raw pixel data for the Y plane.
Ypitch	The number of bytes between rows of pixel data for the Y plane.
Uplane	The raw pixel data for the U plane.
Upitch	The number of bytes between rows of pixel data for the U plane.
Vplane	The raw pixel data for the V plane.
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.

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.

Definition at line 1633 of file SDL_render.c.

{
#if SDL_HAVE_YUV
    SDL_Renderer *renderer;
    SDL_Rect full_rect;
 
    CHECK_TEXTURE_MAGIC(texture, -1);
 
    if (!Yplane) {
        return SDL_InvalidParamError("Yplane");
    }
    if (!Ypitch) {
        return SDL_InvalidParamError("Ypitch");
    }
    if (!Uplane) {
        return SDL_InvalidParamError("Uplane");
    }
    if (!Upitch) {
        return SDL_InvalidParamError("Upitch");
    }
    if (!Vplane) {
        return SDL_InvalidParamError("Vplane");
    }
    if (!Vpitch) {
        return SDL_InvalidParamError("Vpitch");
    }
 
    if (texture->format != SDL_PIXELFORMAT_YV12 &&
        texture->format != SDL_PIXELFORMAT_IYUV) {
        return SDL_SetError("Texture format must by YV12 or IYUV");
    }
 
    if (!rect) {
        full_rect.x = 0;
        full_rect.y = 0;
        full_rect.w = texture->w;
        full_rect.h = texture->h;
        rect = &full_rect;
    }
 
    if (!rect->w || !rect->h) {
        return 0;  /* nothing to do. */
    }
 
    if (texture->yuv) {
        return SDL_UpdateTextureYUVPlanar(texture, rect, Yplane, Ypitch, Uplane, Upitch, Vplane, Vpitch);
    } else {
        SDL_assert(!texture->native);
        renderer = texture->renderer;
        SDL_assert(renderer->UpdateTextureYUV);
        if (renderer->UpdateTextureYUV) {
            if (FlushRenderCommandsIfTextureNeeded(texture) < 0) {
                return -1;
            }
            return renderer->UpdateTextureYUV(renderer, texture, rect, Yplane, Ypitch, Uplane, Upitch, Vplane, Vpitch);
        } else {
            return SDL_Unsupported();
        }
    }
#else
    return -1;
#endif
}

References CHECK_TEXTURE_MAGIC, FlushRenderCommandsIfTextureNeeded(), SDL_Rect::h, rect, renderer, SDL_assert, SDL_InvalidParamError, SDL_PIXELFORMAT_IYUV, SDL_PIXELFORMAT_YV12, SDL_SetError, SDL_Unsupported, SDL_UpdateTextureYUVPlanar(), SDL_Renderer::UpdateTextureYUV, SDL_Rect::w, SDL_Rect::x, and SDL_Rect::y.

UpdateLogicalSize()

static int UpdateLogicalSize ( SDL_Renderer *  renderer )

static

Definition at line 1962 of file SDL_render.c.

{
    int w = 1, h = 1;
    float want_aspect;
    float real_aspect;
    float scale;
    SDL_Rect viewport;
    /* 0 is for letterbox, 1 is for overscan */
    int scale_policy = 0;
    const char *hint;
 
    if (!renderer->logical_w || !renderer->logical_h) {
        return 0;
    }
    if (SDL_GetRendererOutputSize(renderer, &w, &h) < 0) {
        return -1;
    }
 
    hint = SDL_GetHint(SDL_HINT_RENDER_LOGICAL_SIZE_MODE);
    if (hint && (*hint == '1' || SDL_strcasecmp(hint, "overscan") == 0))  {
#if SDL_VIDEO_RENDER_D3D
        SDL_bool overscan_supported = SDL_TRUE;
        /* Unfortunately, Direct3D 9 doesn't support negative viewport numbers
           which the overscan implementation relies on.
        */
        if (SDL_strcasecmp(SDL_GetCurrentVideoDriver(), "direct3d") == 0) {
            overscan_supported = SDL_FALSE;
        }
        if (overscan_supported) {
            scale_policy = 1;
        }
#else
        scale_policy = 1;
#endif
    }
 
    want_aspect = (float)renderer->logical_w / renderer->logical_h;
    real_aspect = (float)w / h;
 
    /* Clear the scale because we're setting viewport in output coordinates */
    SDL_RenderSetScale(renderer, 1.0f, 1.0f);
 
    if (renderer->integer_scale) {
        if (want_aspect > real_aspect) {
            scale = (float)(w / renderer->logical_w);
        } else {
            scale = (float)(h / renderer->logical_h);
        }
        viewport.w = (int)SDL_ceil(renderer->logical_w * scale);
        viewport.x = (w - viewport.w) / 2;
        viewport.h = (int)SDL_ceil(renderer->logical_h * scale);
        viewport.y = (h - viewport.h) / 2;
 
        SDL_RenderSetViewport(renderer, &viewport);
    } else if (SDL_fabs(want_aspect-real_aspect) < 0.0001) {
        /* The aspect ratios are the same, just scale appropriately */
        scale = (float)w / renderer->logical_w;
        SDL_RenderSetViewport(renderer, NULL);
    } else if (want_aspect > real_aspect) {
        if (scale_policy == 1) {
            /* We want a wider aspect ratio than is available - 
             zoom so logical height matches the real height 
             and the width will grow off the screen 
             */
            scale = (float)h / renderer->logical_h;
            viewport.y = 0;
            viewport.h = h;
            viewport.w = (int)SDL_ceil(renderer->logical_w * scale);
            viewport.x = (w - viewport.w) / 2;
            SDL_RenderSetViewport(renderer, &viewport);
        } else {
            /* We want a wider aspect ratio than is available - letterbox it */
            scale = (float)w / renderer->logical_w;
            viewport.x = 0;
            viewport.w = w;
            viewport.h = (int)SDL_ceil(renderer->logical_h * scale);
            viewport.y = (h - viewport.h) / 2;
            SDL_RenderSetViewport(renderer, &viewport);
        }
    } else {
        if (scale_policy == 1) {
            /* We want a narrower aspect ratio than is available -
             zoom so logical width matches the real width
             and the height will grow off the screen
             */
            scale = (float)w / renderer->logical_w;
            viewport.x = 0;
            viewport.w = w;
            viewport.h = (int)SDL_ceil(renderer->logical_h * scale);
            viewport.y = (h - viewport.h) / 2;
            SDL_RenderSetViewport(renderer, &viewport);
        } else {
            /* We want a narrower aspect ratio than is available - use side-bars */
             scale = (float)h / renderer->logical_h;
             viewport.y = 0;
             viewport.h = h;
             viewport.w = (int)SDL_ceil(renderer->logical_w * scale);
             viewport.x = (w - viewport.w) / 2;
             SDL_RenderSetViewport(renderer, &viewport);
        }
    }
 
    /* Set the new scale */
    SDL_RenderSetScale(renderer, scale, scale);
 
    return 0;
}

References SDL_Rect::h, int(), SDL_Renderer::integer_scale, SDL_Renderer::logical_h, SDL_Renderer::logical_w, NULL, renderer, SDL_ceil, SDL_fabs, SDL_FALSE, SDL_GetCurrentVideoDriver, SDL_GetHint, SDL_GetRendererOutputSize(), SDL_HINT_RENDER_LOGICAL_SIZE_MODE, SDL_RenderSetScale(), SDL_RenderSetViewport(), SDL_strcasecmp, SDL_TRUE, viewport, SDL_Rect::w, SDL_Rect::x, and SDL_Rect::y.

Referenced by SDL_RendererEventWatch(), SDL_RenderSetIntegerScale(), and SDL_RenderSetLogicalSize().

VerifyDrawQueueFunctions()

static SDL_INLINE void VerifyDrawQueueFunctions ( const SDL_Renderer *  renderer )

static

Definition at line 772 of file SDL_render.c.

{
    /* all of these functions are required to be implemented, even as no-ops, so we don't
        have to check that they aren't NULL over and over. */
    SDL_assert(renderer->QueueSetViewport != NULL);
    SDL_assert(renderer->QueueSetDrawColor != NULL);
    SDL_assert(renderer->QueueDrawPoints != NULL);
    SDL_assert(renderer->QueueDrawLines != NULL);
    SDL_assert(renderer->QueueFillRects != NULL);
    SDL_assert(renderer->QueueCopy != NULL);
    SDL_assert(renderer->RunCommandQueue != NULL);
}

References NULL, SDL_Renderer::QueueCopy, SDL_Renderer::QueueDrawLines, SDL_Renderer::QueueDrawPoints, SDL_Renderer::QueueFillRects, SDL_Renderer::QueueSetDrawColor, SDL_Renderer::QueueSetViewport, renderer, SDL_Renderer::RunCommandQueue, and SDL_assert.

Referenced by SDL_CreateRenderer(), and SDL_CreateSoftwareRenderer().

Variable Documentation

render_drivers

const SDL_RenderDriver* render_drivers[]

static

Initial value:

= {
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
    &SW_RenderDriver
 
}

Definition at line 82 of file SDL_render.c.

Referenced by SDL_CreateRenderer(), SDL_GetNumRenderDrivers(), and SDL_GetRenderDriverInfo().

renderer_magic

char renderer_magic

static

Definition at line 113 of file SDL_render.c.

Referenced by SDL_CreateRenderer(), and SDL_CreateSoftwareRenderer().

texture_magic

char texture_magic

static

Definition at line 114 of file SDL_render.c.

Referenced by SDL_CreateTexture().