SDL 2.0
SDL_render.c File Reference
#include "../SDL_internal.h"
#include "SDL_assert.h"
#include "SDL_hints.h"
#include "SDL_log.h"
#include "SDL_render.h"
#include "SDL_sysrender.h"
#include "software/SDL_render_sw_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
 

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...
 
static SDL_AllocVertGapAllocateVertexGap (SDL_Renderer *renderer)
 
voidSDL_AllocateRenderVertices (SDL_Renderer *renderer, const size_t numbytes, const size_t alignment, size_t *offset)
 
static SDL_RenderCommandAllocateRenderCommand (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_RenderCommandPrepQueueCmdDrawSolid (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_RenderCommandPrepQueueCmdDrawTexture (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_RendererSDL_CreateRenderer (SDL_Window *window, int index, Uint32 flags)
 Create a 2D rendering context for a window. More...
 
SDL_RendererSDL_CreateSoftwareRenderer (SDL_Surface *surface)
 Create a 2D software rendering context for a surface. More...
 
SDL_RendererSDL_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_TextureSDL_CreateTexture (SDL_Renderer *renderer, Uint32 format, int access, int w, int h)
 Create a texture for a rendering context. More...
 
SDL_TextureSDL_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...
 
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...
 
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. 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_TextureSDL_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...
 
voidSDL_RenderGetMetalLayer (SDL_Renderer *renderer)
 Get the CAMetalLayer associated with the given Metal renderer. More...
 
voidSDL_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_RenderDriverrender_drivers []
 
static char renderer_magic
 
static char texture_magic
 

Macro Definition Documentation

◆ CHECK_RENDERER_MAGIC

#define CHECK_RENDERER_MAGIC (   renderer,
  retval 
)
Value:
SDL_SetError("Invalid renderer"); \
return retval; \
}
#define SDL_assert(condition)
Definition: SDL_assert.h:169
static char renderer_magic
Definition: SDL_render.c:108
const void * magic
static SDL_Renderer * renderer
SDL_bool retval

Definition at line 38 of file SDL_render.c.

◆ CHECK_TEXTURE_MAGIC

#define CHECK_TEXTURE_MAGIC (   texture,
  retval 
)
Value:
if (!texture || texture->magic != &texture_magic) { \
SDL_SetError("Invalid texture"); \
return retval; \
}
GLenum GLenum GLuint texture
static char texture_magic
Definition: SDL_render.c:109

Definition at line 45 of file SDL_render.c.

◆ SDL_BLENDMODE_ADD_FULL

#define SDL_BLENDMODE_ADD_FULL
Value:
@ SDL_BLENDOPERATION_ADD
Definition: SDL_blendmode.h:64
@ SDL_BLENDFACTOR_ZERO
Definition: SDL_blendmode.h:77
@ SDL_BLENDFACTOR_SRC_ALPHA
Definition: SDL_blendmode.h:81
@ SDL_BLENDFACTOR_ONE
Definition: SDL_blendmode.h:78
#define SDL_COMPOSE_BLENDMODE(srcColorFactor, dstColorFactor, colorOperation, srcAlphaFactor, dstAlphaFactor, alphaOperation)
Definition: SDL_render.c:53

Definition at line 70 of file SDL_render.c.

◆ SDL_BLENDMODE_BLEND_FULL

◆ SDL_BLENDMODE_MOD_FULL

◆ SDL_BLENDMODE_NONE_FULL

◆ 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))
SDL_BlendMode
The blend mode used in SDL_RenderCopy() and drawing operations.
Definition: SDL_blendmode.h:41
uint32_t Uint32
Definition: SDL_stdinc.h:203

Definition at line 53 of file SDL_render.c.

◆ SDL_WINDOWRENDERDATA

#define SDL_WINDOWRENDERDATA   "_SDL_WindowRenderData"

Definition at line 36 of file SDL_render.c.

Function Documentation

◆ AllocateRenderCommand()

static SDL_RenderCommand * AllocateRenderCommand ( SDL_Renderer renderer)
static

Definition at line 371 of file SDL_render.c.

372{
374
375 /* !!! FIXME: are there threading limitations in SDL's render API? If not, we need to mutex this. */
377 if (retval != NULL) {
379 retval->next = NULL;
380 } else {
381 retval = SDL_calloc(1, sizeof (*retval));
382 if (!retval) {
384 return NULL;
385 }
386 }
387
391 } else {
393 }
395
396 return retval;
397}
#define SDL_calloc
#define SDL_OutOfMemory()
Definition: SDL_error.h:52
#define NULL
Definition: begin_code.h:167
struct SDL_RenderCommand * next
SDL_RenderCommand * render_commands
SDL_RenderCommand * render_commands_tail
SDL_RenderCommand * render_commands_pool

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().

◆ AllocateVertexGap()

static SDL_AllocVertGap * AllocateVertexGap ( SDL_Renderer renderer)
static

Definition at line 267 of file SDL_render.c.

268{
270 if (retval) {
272 retval->next = NULL;
273 } else {
275 if (!retval) {
277 }
278 }
279 return retval;
280}
#define SDL_malloc
SDL_AllocVertGap * vertex_data_gaps_pool

References NULL, renderer, retval, SDL_malloc, SDL_OutOfMemory, and SDL_Renderer::vertex_data_gaps_pool.

Referenced by SDL_AllocateRenderVertices().

◆ DebugLogRenderCommands()

static SDL_INLINE void DebugLogRenderCommands ( const SDL_RenderCommand cmd)
static

Definition at line 112 of file SDL_render.c.

113{
114#if 0
115 unsigned int i = 1;
116 SDL_Log("Render commands to flush:");
117 while (cmd) {
118 switch (cmd->command) {
120 SDL_Log(" %u. no-op", i++);
121 break;
122
124 SDL_Log(" %u. set viewport (first=%u, rect={(%d, %d), %dx%d})", i++,
125 (unsigned int) cmd->data.viewport.first,
126 cmd->data.viewport.rect.x, cmd->data.viewport.rect.y,
127 cmd->data.viewport.rect.w, cmd->data.viewport.rect.h);
128 break;
129
131 SDL_Log(" %u. set cliprect (enabled=%s, rect={(%d, %d), %dx%d})", i++,
132 cmd->data.cliprect.enabled ? "true" : "false",
133 cmd->data.cliprect.rect.x, cmd->data.cliprect.rect.y,
134 cmd->data.cliprect.rect.w, cmd->data.cliprect.rect.h);
135 break;
136
138 SDL_Log(" %u. set draw color (first=%u, r=%d, g=%d, b=%d, a=%d)", i++,
139 (unsigned int) cmd->data.color.first,
140 (int) cmd->data.color.r, (int) cmd->data.color.g,
141 (int) cmd->data.color.b, (int) cmd->data.color.a);
142 break;
143
145 SDL_Log(" %u. clear (first=%u, r=%d, g=%d, b=%d, a=%d)", i++,
146 (unsigned int) cmd->data.color.first,
147 (int) cmd->data.color.r, (int) cmd->data.color.g,
148 (int) cmd->data.color.b, (int) cmd->data.color.a);
149 break;
150
152 SDL_Log(" %u. draw points (first=%u, count=%u, r=%d, g=%d, b=%d, a=%d, blend=%d)", i++,
153 (unsigned int) cmd->data.draw.first,
154 (unsigned int) cmd->data.draw.count,
155 (int) cmd->data.draw.r, (int) cmd->data.draw.g,
156 (int) cmd->data.draw.b, (int) cmd->data.draw.a,
157 (int) cmd->data.draw.blend);
158 break;
159
161 SDL_Log(" %u. draw lines (first=%u, count=%u, r=%d, g=%d, b=%d, a=%d, blend=%d)", i++,
162 (unsigned int) cmd->data.draw.first,
163 (unsigned int) cmd->data.draw.count,
164 (int) cmd->data.draw.r, (int) cmd->data.draw.g,
165 (int) cmd->data.draw.b, (int) cmd->data.draw.a,
166 (int) cmd->data.draw.blend);
167 break;
168
170 SDL_Log(" %u. fill rects (first=%u, count=%u, r=%d, g=%d, b=%d, a=%d, blend=%d)", i++,
171 (unsigned int) cmd->data.draw.first,
172 (unsigned int) cmd->data.draw.count,
173 (int) cmd->data.draw.r, (int) cmd->data.draw.g,
174 (int) cmd->data.draw.b, (int) cmd->data.draw.a,
175 (int) cmd->data.draw.blend);
176 break;
177
179 SDL_Log(" %u. copy (first=%u, count=%u, r=%d, g=%d, b=%d, a=%d, blend=%d, tex=%p)", i++,
180 (unsigned int) cmd->data.draw.first,
181 (unsigned int) cmd->data.draw.count,
182 (int) cmd->data.draw.r, (int) cmd->data.draw.g,
183 (int) cmd->data.draw.b, (int) cmd->data.draw.a,
184 (int) cmd->data.draw.blend, cmd->data.draw.texture);
185 break;
186
187
189 SDL_Log(" %u. copyex (first=%u, count=%u, r=%d, g=%d, b=%d, a=%d, blend=%d, tex=%p)", i++,
190 (unsigned int) cmd->data.draw.first,
191 (unsigned int) cmd->data.draw.count,
192 (int) cmd->data.draw.r, (int) cmd->data.draw.g,
193 (int) cmd->data.draw.b, (int) cmd->data.draw.a,
194 (int) cmd->data.draw.blend, cmd->data.draw.texture);
195 break;
196 }
197 cmd = cmd->next;
198 }
199#endif
200}
#define SDL_Log
@ SDL_RENDERCMD_SETCLIPRECT
Definition: SDL_sysrender.h:76
@ SDL_RENDERCMD_DRAW_LINES
Definition: SDL_sysrender.h:80
@ SDL_RENDERCMD_SETVIEWPORT
Definition: SDL_sysrender.h:75
@ SDL_RENDERCMD_DRAW_POINTS
Definition: SDL_sysrender.h:79
@ SDL_RENDERCMD_NO_OP
Definition: SDL_sysrender.h:74
@ SDL_RENDERCMD_FILL_RECTS
Definition: SDL_sysrender.h:81
@ SDL_RENDERCMD_COPY
Definition: SDL_sysrender.h:82
@ SDL_RENDERCMD_CLEAR
Definition: SDL_sysrender.h:78
@ SDL_RENDERCMD_SETDRAWCOLOR
Definition: SDL_sysrender.h:77
@ SDL_RENDERCMD_COPY_EX
Definition: SDL_sysrender.h:83
return Display return Display Bool Bool int int int return Display XEvent Bool(*) XPointer return Display return Display Drawable _Xconst char unsigned int unsigned int return Display Pixmap Pixmap XColor XColor unsigned int unsigned int return Display _Xconst char char int char return Display Visual unsigned int int int char unsigned int unsigned int in i)
Definition: SDL_x11sym.h:50
int h
Definition: SDL_rect.h:80
int w
Definition: SDL_rect.h:80
int y
Definition: SDL_rect.h:79
int x
Definition: SDL_rect.h:79
union SDL_RenderCommand::@30 data
struct SDL_RenderCommand::@30::@33 draw
struct SDL_RenderCommand::@30::@31 viewport
SDL_BlendMode blend
SDL_RenderCommandType command
Definition: SDL_sysrender.h:88
struct SDL_RenderCommand::@30::@32 cliprect
SDL_Texture * texture
struct SDL_RenderCommand::@30::@34 color

References SDL_RenderCommand::a, SDL_RenderCommand::b, SDL_RenderCommand::blend, SDL_RenderCommand::cliprect, SDL_RenderCommand::color, SDL_RenderCommand::command, SDL_RenderCommand::count, SDL_RenderCommand::data, SDL_RenderCommand::draw, SDL_RenderCommand::enabled, SDL_RenderCommand::first, SDL_RenderCommand::g, SDL_Rect::h, i, SDL_RenderCommand::next, SDL_RenderCommand::r, SDL_RenderCommand::rect, 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, SDL_RenderCommand::texture, SDL_RenderCommand::viewport, SDL_Rect::w, SDL_Rect::x, and SDL_Rect::y.

Referenced by FlushRenderCommands().

◆ FlushRenderCommands()

static int FlushRenderCommands ( SDL_Renderer renderer)
static

Definition at line 203 of file SDL_render.c.

204{
206 SDL_AllocVertGap *gap = prevgap;
207 int retval;
208
210
211 if (renderer->render_commands == NULL) { /* nothing to do! */
213 return 0;
214 }
215
217
219
220 while (gap) {
221 prevgap = gap;
222 gap = gap->next;
223 }
227
228 /* Move the whole render command queue to the unused pool so we can reuse them next time. */
234 }
240 return retval;
241}
static SDL_INLINE void DebugLogRenderCommands(const SDL_RenderCommand *cmd)
Definition: SDL_render.c:112
@ SDL_FALSE
Definition: SDL_stdinc.h:163
struct SDL_AllocVertGap * next
SDL_AllocVertGap vertex_data_gaps
SDL_bool cliprect_queued
void * vertex_data
SDL_bool color_queued
int(* RunCommandQueue)(SDL_Renderer *renderer, SDL_RenderCommand *cmd, void *vertices, size_t vertsize)
SDL_bool viewport_queued
Uint32 render_command_generation
size_t vertex_data_used

References SDL_Renderer::cliprect_queued, SDL_Renderer::color_queued, DebugLogRenderCommands(), SDL_RenderCommand::next, SDL_AllocVertGap::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_gaps, SDL_Renderer::vertex_data_gaps_pool, 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()

◆ FlushRenderCommandsIfTextureNeeded()

static int FlushRenderCommandsIfTextureNeeded ( SDL_Texture texture)
static

Definition at line 244 of file SDL_render.c.

245{
246 SDL_Renderer *renderer = texture->renderer;
247 if (texture->last_command_generation == renderer->render_command_generation) {
248 /* the current command queue depends on this texture, flush the queue now before it changes */
250 }
251 return 0;
252}

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 1070 of file SDL_render.c.

1071{
1072 Uint32 i;
1073
1075 /* Look for an exact match */
1076 for (i = 0; i < renderer->info.num_texture_formats; ++i) {
1078 return renderer->info.texture_formats[i];
1079 }
1080 }
1081 } else {
1083
1084 /* We just want to match the first format that has the same channels */
1085 for (i = 0; i < renderer->info.num_texture_formats; ++i) {
1088 return renderer->info.texture_formats[i];
1089 }
1090 }
1091 }
1092 return renderer->info.texture_formats[0];
1093}
GLint GLint GLsizei GLsizei GLsizei GLint GLenum format
Definition: SDL_opengl.h:1572
#define SDL_ISPIXELFORMAT_ALPHA(format)
Definition: SDL_pixels.h:154
#define SDL_ISPIXELFORMAT_FOURCC(format)
Definition: SDL_pixels.h:167
SDL_bool
Definition: SDL_stdinc.h:162
SDL_RendererInfo info
Uint32 texture_formats[16]
Definition: SDL_render.h:83
Uint32 num_texture_formats
Definition: SDL_render.h:82

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 651 of file SDL_render.c.

652{
659}
#define SDL_LockMutex
#define SDL_UnlockMutex
GLenum GLenum GLenum GLenum GLenum scale
SDL_mutex * target_mutex
SDL_FPoint scale
SDL_Rect viewport
SDL_FPoint scale_backup
SDL_Texture * target
SDL_Rect viewport_backup
SDL_Rect viewport
Definition: testviewport.c:28

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 1040 of file SDL_render.c.

1041{
1042 switch (blendMode)
1043 {
1044 /* These are required to be supported by all renderers */
1045 case SDL_BLENDMODE_NONE:
1047 case SDL_BLENDMODE_ADD:
1048 case SDL_BLENDMODE_MOD:
1049 return SDL_TRUE;
1050
1051 default:
1053 }
1054}
@ SDL_BLENDMODE_NONE
Definition: SDL_blendmode.h:42
@ SDL_BLENDMODE_ADD
Definition: SDL_blendmode.h:47
@ SDL_BLENDMODE_BLEND
Definition: SDL_blendmode.h:44
@ SDL_BLENDMODE_MOD
Definition: SDL_blendmode.h:50
@ SDL_TRUE
Definition: SDL_stdinc.h:164
SDL_bool(* SupportsBlendMode)(SDL_Renderer *renderer, SDL_BlendMode blendMode)
static SDL_BlendMode blendMode
Definition: testdraw2.c:34

References blendMode, renderer, SDL_BLENDMODE_ADD, SDL_BLENDMODE_BLEND, SDL_BLENDMODE_MOD, 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 1057 of file SDL_render.c.

1058{
1059 Uint32 i;
1060
1061 for (i = 0; i < renderer->info.num_texture_formats; ++i) {
1063 return SDL_TRUE;
1064 }
1065 }
1066 return SDL_FALSE;
1067}

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 491 of file SDL_render.c.

492{
493 int retval = 0;
494 if (retval == 0) {
496 }
497 if (retval == 0) {
499 }
500 if (retval == 0) {
502 }
503 return retval;
504}
GLdouble GLdouble GLdouble r
Definition: SDL_opengl.h:2079
GLboolean GLboolean GLboolean b
GLboolean GLboolean GLboolean GLboolean a
GLboolean GLboolean g
static int QueueCmdSetDrawColor(SDL_Renderer *renderer, const Uint8 r, const Uint8 g, const Uint8 b, const Uint8 a)
Definition: SDL_render.c:445
static int QueueCmdSetViewport(SDL_Renderer *renderer)
Definition: SDL_render.c:400
static int QueueCmdSetClipRect(SDL_Renderer *renderer)
Definition: SDL_render.c:423

References QueueCmdSetClipRect(), QueueCmdSetDrawColor(), QueueCmdSetViewport(), renderer, and retval.

Referenced by PrepQueueCmdDrawSolid(), and PrepQueueCmdDrawTexture().

◆ PrepQueueCmdDrawSolid()

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

Definition at line 507 of file SDL_render.c.

508{
509 /* !!! FIXME: drop this draw if viewport w or h is zero. */
510 SDL_RenderCommand *cmd = NULL;
513 if (cmd != NULL) {
514 cmd->command = cmdtype;
515 cmd->data.draw.first = 0; /* render backend will fill this in. */
516 cmd->data.draw.count = 0; /* render backend will fill this in. */
517 cmd->data.draw.r = renderer->r;
518 cmd->data.draw.g = renderer->g;
519 cmd->data.draw.b = renderer->b;
520 cmd->data.draw.a = renderer->a;
522 cmd->data.draw.texture = NULL; /* no texture. */
523 }
524 }
525 return cmd;
526}
static int PrepQueueCmdDraw(SDL_Renderer *renderer, const Uint8 r, const Uint8 g, const Uint8 b, const Uint8 a)
Definition: SDL_render.c:491
static SDL_RenderCommand * AllocateRenderCommand(SDL_Renderer *renderer)
Definition: SDL_render.c:371
SDL_BlendMode blendMode

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

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 571 of file SDL_render.c.

572{
573 /* !!! FIXME: drop this draw if viewport w or h is zero. */
574 SDL_RenderCommand *cmd = NULL;
575 if (PrepQueueCmdDraw(renderer, texture->r, texture->g, texture->b, texture->a) == 0) {
577 if (cmd != NULL) {
578 cmd->command = cmdtype;
579 cmd->data.draw.first = 0; /* render backend will fill this in. */
580 cmd->data.draw.count = 0; /* render backend will fill this in. */
581 cmd->data.draw.r = texture->r;
582 cmd->data.draw.g = texture->g;
583 cmd->data.draw.b = texture->b;
584 cmd->data.draw.a = texture->a;
585 cmd->data.draw.blend = texture->blendMode;
586 cmd->data.draw.texture = texture;
587 }
588 }
589 return cmd;
590}

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

Referenced by QueueCmdCopy(), and QueueCmdCopyEx().

◆ QueueCmdClear()

◆ QueueCmdCopy()

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

Definition at line 593 of file SDL_render.c.

594{
596 int retval = -1;
597 if (cmd != NULL) {
598 retval = renderer->QueueCopy(renderer, cmd, texture, srcrect, dstrect);
599 if (retval < 0) {
601 }
602 }
603 return retval;
604}
static SDL_RenderCommand * PrepQueueCmdDrawTexture(SDL_Renderer *renderer, SDL_Texture *texture, const SDL_RenderCommandType cmdtype)
Definition: SDL_render.c:571
int(* QueueCopy)(SDL_Renderer *renderer, SDL_RenderCommand *cmd, SDL_Texture *texture, const SDL_Rect *srcrect, const SDL_FRect *dstrect)

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 607 of file SDL_render.c.

610{
612 int retval = -1;
613 SDL_assert(renderer->QueueCopyEx != NULL); /* should have caught at higher level. */
614 if (cmd != NULL) {
615 retval = renderer->QueueCopyEx(renderer, cmd, texture, srcquad, dstrect, angle, center, flip);
616 if (retval < 0) {
618 }
619 }
620 return retval;
621}
GLfloat angle
int(* QueueCopyEx)(SDL_Renderer *renderer, SDL_RenderCommand *cmd, SDL_Texture *texture, const SDL_Rect *srcquad, const SDL_FRect *dstrect, const double angle, const SDL_FPoint *center, const SDL_RendererFlip flip)

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 543 of file SDL_render.c.

544{
546 int retval = -1;
547 if (cmd != NULL) {
549 if (retval < 0) {
551 }
552 }
553 return retval;
554}
GLuint GLuint GLsizei count
Definition: SDL_opengl.h:1571
GLfixed GLfixed GLint GLint GLfixed points
static SDL_RenderCommand * PrepQueueCmdDrawSolid(SDL_Renderer *renderer, const SDL_RenderCommandType cmdtype)
Definition: SDL_render.c:507
int(* QueueDrawLines)(SDL_Renderer *renderer, SDL_RenderCommand *cmd, const SDL_FPoint *points, int count)

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 529 of file SDL_render.c.

530{
532 int retval = -1;
533 if (cmd != NULL) {
535 if (retval < 0) {
537 }
538 }
539 return retval;
540}
int(* QueueDrawPoints)(SDL_Renderer *renderer, SDL_RenderCommand *cmd, const SDL_FPoint *points, int count)

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 557 of file SDL_render.c.

558{
560 int retval = -1;
561 if (cmd != NULL) {
563 if (retval < 0) {
565 }
566 }
567 return retval;
568}
EGLSurface EGLint * rects
Definition: eglext.h:282
int(* QueueFillRects)(SDL_Renderer *renderer, SDL_RenderCommand *cmd, const SDL_FRect *rects, int count)

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 423 of file SDL_render.c.

424{
425 int retval = 0;
426 if ((!renderer->cliprect_queued) ||
430 if (cmd == NULL) {
431 retval = -1;
432 } else {
439 }
440 }
441 return retval;
442}
#define SDL_memcmp
#define SDL_memcpy
A rectangle, with the origin at the upper left (integer).
Definition: SDL_rect.h:78
SDL_bool clipping_enabled
SDL_Rect clip_rect
SDL_Rect last_queued_cliprect
SDL_bool last_queued_cliprect_enabled

References AllocateRenderCommand(), SDL_Renderer::clip_rect, SDL_Renderer::clipping_enabled, SDL_RenderCommand::cliprect, SDL_Renderer::cliprect_queued, SDL_RenderCommand::command, SDL_RenderCommand::data, SDL_RenderCommand::enabled, SDL_Renderer::last_queued_cliprect, SDL_Renderer::last_queued_cliprect_enabled, NULL, SDL_RenderCommand::rect, 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 445 of file SDL_render.c.

446{
447 const Uint32 color = ((a << 24) | (r << 16) | (g << 8) | b);
448 int retval = 0;
449
452 retval = -1;
453
454 if (cmd != NULL) {
456 cmd->data.color.first = 0; /* render backend will fill this in. */
457 cmd->data.color.r = r;
458 cmd->data.color.g = g;
459 cmd->data.color.b = b;
460 cmd->data.color.a = a;
462 if (retval < 0) {
464 } else {
467 }
468 }
469 }
470 return retval;
471}
GLuint color
Uint32 last_queued_color
int(* QueueSetDrawColor)(SDL_Renderer *renderer, SDL_RenderCommand *cmd)

References SDL_RenderCommand::a, AllocateRenderCommand(), SDL_RenderCommand::b, SDL_RenderCommand::color, SDL_Renderer::color_queued, SDL_RenderCommand::command, SDL_RenderCommand::data, SDL_RenderCommand::first, SDL_RenderCommand::g, SDL_Renderer::last_queued_color, NULL, SDL_Renderer::QueueSetDrawColor, SDL_RenderCommand::r, 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 400 of file SDL_render.c.

401{
402 int retval = 0;
405 retval = -1;
406 if (cmd != NULL) {
408 cmd->data.viewport.first = 0; /* render backend will fill this in. */
411 if (retval < 0) {
413 } else {
416 }
417 }
418 }
419 return retval;
420}
SDL_Rect last_queued_viewport
int(* QueueSetViewport)(SDL_Renderer *renderer, SDL_RenderCommand *cmd)

References AllocateRenderCommand(), SDL_RenderCommand::command, SDL_RenderCommand::data, SDL_RenderCommand::first, SDL_Renderer::last_queued_viewport, NULL, SDL_Renderer::QueueSetViewport, SDL_RenderCommand::rect, 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 2425 of file SDL_render.c.

2427{
2428 SDL_FRect *frect;
2429 SDL_FRect *frects;
2430 SDL_FPoint fpoints[2];
2431 int i, nrects = 0;
2432 int retval = 0;
2433 SDL_bool isstack;
2434
2435 frects = SDL_small_alloc(SDL_FRect, count-1, &isstack);
2436 if (!frects) {
2437 return SDL_OutOfMemory();
2438 }
2439
2440 for (i = 0; i < count-1; ++i) {
2441 if (points[i].x == points[i+1].x) {
2442 const int minY = SDL_min(points[i].y, points[i+1].y);
2443 const int maxY = SDL_max(points[i].y, points[i+1].y);
2444
2445 frect = &frects[nrects++];
2446 frect->x = points[i].x * renderer->scale.x;
2447 frect->y = minY * renderer->scale.y;
2448 frect->w = renderer->scale.x;
2449 frect->h = (maxY - minY + 1) * renderer->scale.y;
2450 } else if (points[i].y == points[i+1].y) {
2451 const int minX = SDL_min(points[i].x, points[i+1].x);
2452 const int maxX = SDL_max(points[i].x, points[i+1].x);
2453
2454 frect = &frects[nrects++];
2455 frect->x = minX * renderer->scale.x;
2456 frect->y = points[i].y * renderer->scale.y;
2457 frect->w = (maxX - minX + 1) * renderer->scale.x;
2458 frect->h = renderer->scale.y;
2459 } else {
2460 /* FIXME: We can't use a rect for this line... */
2461 fpoints[0].x = points[i].x * renderer->scale.x;
2462 fpoints[0].y = points[i].y * renderer->scale.y;
2463 fpoints[1].x = points[i+1].x * renderer->scale.x;
2464 fpoints[1].y = points[i+1].y * renderer->scale.y;
2465 retval += QueueCmdDrawLines(renderer, fpoints, 2);
2466 }
2467 }
2468
2469 retval += QueueCmdFillRects(renderer, frects, nrects);
2470
2471 SDL_small_free(frects, isstack);
2472
2473 if (retval < 0) {
2474 retval = -1;
2475 }
2477}
#define SDL_small_alloc(type, count, pisstack)
Definition: SDL_internal.h:39
#define SDL_small_free(ptr, isstack)
Definition: SDL_internal.h:40
GLint GLint GLint GLint GLint GLint y
Definition: SDL_opengl.h:1574
GLint GLint GLint GLint GLint x
Definition: SDL_opengl.h:1574
static SDL_INLINE int FlushRenderCommandsIfNotBatching(SDL_Renderer *renderer)
Definition: SDL_render.c:255
static int QueueCmdDrawLines(SDL_Renderer *renderer, const SDL_FPoint *points, const int count)
Definition: SDL_render.c:543
static int QueueCmdFillRects(SDL_Renderer *renderer, const SDL_FRect *rects, const int count)
Definition: SDL_render.c:557
#define SDL_min(x, y)
Definition: SDL_stdinc.h:406
#define SDL_max(x, y)
Definition: SDL_stdinc.h:407
GLfloat GLfloat GLfloat GLfloat GLfloat maxY
Definition: gl2ext.h:446
GLfloat minY
Definition: gl2ext.h:446
GLfloat GLfloat GLfloat GLfloat maxX
Definition: gl2ext.h:446
The structure that defines a point (floating point)
Definition: SDL_rect.h:61
float x
Definition: SDL_rect.h:62
float y
Definition: SDL_rect.h:63
A rectangle, with the origin at the upper left (floating point).
Definition: SDL_rect.h:88
float h
Definition: SDL_rect.h:92
float x
Definition: SDL_rect.h:89
float w
Definition: SDL_rect.h:91
float y
Definition: SDL_rect.h:90

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 2480 of file SDL_render.c.

2482{
2483 SDL_FRect *frect;
2484 SDL_FRect *frects;
2485 SDL_FPoint fpoints[2];
2486 int i, nrects = 0;
2487 int retval = 0;
2488 SDL_bool isstack;
2489
2490 frects = SDL_small_alloc(SDL_FRect, count-1, &isstack);
2491 if (!frects) {
2492 return SDL_OutOfMemory();
2493 }
2494
2495 for (i = 0; i < count-1; ++i) {
2496 if (points[i].x == points[i+1].x) {
2497 const int minY = (int)SDL_min(points[i].y, points[i+1].y);
2498 const int maxY = (int)SDL_max(points[i].y, points[i+1].y);
2499
2500 frect = &frects[nrects++];
2501 frect->x = points[i].x * renderer->scale.x;
2502 frect->y = minY * renderer->scale.y;
2503 frect->w = renderer->scale.x;
2504 frect->h = (maxY - minY + 1) * renderer->scale.y;
2505 } else if (points[i].y == points[i+1].y) {
2506 const int minX = (int)SDL_min(points[i].x, points[i+1].x);
2507 const int maxX = (int)SDL_max(points[i].x, points[i+1].x);
2508
2509 frect = &frects[nrects++];
2510 frect->x = minX * renderer->scale.x;
2511 frect->y = points[i].y * renderer->scale.y;
2512 frect->w = (maxX - minX + 1) * renderer->scale.x;
2513 frect->h = renderer->scale.y;
2514 } else {
2515 /* FIXME: We can't use a rect for this line... */
2516 fpoints[0].x = points[i].x * renderer->scale.x;
2517 fpoints[0].y = points[i].y * renderer->scale.y;
2518 fpoints[1].x = points[i+1].x * renderer->scale.x;
2519 fpoints[1].y = points[i+1].y * renderer->scale.y;
2520 retval += QueueCmdDrawLines(renderer, fpoints, 2);
2521 }
2522 }
2523
2524 retval += QueueCmdFillRects(renderer, frects, nrects);
2525
2526 SDL_small_free(frects, isstack);
2527
2528 if (retval < 0) {
2529 retval = -1;
2530 }
2532}

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_RenderDrawLinesF().

◆ RenderDrawPointsWithRects()

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

Definition at line 2263 of file SDL_render.c.

2265{
2266 int retval = -1;
2267 SDL_bool isstack;
2268 SDL_FRect *frects = SDL_small_alloc(SDL_FRect, count, &isstack);
2269 int i;
2270
2271 if (!frects) {
2272 return SDL_OutOfMemory();
2273 }
2274
2275 for (i = 0; i < count; ++i) {
2276 frects[i].x = points[i].x * renderer->scale.x;
2277 frects[i].y = points[i].y * renderer->scale.y;
2278 frects[i].w = renderer->scale.x;
2279 frects[i].h = renderer->scale.y;
2280 }
2281
2283
2284 SDL_small_free(frects, isstack);
2285
2287}

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 2333 of file SDL_render.c.

2335{
2336 int retval = -1;
2337 SDL_bool isstack;
2338 SDL_FRect *frects = SDL_small_alloc(SDL_FRect, count, &isstack);
2339 int i;
2340
2341 if (!frects) {
2342 return SDL_OutOfMemory();
2343 }
2344
2345 for (i = 0; i < count; ++i) {
2346 frects[i].x = fpoints[i].x * renderer->scale.x;
2347 frects[i].y = fpoints[i].y * renderer->scale.y;
2348 frects[i].w = renderer->scale.x;
2349 frects[i].h = renderer->scale.y;
2350 }
2351
2353
2354 SDL_small_free(frects, isstack);
2355
2357}

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 284 of file SDL_render.c.

285{
286 const size_t needed = renderer->vertex_data_used + numbytes + alignment;
287 size_t aligner, aligned;
288 void *retval;
289
291 SDL_AllocVertGap *gap = prevgap->next;
292 while (gap) {
293 const size_t gapoffset = gap->offset;
294 aligner = (alignment && ((gap->offset % alignment) != 0)) ? (alignment - (gap->offset % alignment)) : 0;
295 aligned = gapoffset + aligner;
296
297 /* Can we use this gap? */
298 if ((aligner < gap->len) && ((gap->len - aligner) >= numbytes)) {
299 /* we either finished this gap off, trimmed the left, trimmed the right, or split it into two gaps. */
300 if (gap->len == numbytes) { /* finished it off, remove it */
301 SDL_assert(aligned == gapoffset);
302 prevgap->next = gap->next;
305 } else if (aligned == gapoffset) { /* trimmed the left */
306 gap->offset += numbytes;
307 gap->len -= numbytes;
308 } else if (((aligned - gapoffset) + numbytes) == gap->len) { /* trimmed the right */
309 gap->len -= numbytes;
310 } else { /* split into two gaps */
312 if (!newgap) {
313 return NULL;
314 }
315 newgap->offset = aligned + numbytes;
316 newgap->len = gap->len - (aligner + numbytes);
317 newgap->next = gap->next;
318 // gap->offset doesn't change.
319 gap->len = aligner;
320 gap->next = newgap;
321 }
322
323 if (offset) {
324 *offset = aligned;
325 }
326 return ((Uint8 *) renderer->vertex_data) + aligned;
327 }
328
329 /* Try the next gap */
330 prevgap = gap;
331 gap = gap->next;
332 }
333
334 /* no gaps with enough space; get a new piece of the vertex buffer */
335 while (needed > renderer->vertex_data_allocation) {
336 const size_t current_allocation = renderer->vertex_data ? renderer->vertex_data_allocation : 1024;
337 const size_t newsize = current_allocation * 2;
338 void *ptr = SDL_realloc(renderer->vertex_data, newsize);
339 if (ptr == NULL) {
341 return NULL;
342 }
343 renderer->vertex_data = ptr;
345 }
346
347 aligner = (alignment && ((renderer->vertex_data_used % alignment) != 0)) ? (alignment - (renderer->vertex_data_used % alignment)) : 0;
348 aligned = renderer->vertex_data_used + aligner;
349
350 retval = ((Uint8 *) renderer->vertex_data) + aligned;
351 if (offset) {
352 *offset = aligned;
353 }
354
355 if (aligner) { /* made a new gap... */
357 if (newgap) { /* just let it slide as lost space if malloc fails. */
359 newgap->len = aligner;
360 newgap->next = NULL;
361 prevgap->next = newgap;
362 }
363 }
364
365 renderer->vertex_data_used += aligner + numbytes;
366
367 return retval;
368}
#define SDL_realloc
GLintptr offset
GLenum GLsizei len
static SDL_AllocVertGap * AllocateVertexGap(SDL_Renderer *renderer)
Definition: SDL_render.c:267
uint8_t Uint8
Definition: SDL_stdinc.h:179
size_t vertex_data_allocation

References AllocateVertexGap(), SDL_AllocVertGap::len, SDL_AllocVertGap::next, NULL, SDL_AllocVertGap::offset, renderer, retval, SDL_assert, SDL_OutOfMemory, SDL_realloc, SDL_Renderer::vertex_data, SDL_Renderer::vertex_data_allocation, SDL_Renderer::vertex_data_gaps, SDL_Renderer::vertex_data_gaps_pool, 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
srcColorFactorsource color factor
dstColorFactordestination color factor
colorOperationcolor operation
srcAlphaFactorsource alpha factor
dstAlphaFactordestination alpha factor
alphaOperationalpha 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 3331 of file SDL_render.c.

3335{
3336 SDL_BlendMode blendMode = SDL_COMPOSE_BLENDMODE(srcColorFactor, dstColorFactor, colorOperation,
3337 srcAlphaFactor, dstAlphaFactor, alphaOperation);
3339}
static SDL_BlendMode SDL_GetShortBlendMode(SDL_BlendMode blendMode)
Definition: SDL_render.c:3295

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
windowThe window where rendering is displayed.
indexThe index of the rendering driver to initialize, or -1 to initialize the first one supporting the requested flags.
flagsSDL_RendererFlags.
Returns
A valid rendering context or NULL if there was an error.
See also
SDL_CreateSoftwareRenderer()
SDL_GetRendererInfo()
SDL_DestroyRenderer()

Definition at line 835 of file SDL_render.c.

836{
837#if !SDL_RENDER_DISABLED
840 SDL_bool batching = SDL_TRUE;
841 const char *hint;
842
843#if defined(__ANDROID__)
845#endif
846
847 if (!window) {
848 SDL_SetError("Invalid window");
849 goto error;
850 }
851
852 if (SDL_GetRenderer(window)) {
853 SDL_SetError("Renderer already associated with window");
854 goto error;
855 }
856
860 } else {
861 flags &= ~SDL_RENDERER_PRESENTVSYNC;
862 }
863 }
864
865 if (index < 0) {
867 if (hint) {
868 for (index = 0; index < n; ++index) {
869 const SDL_RenderDriver *driver = render_drivers[index];
870
871 if (SDL_strcasecmp(hint, driver->info.name) == 0) {
872 /* Create a new renderer instance */
874 if (renderer) {
875 batching = SDL_FALSE;
876 }
877 break;
878 }
879 }
880 }
881
882 if (!renderer) {
883 for (index = 0; index < n; ++index) {
884 const SDL_RenderDriver *driver = render_drivers[index];
885
886 if ((driver->info.flags & flags) == flags) {
887 /* Create a new renderer instance */
889 if (renderer) {
890 /* Yay, we got one! */
891 break;
892 }
893 }
894 }
895 }
896 if (index == n) {
897 SDL_SetError("Couldn't find matching render driver");
898 goto error;
899 }
900 } else {
902 SDL_SetError("index must be -1 or in the range of 0 - %d",
904 goto error;
905 }
906 /* Create a new renderer instance */
908 batching = SDL_FALSE;
909 }
910
911 if (!renderer) {
912 goto error;
913 }
914
916
917 /* let app/user override batching decisions. */
918 if (renderer->always_batch) {
919 batching = SDL_TRUE;
922 }
923
924 renderer->batching = batching;
928 renderer->scale.x = 1.0f;
929 renderer->scale.y = 1.0f;
930 renderer->dpi_scale.x = 1.0f;
931 renderer->dpi_scale.y = 1.0f;
932
933 /* new textures start at zero, so we start at 1 so first render doesn't flush by accident. */
935
936 if (window && renderer->GetOutputSize) {
937 int window_w, window_h;
938 int output_w, output_h;
939 if (renderer->GetOutputSize(renderer, &output_w, &output_h) == 0) {
941 renderer->dpi_scale.x = (float)window_w / output_w;
942 renderer->dpi_scale.y = (float)window_h / output_h;
943 }
944 }
945
948 } else {
950 }
951
953
955
957
959 "Created renderer: %s", renderer->info.name);
960
961#if defined(__ANDROID__)
963#endif
964 return renderer;
965
966error:
967
968#if defined(__ANDROID__)
970#endif
971 return NULL;
972
973#else
974 SDL_SetError("SDL not built with rendering support");
975 return NULL;
976#endif
977}
void Android_ActivityMutex_Unlock(void)
void Android_ActivityMutex_Lock_Running(void)
#define SDL_SetError
#define SDL_GetWindowSize
#define SDL_GetWindowFlags
#define SDL_AddEventWatch
#define SDL_strcasecmp
#define SDL_CreateMutex
#define SDL_SetWindowData
#define SDL_GetHintBoolean
#define SDL_LogInfo
#define SDL_GetHint
#define SDL_HINT_RENDER_DRIVER
A variable specifying which render driver to use.
Definition: SDL_hints.h:85
#define SDL_HINT_RENDER_VSYNC
A variable controlling whether updates to the SDL screen surface should be synchronized with the vert...
Definition: SDL_hints.h:154
#define SDL_HINT_RENDER_BATCHING
A variable controlling whether the 2D render API is compatible or efficient.
Definition: SDL_hints.h:1087
@ SDL_LOG_CATEGORY_RENDER
Definition: SDL_log.h:72
GLuint index
GLbitfield flags
GLdouble n
static const SDL_RenderDriver * render_drivers[]
Definition: SDL_render.c:79
int SDL_GetNumRenderDrivers(void)
Get the number of 2D rendering drivers available for the current display.
Definition: SDL_render.c:627
#define SDL_WINDOWRENDERDATA
Definition: SDL_render.c:36
int SDL_RenderSetViewport(SDL_Renderer *renderer, const SDL_Rect *rect)
Set the drawing area for rendering on the current target.
Definition: SDL_render.c:2078
static int SDL_RendererEventWatch(void *userdata, SDL_Event *event)
Definition: SDL_render.c:662
SDL_Renderer * SDL_GetRenderer(SDL_Window *window)
Get the renderer associated with a window.
Definition: SDL_render.c:1007
static SDL_INLINE void VerifyDrawQueueFunctions(const SDL_Renderer *renderer)
Definition: SDL_render.c:821
@ SDL_RENDERER_PRESENTVSYNC
Definition: SDL_render.h:69
@ SDL_WINDOW_MINIMIZED
Definition: SDL_video.h:106
@ SDL_WINDOW_HIDDEN
Definition: SDL_video.h:103
EGLSurface EGLNativeWindowType * window
Definition: eglext.h:1025
SDL_RendererInfo info
SDL_Renderer *(* CreateRenderer)(SDL_Window *window, Uint32 flags)
SDL_Window * window
SDL_bool always_batch
int(* GetOutputSize)(SDL_Renderer *renderer, int *w, int *h)
SDL_bool hidden
SDL_FPoint dpi_scale
const char * name
Definition: SDL_render.h:80
int window_w
Definition: testoverlay2.c:143
int window_h
Definition: testoverlay2.c:144

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::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_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
surfaceThe 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 980 of file SDL_render.c.

981{
982#if !SDL_RENDER_DISABLED
984
986
987 if (renderer) {
991 renderer->scale.x = 1.0f;
992 renderer->scale.y = 1.0f;
993
994 /* new textures start at zero, so we start at 1 so first render doesn't flush by accident. */
996
998 }
999 return renderer;
1000#else
1001 SDL_SetError("SDL not built with rendering support");
1002 return NULL;
1003#endif /* !SDL_RENDER_DISABLED */
1004}
SDL_Renderer * SW_CreateRendererForSurface(SDL_Surface *surface)
EGLSurface surface
Definition: eglext.h:248

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
rendererThe renderer.
formatThe format of the texture.
accessOne of the enumerated values in SDL_TextureAccess.
wThe width of the texture in pixels.
hThe 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 1112 of file SDL_render.c.

1113{
1115
1117
1118 if (!format) {
1120 }
1121 if (SDL_BYTESPERPIXEL(format) == 0) {
1122 SDL_SetError("Invalid texture format");
1123 return NULL;
1124 }
1126 SDL_SetError("Palettized textures are not supported");
1127 return NULL;
1128 }
1129 if (w <= 0 || h <= 0) {
1130 SDL_SetError("Texture dimensions can't be 0");
1131 return NULL;
1132 }
1135 SDL_SetError("Texture dimensions are limited to %dx%d", renderer->info.max_texture_width, renderer->info.max_texture_height);
1136 return NULL;
1137 }
1138 texture = (SDL_Texture *) SDL_calloc(1, sizeof(*texture));
1139 if (!texture) {
1141 return NULL;
1142 }
1143 texture->magic = &texture_magic;
1144 texture->format = format;
1145 texture->access = access;
1146 texture->w = w;
1147 texture->h = h;
1148 texture->r = 255;
1149 texture->g = 255;
1150 texture->b = 255;
1151 texture->a = 255;
1152 texture->scaleMode = SDL_GetScaleMode();
1153 texture->renderer = renderer;
1154 texture->next = renderer->textures;
1155 if (renderer->textures) {
1157 }
1159
1163 return NULL;
1164 }
1165 } else {
1168 access, w, h);
1169 if (!texture->native) {
1171 return NULL;
1172 }
1173
1174 /* Swap textures to have texture before texture->native in the list */
1175 texture->native->next = texture->next;
1176 if (texture->native->next) {
1177 texture->native->next->prev = texture->native;
1178 }
1179 texture->prev = texture->native->prev;
1180 if (texture->prev) {
1181 texture->prev->next = texture;
1182 }
1183 texture->native->prev = texture;
1184 texture->next = texture->native;
1186
1187 if (SDL_ISPIXELFORMAT_FOURCC(texture->format)) {
1189 if (!texture->yuv) {
1191 return NULL;
1192 }
1193 } else if (access == SDL_TEXTUREACCESS_STREAMING) {
1194 /* The pitch is 4 byte aligned */
1195 texture->pitch = (((w * SDL_BYTESPERPIXEL(format)) + 3) & ~3);
1196 texture->pixels = SDL_calloc(1, texture->pitch * h);
1197 if (!texture->pixels) {
1199 return NULL;
1200 }
1201 }
1202 }
1203 return texture;
1204}
GLuint GLint GLboolean GLint GLenum access
GLfloat GLfloat GLfloat GLfloat h
GLubyte GLubyte GLubyte GLubyte w
#define SDL_BYTESPERPIXEL(X)
Definition: SDL_pixels.h:128
#define SDL_ISPIXELFORMAT_INDEXED(format)
Definition: SDL_pixels.h:134
void SDL_DestroyTexture(SDL_Texture *texture)
Destroy the specified texture.
Definition: SDL_render.c:3140
static Uint32 GetClosestSupportedFormat(SDL_Renderer *renderer, Uint32 format)
Definition: SDL_render.c:1070
SDL_Texture * SDL_CreateTexture(SDL_Renderer *renderer, Uint32 format, int access, int w, int h)
Create a texture for a rendering context.
Definition: SDL_render.c:1112
static SDL_bool IsSupportedFormat(SDL_Renderer *renderer, Uint32 format)
Definition: SDL_render.c:1057
#define CHECK_RENDERER_MAGIC(renderer, retval)
Definition: SDL_render.c:38
static SDL_ScaleMode SDL_GetScaleMode(void)
Definition: SDL_render.c:1096
@ SDL_TEXTUREACCESS_STREAMING
Definition: SDL_render.h:94
SDL_SW_YUVTexture * SDL_SW_CreateYUVTexture(Uint32 format, int w, int h)
Definition: SDL_yuv_sw.c:31
SDL_Texture * textures
int(* CreateTexture)(SDL_Renderer *renderer, SDL_Texture *texture)
int max_texture_height
Definition: SDL_render.h:85
SDL_Texture * prev
Definition: SDL_sysrender.h:68

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
rendererThe renderer.
surfaceThe 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 1207 of file SDL_render.c.

1208{
1209 const SDL_PixelFormat *fmt;
1210 SDL_bool needAlpha;
1211 SDL_bool direct_update;
1212 int i;
1215
1217
1218 if (!surface) {
1219 SDL_SetError("SDL_CreateTextureFromSurface() passed NULL surface");
1220 return NULL;
1221 }
1222
1223 /* See what the best texture format is */
1224 fmt = surface->format;
1225 if (fmt->Amask || SDL_HasColorKey(surface)) {
1226 needAlpha = SDL_TRUE;
1227 } else {
1228 needAlpha = SDL_FALSE;
1229 }
1230
1231 /* If Palette contains alpha values, promotes to alpha format */
1232 if (fmt->palette) {
1233 for (i = 0; i < fmt->palette->ncolors; i++) {
1234 Uint8 alpha_value = fmt->palette->colors[i].a;
1235 if (alpha_value != 0 || alpha_value != SDL_ALPHA_OPAQUE) {
1236 needAlpha = SDL_TRUE;
1237 break;
1238 }
1239 }
1240 }
1241
1242 /* Try to have the best pixel format for the texture */
1243 /* No alpha, but a colorkey => promote to alpha */
1244 if (!fmt->Amask && SDL_HasColorKey(surface)) {
1245 if (fmt->format == SDL_PIXELFORMAT_RGB888) {
1246 for (i = 0; i < (int)renderer->info.num_texture_formats; ++i) {
1249 break;
1250 }
1251 }
1252 } else if (fmt->format == SDL_PIXELFORMAT_BGR888) {
1253 for (i = 0; i < (int)renderer->info.num_texture_formats; ++i) {
1256 break;
1257 }
1258 }
1259 }
1260 } else {
1261 /* Exact match would be fine */
1262 for (i = 0; i < (int)renderer->info.num_texture_formats; ++i) {
1263 if (renderer->info.texture_formats[i] == fmt->format) {
1264 format = fmt->format;
1265 break;
1266 }
1267 }
1268 }
1269
1270 /* Fallback, choose a valid pixel format */
1273 for (i = 0; i < (int)renderer->info.num_texture_formats; ++i) {
1277 break;
1278 }
1279 }
1280 }
1281
1283 surface->w, surface->h);
1284 if (!texture) {
1285 return NULL;
1286 }
1287
1288 if (format == surface->format->format) {
1289 if (surface->format->Amask && SDL_HasColorKey(surface)) {
1290 /* Surface and Renderer formats are identicals.
1291 * Intermediate conversion is needed to convert color key to alpha (SDL_ConvertColorkeyToAlpha()). */
1292 direct_update = SDL_FALSE;
1293 } else {
1294 /* Update Texture directly */
1295 direct_update = SDL_TRUE;
1296 }
1297 } else {
1298 /* Surface and Renderer formats are differents, it needs an intermediate conversion. */
1299 direct_update = SDL_FALSE;
1300 }
1301
1302 if (direct_update) {
1303 if (SDL_MUSTLOCK(surface)) {
1305 SDL_UpdateTexture(texture, NULL, surface->pixels, surface->pitch);
1307 } else {
1308 SDL_UpdateTexture(texture, NULL, surface->pixels, surface->pitch);
1309 }
1310 } else {
1311 SDL_PixelFormat *dst_fmt;
1312 SDL_Surface *temp = NULL;
1313
1314 /* Set up a destination surface for the texture update */
1315 dst_fmt = SDL_AllocFormat(format);
1316 if (!dst_fmt) {
1318 return NULL;
1319 }
1320 temp = SDL_ConvertSurface(surface, dst_fmt, 0);
1321 SDL_FreeFormat(dst_fmt);
1322 if (temp) {
1323 SDL_UpdateTexture(texture, NULL, temp->pixels, temp->pitch);
1324 SDL_FreeSurface(temp);
1325 } else {
1327 return NULL;
1328 }
1329 }
1330
1331 {
1332 Uint8 r, g, b, a;
1334
1337
1340
1341 if (SDL_HasColorKey(surface)) {
1342 /* We converted to a texture with alpha format */
1344 } else {
1347 }
1348 }
1349 return texture;
1350}
#define SDL_GetSurfaceBlendMode
#define SDL_FreeFormat
#define SDL_GetSurfaceAlphaMod
#define SDL_AllocFormat
#define SDL_UnlockSurface
#define SDL_HasColorKey
#define SDL_LockSurface
#define SDL_GetSurfaceColorMod
#define SDL_FreeSurface
#define SDL_ConvertSurface
#define SDL_ALPHA_OPAQUE
Definition: SDL_pixels.h:46
@ SDL_PIXELFORMAT_BGR888
Definition: SDL_pixels.h:242
@ SDL_PIXELFORMAT_RGB888
Definition: SDL_pixels.h:236
@ SDL_PIXELFORMAT_ABGR8888
Definition: SDL_pixels.h:254
@ SDL_PIXELFORMAT_ARGB8888
Definition: SDL_pixels.h:248
@ SDL_PIXELFORMAT_UNKNOWN
Definition: SDL_pixels.h:173
int SDL_SetTextureAlphaMod(SDL_Texture *texture, Uint8 alpha)
Set an additional alpha value used in render copy operations.
Definition: SDL_render.c:1411
int SDL_SetTextureColorMod(SDL_Texture *texture, Uint8 r, Uint8 g, Uint8 b)
Set an additional color value used in render copy operations.
Definition: SDL_render.c:1374
int SDL_UpdateTexture(SDL_Texture *texture, const SDL_Rect *rect, const void *pixels, int pitch)
Update the given texture rectangle with new pixel data.
Definition: SDL_render.c:1555
int SDL_SetTextureBlendMode(SDL_Texture *texture, SDL_BlendMode blendMode)
Set the blend mode used for texture copy operations.
Definition: SDL_render.c:1439
@ SDL_TEXTUREACCESS_STATIC
Definition: SDL_render.h:93
#define SDL_MUSTLOCK(S)
Definition: SDL_surface.h:62
Uint8 a
Definition: SDL_pixels.h:300
SDL_Color * colors
Definition: SDL_pixels.h:307
SDL_Palette * palette
Definition: SDL_pixels.h:318
A collection of pixels used in software blitting.
Definition: SDL_surface.h:71
void * pixels
Definition: SDL_surface.h:76

References SDL_Color::a, SDL_PixelFormat::Amask, blendMode, CHECK_RENDERER_MAGIC, SDL_Palette::colors, SDL_PixelFormat::format, i, SDL_Renderer::info, SDL_Palette::ncolors, NULL, SDL_RendererInfo::num_texture_formats, SDL_PixelFormat::palette, SDL_Surface::pitch, SDL_Surface::pixels, renderer, SDL_AllocFormat, SDL_ALPHA_OPAQUE, SDL_BLENDMODE_BLEND, SDL_ConvertSurface, SDL_CreateTexture(), SDL_DestroyTexture(), 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
widthThe width of the window
heightThe height of the window
window_flagsThe flags used to create the window
windowA pointer filled with the window, or NULL on error
rendererA pointer filled with the renderer, or NULL on error
Returns
0 on success, or -1 on error

Definition at line 801 of file SDL_render.c.

803{
806 width, height, window_flags);
807 if (!*window) {
808 *renderer = NULL;
809 return -1;
810 }
811
813 if (!*renderer) {
814 return -1;
815 }
816
817 return 0;
818}
#define SDL_CreateWindow
GLint GLint GLsizei width
Definition: SDL_opengl.h:1572
GLint GLint GLsizei GLsizei height
Definition: SDL_opengl.h:1572
SDL_Renderer * SDL_CreateRenderer(SDL_Window *window, int index, Uint32 flags)
Create a 2D rendering context for a window.
Definition: SDL_render.c:835
#define SDL_WINDOWPOS_UNDEFINED
Definition: SDL_video.h:130

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 3177 of file SDL_render.c.

3178{
3179 SDL_RenderCommand *cmd;
3180 SDL_AllocVertGap *gap;
3181 SDL_AllocVertGap *nextgap;
3182
3184
3186
3190 } else {
3192 }
3193
3197
3198 while (cmd != NULL) {
3199 SDL_RenderCommand *next = cmd->next;
3200 SDL_free(cmd);
3201 cmd = next;
3202 }
3203
3205
3206 for (gap = renderer->vertex_data_gaps.next; gap; gap = nextgap) {
3207 nextgap = gap->next;
3208 SDL_free(gap);
3209 }
3210
3211 for (gap = renderer->vertex_data_gaps_pool; gap; gap = nextgap) {
3212 nextgap = gap->next;
3213 SDL_free(gap);
3214 }
3215
3216 /* Free existing textures for this renderer */
3217 while (renderer->textures) {
3218 SDL_Texture *tex = renderer->textures; (void) tex;
3220 SDL_assert(tex != renderer->textures); /* satisfy static analysis. */
3221 }
3222
3223 if (renderer->window) {
3225 }
3226
3227 /* It's no longer magical... */
3228 renderer->magic = NULL;
3229
3230 /* Free the target mutex */
3233
3234 /* Free the renderer instance */
3236}
#define SDL_DelEventWatch
#define SDL_free
#define SDL_DestroyMutex
SDL_PRINTF_FORMAT_STRING const char int SDL_PRINTF_FORMAT_STRING const char int SDL_PRINTF_FORMAT_STRING const char int SDL_PRINTF_FORMAT_STRING const char const char SDL_SCANF_FORMAT_STRING const char return SDL_ThreadFunction const char void return Uint32 return Uint32 void
void(* DestroyRenderer)(SDL_Renderer *renderer)

References CHECK_RENDERER_MAGIC, SDL_Renderer::DestroyRenderer, SDL_Renderer::magic, SDL_RenderCommand::next, SDL_AllocVertGap::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, SDL_Renderer::vertex_data_gaps, SDL_Renderer::vertex_data_gaps_pool, 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 3140 of file SDL_render.c.

3141{
3143
3145
3146 renderer = texture->renderer;
3147 if (texture == renderer->target) {
3148 SDL_SetRenderTarget(renderer, NULL); /* implies command queue flush */
3149 } else {
3151 }
3152
3153 texture->magic = NULL;
3154
3155 if (texture->next) {
3156 texture->next->prev = texture->prev;
3157 }
3158 if (texture->prev) {
3159 texture->prev->next = texture->next;
3160 } else {
3162 }
3163
3164 if (texture->native) {
3165 SDL_DestroyTexture(texture->native);
3166 }
3167 if (texture->yuv) {
3169 }
3170 SDL_free(texture->pixels);
3171
3174}
int SDL_SetRenderTarget(SDL_Renderer *renderer, SDL_Texture *texture)
Set a texture as the current rendering target.
Definition: SDL_render.c:1833
#define CHECK_TEXTURE_MAGIC(texture, retval)
Definition: SDL_render.c:45
static int FlushRenderCommandsIfTextureNeeded(SDL_Texture *texture)
Definition: SDL_render.c:244
void SDL_SW_DestroyYUVTexture(SDL_SW_YUVTexture *swdata)
Definition: SDL_yuv_sw.c:404
void(* DestroyTexture)(SDL_Renderer *renderer, SDL_Texture *texture)
SDL_Texture * next
Definition: SDL_sysrender.h:69

References CHECK_TEXTURE_MAGIC, SDL_Renderer::DestroyTexture, FlushRenderCommandsIfTextureNeeded(), SDL_Texture::next, NULL, renderer, SDL_DestroyTexture(), SDL_free, 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 2854 of file SDL_render.c.

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

References SDL_FALSE, and SDL_TRUE.

Referenced by SDL_HasIntersectionF().

◆ SDL_GetBlendModeAlphaOperation()

SDL_BlendOperation SDL_GetBlendModeAlphaOperation ( SDL_BlendMode  blendMode)

Definition at line 3377 of file SDL_render.c.

3378{
3380 return (SDL_BlendOperation)(((Uint32)blendMode >> 16) & 0xF);
3381}
SDL_BlendOperation
The blend operation used when combining source and destination pixel components.
Definition: SDL_blendmode.h:63
static SDL_BlendMode SDL_GetLongBlendMode(SDL_BlendMode blendMode)
Definition: SDL_render.c:3313

References blendMode, and SDL_GetLongBlendMode().

◆ SDL_GetBlendModeColorOperation()

SDL_BlendOperation SDL_GetBlendModeColorOperation ( SDL_BlendMode  blendMode)

Definition at line 3356 of file SDL_render.c.

3357{
3359 return (SDL_BlendOperation)(((Uint32)blendMode >> 0) & 0xF);
3360}

References blendMode, and SDL_GetLongBlendMode().

◆ SDL_GetBlendModeDstAlphaFactor()

SDL_BlendFactor SDL_GetBlendModeDstAlphaFactor ( SDL_BlendMode  blendMode)

Definition at line 3370 of file SDL_render.c.

3371{
3373 return (SDL_BlendFactor)(((Uint32)blendMode >> 24) & 0xF);
3374}
SDL_BlendFactor
The normalized factor used to multiply pixel components.
Definition: SDL_blendmode.h:76

References blendMode, and SDL_GetLongBlendMode().

◆ SDL_GetBlendModeDstColorFactor()

SDL_BlendFactor SDL_GetBlendModeDstColorFactor ( SDL_BlendMode  blendMode)

Definition at line 3349 of file SDL_render.c.

3350{
3352 return (SDL_BlendFactor)(((Uint32)blendMode >> 8) & 0xF);
3353}

References blendMode, and SDL_GetLongBlendMode().

◆ SDL_GetBlendModeSrcAlphaFactor()

SDL_BlendFactor SDL_GetBlendModeSrcAlphaFactor ( SDL_BlendMode  blendMode)

Definition at line 3363 of file SDL_render.c.

3364{
3366 return (SDL_BlendFactor)(((Uint32)blendMode >> 20) & 0xF);
3367}

References blendMode, and SDL_GetLongBlendMode().

◆ SDL_GetBlendModeSrcColorFactor()

SDL_BlendFactor SDL_GetBlendModeSrcColorFactor ( SDL_BlendMode  blendMode)

Definition at line 3342 of file SDL_render.c.

3343{
3345 return (SDL_BlendFactor)(((Uint32)blendMode >> 4) & 0xF);
3346}

References blendMode, and SDL_GetLongBlendMode().

◆ SDL_GetLongBlendMode()

◆ 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 627 of file SDL_render.c.

628{
629#if !SDL_RENDER_DISABLED
631#else
632 return 0;
633#endif
634}
#define SDL_arraysize(array)
Definition: SDL_stdinc.h:115

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
rendererThe renderer from which blend mode should be queried.
blendModeA pointer filled in with the current blend mode.
Returns
0 on success, or -1 on error
See also
SDL_SetRenderDrawBlendMode()

Definition at line 2223 of file SDL_render.c.

2224{
2226
2228 return 0;
2229}

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
rendererThe renderer from which drawing color should be queried.
rA pointer to the red value used to draw on the rendering target.
gA pointer to the green value used to draw on the rendering target.
bA pointer to the blue value used to draw on the rendering target.
aA 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 2190 of file SDL_render.c.

2192{
2194
2195 if (r) {
2196 *r = renderer->r;
2197 }
2198 if (g) {
2199 *g = renderer->g;
2200 }
2201 if (b) {
2202 *b = renderer->b;
2203 }
2204 if (a) {
2205 *a = renderer->a;
2206 }
2207 return 0;
2208}

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
indexThe index of the driver to query information about.
infoA 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 637 of file SDL_render.c.

638{
639#if !SDL_RENDER_DISABLED
641 return SDL_SetError("index must be in the range of 0 - %d",
643 }
644 *info = render_drivers[index]->info;
645 return 0;
646#else
647 return SDL_SetError("SDL not built with rendering support");
648#endif
649}

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 1007 of file SDL_render.c.

1008{
1010}
#define SDL_GetWindowData

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 1013 of file SDL_render.c.

1014{
1016
1017 *info = renderer->info;
1018 return 0;
1019}

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 1022 of file SDL_render.c.

1023{
1025
1026 if (renderer->target) {
1028 } else if (renderer->GetOutputSize) {
1029 return renderer->GetOutputSize(renderer, w, h);
1030 } else if (renderer->window) {
1032 return 0;
1033 } else {
1034 SDL_assert(0 && "This should never happen");
1035 return SDL_SetError("Renderer doesn't support querying output size");
1036 }
1037}
int SDL_QueryTexture(SDL_Texture *texture, Uint32 *format, int *access, int *w, int *h)
Query the attributes of a texture.
Definition: SDL_render.c:1353

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_RendererEventWatch(), 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 1912 of file SDL_render.c.

1913{
1914 return renderer->target;
1915}

References renderer, and SDL_Renderer::target.

Referenced by SDL_RendererEventWatch().

◆ SDL_GetScaleMode()

static SDL_ScaleMode SDL_GetScaleMode ( void  )
static

Definition at line 1096 of file SDL_render.c.

1097{
1098 const char *hint = SDL_GetHint(SDL_HINT_RENDER_SCALE_QUALITY);
1099
1100 if (!hint || SDL_strcasecmp(hint, "nearest") == 0) {
1101 return SDL_ScaleModeNearest;
1102 } else if (SDL_strcasecmp(hint, "linear") == 0) {
1103 return SDL_ScaleModeLinear;
1104 } else if (SDL_strcasecmp(hint, "best") == 0) {
1105 return SDL_ScaleModeBest;
1106 } else {
1107 return (SDL_ScaleMode)SDL_atoi(hint);
1108 }
1109}
#define SDL_atoi
#define SDL_HINT_RENDER_SCALE_QUALITY
A variable controlling the scaling quality.
Definition: SDL_hints.h:143
SDL_ScaleMode
Definition: SDL_sysrender.h:36
@ SDL_ScaleModeLinear
Definition: SDL_sysrender.h:38
@ SDL_ScaleModeBest
Definition: SDL_sysrender.h:39
@ SDL_ScaleModeNearest
Definition: SDL_sysrender.h:37

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

◆ SDL_GetTextureAlphaMod()

int SDL_GetTextureAlphaMod ( SDL_Texture texture,
Uint8 alpha 
)

Get the additional alpha value used in render copy operations.

Parameters
textureThe texture to query.
alphaA 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 1428 of file SDL_render.c.

1429{
1431
1432 if (alpha) {
1433 *alpha = texture->a;
1434 }
1435 return 0;
1436}
GLfloat GLfloat GLfloat alpha

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
textureThe texture to query.
blendModeA 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 1457 of file SDL_render.c.

1458{
1460
1461 if (blendMode) {
1462 *blendMode = texture->blendMode;
1463 }
1464 return 0;
1465}

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
textureThe texture to query.
rA pointer filled in with the current red color value.
gA pointer filled in with the current green color value.
bA 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 1393 of file SDL_render.c.

1395{
1397
1398 if (r) {
1399 *r = texture->r;
1400 }
1401 if (g) {
1402 *g = texture->g;
1403 }
1404 if (b) {
1405 *b = texture->b;
1406 }
1407 return 0;
1408}

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
textureThe SDL texture to bind
texwA pointer to a float that will be filled with the texture width
texhA 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 3238 of file SDL_render.c.

3239{
3241
3243 renderer = texture->renderer;
3244 if (texture->native) {
3245 return SDL_GL_BindTexture(texture->native, texw, texh);
3246 } else if (renderer && renderer->GL_BindTexture) {
3247 FlushRenderCommandsIfTextureNeeded(texture); /* in case the app is going to mess with it. */
3248 return renderer->GL_BindTexture(renderer, texture, texw, texh);
3249 } else {
3250 return SDL_Unsupported();
3251 }
3252}
#define SDL_Unsupported()
Definition: SDL_error.h:53
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.
Definition: SDL_render.c:3238
int(* GL_BindTexture)(SDL_Renderer *renderer, SDL_Texture *texture, float *texw, float *texh)

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
textureThe SDL texture to unbind
Returns
0 on success, or -1 if the operation is not supported

Definition at line 3254 of file SDL_render.c.

3255{
3257
3259 renderer = texture->renderer;
3260 if (texture->native) {
3261 return SDL_GL_UnbindTexture(texture->native);
3262 } else if (renderer && renderer->GL_UnbindTexture) {
3263 FlushRenderCommandsIfTextureNeeded(texture); /* in case the app messed with it. */
3265 }
3266
3267 return SDL_Unsupported();
3268}
int SDL_GL_UnbindTexture(SDL_Texture *texture)
Unbind a texture from the current OpenGL/ES/ES2 context.
Definition: SDL_render.c:3254
int(* GL_UnbindTexture)(SDL_Renderer *renderer, SDL_Texture *texture)

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 2861 of file SDL_render.c.

2862{
2863 float Amin, Amax, Bmin, Bmax;
2864
2865 if (!A) {
2867 return SDL_FALSE;
2868 }
2869
2870 if (!B) {
2872 return SDL_FALSE;
2873 }
2874
2875 /* Special cases for empty rects */
2876 if (SDL_FRectEmpty(A) || SDL_FRectEmpty(B)) {
2877 return SDL_FALSE;
2878 }
2879
2880 /* Horizontal intersection */
2881 Amin = A->x;
2882 Amax = Amin + A->w;
2883 Bmin = B->x;
2884 Bmax = Bmin + B->w;
2885 if (Bmin > Amin)
2886 Amin = Bmin;
2887 if (Bmax < Amax)
2888 Amax = Bmax;
2889 if (Amax <= Amin)
2890 return SDL_FALSE;
2891
2892 /* Vertical intersection */
2893 Amin = A->y;
2894 Amax = Amin + A->h;
2895 Bmin = B->y;
2896 Bmax = Bmin + B->h;
2897 if (Bmin > Amin)
2898 Amin = Bmin;
2899 if (Bmax < Amax)
2900 Amax = Bmax;
2901 if (Amax <= Amin)
2902 return SDL_FALSE;
2903
2904 return SDL_TRUE;
2905}
#define SDL_InvalidParamError(param)
Definition: SDL_error.h:54
SDL_FORCE_INLINE SDL_bool SDL_FRectEmpty(const SDL_FRect *r)
Definition: SDL_render.c:2854

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
textureThe texture to lock for access, which was created with SDL_TEXTUREACCESS_STREAMING.
rectA pointer to the rectangle to lock for access. If the rect is NULL, the entire texture will be locked.
pixelsThis is filled in with a pointer to the locked pixels, appropriately offset by the locked area.
pitchThis 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 1727 of file SDL_render.c.

1729{
1730 SDL_Rect full_rect;
1731
1733
1734 if (texture->access != SDL_TEXTUREACCESS_STREAMING) {
1735 return SDL_SetError("SDL_LockTexture(): texture must be streaming");
1736 }
1737
1738 if (!rect) {
1739 full_rect.x = 0;
1740 full_rect.y = 0;
1741 full_rect.w = texture->w;
1742 full_rect.h = texture->h;
1743 rect = &full_rect;
1744 }
1745
1746 if (texture->yuv) {
1748 return -1;
1749 }
1750 return SDL_LockTextureYUV(texture, rect, pixels, pitch);
1751 } else if (texture->native) {
1752 /* Calls a real SDL_LockTexture/SDL_UnlockTexture on unlock, flushing then. */
1753 return SDL_LockTextureNative(texture, rect, pixels, pitch);
1754 } else {
1755 SDL_Renderer *renderer = texture->renderer;
1757 return -1;
1758 }
1759 return renderer->LockTexture(renderer, texture, rect, pixels, pitch);
1760 }
1761}
GLint GLint GLsizei GLsizei GLsizei GLint GLenum GLenum const GLvoid * pixels
Definition: SDL_opengl.h:1572
static int SDL_LockTextureYUV(SDL_Texture *texture, const SDL_Rect *rect, void **pixels, int *pitch)
Definition: SDL_render.c:1708
static int SDL_LockTextureNative(SDL_Texture *texture, const SDL_Rect *rect, void **pixels, int *pitch)
Definition: SDL_render.c:1715
int(* LockTexture)(SDL_Renderer *renderer, SDL_Texture *texture, const SDL_Rect *rect, void **pixels, int *pitch)
SDL_Rect rect
Definition: testrelative.c:27

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_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 1715 of file SDL_render.c.

1717{
1718 texture->locked_rect = *rect;
1719 *pixels = (void *) ((Uint8 *) texture->pixels +
1720 rect->y * texture->pitch +
1721 rect->x * SDL_BYTESPERPIXEL(texture->format));
1722 *pitch = texture->pitch;
1723 return 0;
1724}

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

Referenced by SDL_LockTexture().

◆ SDL_LockTextureYUV()

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

Definition at line 1708 of file SDL_render.c.

1710{
1711 return SDL_SW_LockYUVTexture(texture->yuv, rect, pixels, pitch);
1712}
int SDL_SW_LockYUVTexture(SDL_SW_YUVTexture *swdata, const SDL_Rect *rect, void **pixels, int *pitch)
Definition: SDL_yuv_sw.c:302

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
textureA texture to be queried.
formatA pointer filled in with the raw format of the texture. The actual format may differ, but pixel transfers will use this format.
accessA pointer filled in with the actual access to the texture.
wA pointer filled in with the width of the texture in pixels.
hA 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 1353 of file SDL_render.c.

1355{
1357
1358 if (format) {
1359 *format = texture->format;
1360 }
1361 if (access) {
1362 *access = texture->access;
1363 }
1364 if (w) {
1365 *w = texture->w;
1366 }
1367 if (h) {
1368 *h = texture->h;
1369 }
1370 return 0;
1371}

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 2232 of file SDL_render.c.

2233{
2234 int retval;
2238}
static int QueueCmdClear(SDL_Renderer *renderer)
Definition: SDL_render.c:474

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
rendererThe renderer which should copy parts of a texture.
textureThe source texture.
srcrectA pointer to the source rectangle, or NULL for the entire texture.
dstrectA pointer to the destination rectangle, or NULL for the entire rendering target.
Returns
0 on success, or -1 on error

Definition at line 2908 of file SDL_render.c.

2910{
2911 SDL_FRect dstfrect;
2912 SDL_FRect *pdstfrect = NULL;
2913 if (dstrect) {
2914 dstfrect.x = (float) dstrect->x;
2915 dstfrect.y = (float) dstrect->y;
2916 dstfrect.w = (float) dstrect->w;
2917 dstfrect.h = (float) dstrect->h;
2918 pdstfrect = &dstfrect;
2919 }
2920 return SDL_RenderCopyF(renderer, texture, srcrect, pdstfrect);
2921}
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.
Definition: SDL_render.c:2924

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
rendererThe renderer which should copy parts of a texture.
textureThe source texture.
srcrectA pointer to the source rectangle, or NULL for the entire texture.
dstrectA pointer to the destination rectangle, or NULL for the entire rendering target.
angleAn angle in degrees that indicates the rotation that will be applied to dstrect, rotating it in a clockwise direction
centerA 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).
flipAn SDL_RendererFlip value stating which flipping actions should be performed on the texture
Returns
0 on success, or -1 on error

Definition at line 2983 of file SDL_render.c.

2986{
2987 SDL_FRect dstfrect;
2988 SDL_FRect *pdstfrect = NULL;
2989 SDL_FPoint fcenter;
2990 SDL_FPoint *pfcenter = NULL;
2991
2992 if (dstrect) {
2993 dstfrect.x = (float) dstrect->x;
2994 dstfrect.y = (float) dstrect->y;
2995 dstfrect.w = (float) dstrect->w;
2996 dstfrect.h = (float) dstrect->h;
2997 pdstfrect = &dstfrect;
2998 }
2999
3000 if (center) {
3001 fcenter.x = (float) center->x;
3002 fcenter.y = (float) center->y;
3003 pfcenter = &fcenter;
3004 }
3005
3006 return SDL_RenderCopyExF(renderer, texture, srcrect, pdstfrect, angle, pfcenter, flip);
3007}
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...
Definition: SDL_render.c:3010
int x
Definition: SDL_rect.h:50
int y
Definition: SDL_rect.h:51

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
rendererThe renderer which should copy parts of a texture.
textureThe source texture.
srcrectA pointer to the source rectangle, or NULL for the entire texture.
dstrectA pointer to the destination rectangle, or NULL for the entire rendering target.
angleAn angle in degrees that indicates the rotation that will be applied to dstrect, rotating it in a clockwise direction
centerA 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).
flipAn SDL_RendererFlip value stating which flipping actions should be performed on the texture
Returns
0 on success, or -1 on error

Definition at line 3010 of file SDL_render.c.

3013{
3014 SDL_Rect real_srcrect;
3015 SDL_FRect real_dstrect;
3016 SDL_FPoint real_center;
3017 int retval;
3018
3019 if (flip == SDL_FLIP_NONE && (int)(angle/360) == angle/360) { /* fast path when we don't need rotation or flipping */
3020 return SDL_RenderCopyF(renderer, texture, srcrect, dstrect);
3021 }
3022
3025
3026 if (renderer != texture->renderer) {
3027 return SDL_SetError("Texture was not created with this renderer");
3028 }
3029 if (!renderer->QueueCopyEx) {
3030 return SDL_SetError("Renderer does not support RenderCopyEx");
3031 }
3032
3033 /* Don't draw while we're hidden */
3034 if (renderer->hidden) {
3035 return 0;
3036 }
3037
3038 real_srcrect.x = 0;
3039 real_srcrect.y = 0;
3040 real_srcrect.w = texture->w;
3041 real_srcrect.h = texture->h;
3042 if (srcrect) {
3043 if (!SDL_IntersectRect(srcrect, &real_srcrect, &real_srcrect)) {
3044 return 0;
3045 }
3046 }
3047
3048 /* We don't intersect the dstrect with the viewport as RenderCopy does because of potential rotation clipping issues... TODO: should we? */
3049 if (dstrect) {
3050 real_dstrect = *dstrect;
3051 } else {
3052 SDL_Rect r;
3053 SDL_zero(r);
3055 real_dstrect.x = 0.0f;
3056 real_dstrect.y = 0.0f;
3057 real_dstrect.w = (float) r.w;
3058 real_dstrect.h = (float) r.h;
3059 }
3060
3061 if (texture->native) {
3062 texture = texture->native;
3063 }
3064
3065 if (center) {
3066 real_center = *center;
3067 } else {
3068 real_center.x = real_dstrect.w / 2.0f;
3069 real_center.y = real_dstrect.h / 2.0f;
3070 }
3071
3072 real_dstrect.x *= renderer->scale.x;
3073 real_dstrect.y *= renderer->scale.y;
3074 real_dstrect.w *= renderer->scale.x;
3075 real_dstrect.h *= renderer->scale.y;
3076
3077 real_center.x *= renderer->scale.x;
3078 real_center.y *= renderer->scale.y;
3079
3080 texture->last_command_generation = renderer->render_command_generation;
3081
3082 retval = QueueCmdCopyEx(renderer, texture, &real_srcrect, &real_dstrect, angle, &real_center, flip);
3084}
#define SDL_IntersectRect
void SDL_RenderGetViewport(SDL_Renderer *renderer, SDL_Rect *rect)
Get the drawing area for the current target.
Definition: SDL_render.c:2100
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)
Definition: SDL_render.c:607
@ SDL_FLIP_NONE
Definition: SDL_render.h:113
#define SDL_zero(x)
Definition: SDL_stdinc.h:416

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
rendererThe renderer which should copy parts of a texture.
textureThe source texture.
srcrectA pointer to the source rectangle, or NULL for the entire texture.
dstrectA pointer to the destination rectangle, or NULL for the entire rendering target.
Returns
0 on success, or -1 on error

Definition at line 2924 of file SDL_render.c.

2926{
2927 SDL_Rect real_srcrect;
2928 SDL_FRect real_dstrect;
2929 SDL_Rect r;
2930 int retval;
2931
2934
2935 if (renderer != texture->renderer) {
2936 return SDL_SetError("Texture was not created with this renderer");
2937 }
2938
2939 /* Don't draw while we're hidden */
2940 if (renderer->hidden) {
2941 return 0;
2942 }
2943
2944 real_srcrect.x = 0;
2945 real_srcrect.y = 0;
2946 real_srcrect.w = texture->w;
2947 real_srcrect.h = texture->h;
2948 if (srcrect) {
2949 if (!SDL_IntersectRect(srcrect, &real_srcrect, &real_srcrect)) {
2950 return 0;
2951 }
2952 }
2953
2954 SDL_zero(r);
2956 real_dstrect.x = 0.0f;
2957 real_dstrect.y = 0.0f;
2958 real_dstrect.w = (float) r.w;
2959 real_dstrect.h = (float) r.h;
2960 if (dstrect) {
2961 if (!SDL_HasIntersectionF(dstrect, &real_dstrect)) {
2962 return 0;
2963 }
2964 real_dstrect = *dstrect;
2965 }
2966
2967 if (texture->native) {
2968 texture = texture->native;
2969 }
2970
2971 real_dstrect.x *= renderer->scale.x;
2972 real_dstrect.y *= renderer->scale.y;
2973 real_dstrect.w *= renderer->scale.x;
2974 real_dstrect.h *= renderer->scale.y;
2975
2976 texture->last_command_generation = renderer->render_command_generation;
2977
2978 retval = QueueCmdCopy(renderer, texture, &real_srcrect, &real_dstrect);
2980}
static SDL_bool SDL_HasIntersectionF(const SDL_FRect *A, const SDL_FRect *B)
Definition: SDL_render.c:2861
static int QueueCmdCopy(SDL_Renderer *renderer, SDL_Texture *texture, const SDL_Rect *srcrect, const SDL_FRect *dstrect)
Definition: SDL_render.c:593

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
rendererThe renderer which should draw a line.
x1The x coordinate of the start point.
y1The y coordinate of the start point.
x2The x coordinate of the end point.
y2The y coordinate of the end point.
Returns
0 on success, or -1 on error

Definition at line 2403 of file SDL_render.c.

2404{
2405 SDL_FPoint points[2];
2406 points[0].x = (float) x1;
2407 points[0].y = (float) y1;
2408 points[1].x = (float) x2;
2409 points[1].y = (float) y2;
2411}
GLfixed GLfixed GLfixed y2
GLfixed y1
GLuint GLfloat GLfloat GLfloat x1
GLfixed GLfixed x2
int SDL_RenderDrawLinesF(SDL_Renderer *renderer, const SDL_FPoint *points, int count)
Draw a series of connected lines on the current rendering target.
Definition: SDL_render.c:2578

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
rendererThe renderer which should draw a line.
x1The x coordinate of the start point.
y1The y coordinate of the start point.
x2The x coordinate of the end point.
y2The y coordinate of the end point.
Returns
0 on success, or -1 on error

Definition at line 2414 of file SDL_render.c.

2415{
2416 SDL_FPoint points[2];
2417 points[0].x = x1;
2418 points[0].y = y1;
2419 points[1].x = x2;
2420 points[1].y = y2;
2422}

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
rendererThe renderer which should draw multiple lines.
pointsThe points along the lines
countThe number of points, drawing count-1 lines
Returns
0 on success, or -1 on error

Definition at line 2535 of file SDL_render.c.

2537{
2538 SDL_FPoint *fpoints;
2539 int i;
2540 int retval;
2541 SDL_bool isstack;
2542
2544
2545 if (!points) {
2546 return SDL_SetError("SDL_RenderDrawLines(): Passed NULL points");
2547 }
2548 if (count < 2) {
2549 return 0;
2550 }
2551
2552 /* Don't draw while we're hidden */
2553 if (renderer->hidden) {
2554 return 0;
2555 }
2556
2557 if (renderer->scale.x != 1.0f || renderer->scale.y != 1.0f) {
2559 }
2560
2561 fpoints = SDL_small_alloc(SDL_FPoint, count, &isstack);
2562 if (!fpoints) {
2563 return SDL_OutOfMemory();
2564 }
2565 for (i = 0; i < count; ++i) {
2566 fpoints[i].x = points[i].x * renderer->scale.x;
2567 fpoints[i].y = points[i].y * renderer->scale.y;
2568 }
2569
2571
2572 SDL_small_free(fpoints, isstack);
2573
2575}
static int RenderDrawLinesWithRects(SDL_Renderer *renderer, const SDL_Point *points, const int count)
Definition: SDL_render.c:2425

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
rendererThe renderer which should draw multiple lines.
pointsThe points along the lines
countThe number of points, drawing count-1 lines
Returns
0 on success, or -1 on error

Definition at line 2578 of file SDL_render.c.

2580{
2581 SDL_FPoint *fpoints;
2582 int i;
2583 int retval;
2584 SDL_bool isstack;
2585
2587
2588 if (!points) {
2589 return SDL_SetError("SDL_RenderDrawLines(): Passed NULL points");
2590 }
2591 if (count < 2) {
2592 return 0;
2593 }
2594
2595 /* Don't draw while we're hidden */
2596 if (renderer->hidden) {
2597 return 0;
2598 }
2599
2600 if (renderer->scale.x != 1.0f || renderer->scale.y != 1.0f) {
2602 }
2603
2604 fpoints = SDL_small_alloc(SDL_FPoint, count, &isstack);
2605 if (!fpoints) {
2606 return SDL_OutOfMemory();
2607 }
2608 for (i = 0; i < count; ++i) {
2609 fpoints[i].x = points[i].x * renderer->scale.x;
2610 fpoints[i].y = points[i].y * renderer->scale.y;
2611 }
2612
2614
2615 SDL_small_free(fpoints, isstack);
2616
2618}
static int RenderDrawLinesWithRectsF(SDL_Renderer *renderer, const SDL_FPoint *points, const int count)
Definition: SDL_render.c:2480

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
rendererThe renderer which should draw a point.
xThe x coordinate of the point.
yThe y coordinate of the point.
Returns
0 on success, or -1 on error

Definition at line 2245 of file SDL_render.c.

2246{
2247 SDL_FPoint fpoint;
2248 fpoint.x = (float) x;
2249 fpoint.y = (float) y;
2250 return SDL_RenderDrawPointsF(renderer, &fpoint, 1);
2251}
int SDL_RenderDrawPointsF(SDL_Renderer *renderer, const SDL_FPoint *points, int count)
Draw multiple points on the current rendering target.
Definition: SDL_render.c:2360

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
rendererThe renderer which should draw a point.
xThe x coordinate of the point.
yThe y coordinate of the point.
Returns
0 on success, or -1 on error

Definition at line 2254 of file SDL_render.c.

2255{
2256 SDL_FPoint fpoint;
2257 fpoint.x = x;
2258 fpoint.y = y;
2259 return SDL_RenderDrawPointsF(renderer, &fpoint, 1);
2260}

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
rendererThe renderer which should draw multiple points.
pointsThe points to draw
countThe number of points to draw
Returns
0 on success, or -1 on error

Definition at line 2290 of file SDL_render.c.

2292{
2293 SDL_FPoint *fpoints;
2294 int i;
2295 int retval;
2296 SDL_bool isstack;
2297
2299
2300 if (!points) {
2301 return SDL_SetError("SDL_RenderDrawPoints(): Passed NULL points");
2302 }
2303 if (count < 1) {
2304 return 0;
2305 }
2306
2307 /* Don't draw while we're hidden */
2308 if (renderer->hidden) {
2309 return 0;
2310 }
2311
2312 if (renderer->scale.x != 1.0f || renderer->scale.y != 1.0f) {
2314 }
2315
2316 fpoints = SDL_small_alloc(SDL_FPoint, count, &isstack);
2317 if (!fpoints) {
2318 return SDL_OutOfMemory();
2319 }
2320 for (i = 0; i < count; ++i) {
2321 fpoints[i].x = points[i].x * renderer->scale.x;
2322 fpoints[i].y = points[i].y * renderer->scale.y;
2323 }
2324
2326
2327 SDL_small_free(fpoints, isstack);
2328
2330}
static int RenderDrawPointsWithRects(SDL_Renderer *renderer, const SDL_Point *points, const int count)
Definition: SDL_render.c:2263
static int QueueCmdDrawPoints(SDL_Renderer *renderer, const SDL_FPoint *points, const int count)
Definition: SDL_render.c:529

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
rendererThe renderer which should draw multiple points.
pointsThe points to draw
countThe number of points to draw
Returns
0 on success, or -1 on error

Definition at line 2360 of file SDL_render.c.

2362{
2363 SDL_FPoint *fpoints;
2364 int i;
2365 int retval;
2366 SDL_bool isstack;
2367
2369
2370 if (!points) {
2371 return SDL_SetError("SDL_RenderDrawFPoints(): Passed NULL points");
2372 }
2373 if (count < 1) {
2374 return 0;
2375 }
2376
2377 /* Don't draw while we're hidden */
2378 if (renderer->hidden) {
2379 return 0;
2380 }
2381
2382 if (renderer->scale.x != 1.0f || renderer->scale.y != 1.0f) {
2384 }
2385
2386 fpoints = SDL_small_alloc(SDL_FPoint, count, &isstack);
2387 if (!fpoints) {
2388 return SDL_OutOfMemory();
2389 }
2390 for (i = 0; i < count; ++i) {
2391 fpoints[i].x = points[i].x * renderer->scale.x;
2392 fpoints[i].y = points[i].y * renderer->scale.y;
2393 }
2394
2396
2397 SDL_small_free(fpoints, isstack);
2398
2400}
static int RenderDrawPointsWithRectsF(SDL_Renderer *renderer, const SDL_FPoint *fpoints, const int count)
Definition: SDL_render.c:2333

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
rendererThe renderer which should draw a rectangle.
rectA pointer to the destination rectangle, or NULL to outline the entire rendering target.
Returns
0 on success, or -1 on error

Definition at line 2621 of file SDL_render.c.

2622{
2623 SDL_FRect frect;
2624 SDL_FRect *prect = NULL;
2625
2626 if (rect) {
2627 frect.x = (float) rect->x;
2628 frect.y = (float) rect->y;
2629 frect.w = (float) rect->w;
2630 frect.h = (float) rect->h;
2631 prect = &frect;
2632 }
2633
2634 return SDL_RenderDrawRectF(renderer, prect);
2635}
int SDL_RenderDrawRectF(SDL_Renderer *renderer, const SDL_FRect *rect)
Draw a rectangle on the current rendering target.
Definition: SDL_render.c:2638

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
rendererThe renderer which should draw a rectangle.
rectA pointer to the destination rectangle, or NULL to outline the entire rendering target.
Returns
0 on success, or -1 on error

Definition at line 2638 of file SDL_render.c.

2639{
2640 SDL_FRect frect;
2641 SDL_FPoint points[5];
2642
2644
2645 /* If 'rect' == NULL, then outline the whole surface */
2646 if (!rect) {
2647 SDL_Rect r;
2649 frect.x = 0.0f;
2650 frect.y = 0.0f;
2651 frect.w = (float) r.w;
2652 frect.h = (float) r.h;
2653 rect = &frect;
2654 }
2655
2656 points[0].x = rect->x;
2657 points[0].y = rect->y;
2658 points[1].x = rect->x+rect->w-1;
2659 points[1].y = rect->y;
2660 points[2].x = rect->x+rect->w-1;
2661 points[2].y = rect->y+rect->h-1;
2662 points[3].x = rect->x;
2663 points[3].y = rect->y+rect->h-1;
2664 points[4].x = rect->x;
2665 points[4].y = rect->y;
2667}

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
rendererThe renderer which should draw multiple rectangles.
rectsA pointer to an array of destination rectangles.
countThe number of rectangles.
Returns
0 on success, or -1 on error

Definition at line 2670 of file SDL_render.c.

2672{
2673 int i;
2674
2676
2677 if (!rects) {
2678 return SDL_SetError("SDL_RenderDrawRects(): Passed NULL rects");
2679 }
2680 if (count < 1) {
2681 return 0;
2682 }
2683
2684 /* Don't draw while we're hidden */
2685 if (renderer->hidden) {
2686 return 0;
2687 }
2688
2689 for (i = 0; i < count; ++i) {
2690 if (SDL_RenderDrawRect(renderer, &rects[i]) < 0) {
2691 return -1;
2692 }
2693 }
2694 return 0;
2695}
int SDL_RenderDrawRect(SDL_Renderer *renderer, const SDL_Rect *rect)
Draw a rectangle on the current rendering target.
Definition: SDL_render.c:2621

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
rendererThe renderer which should draw multiple rectangles.
rectsA pointer to an array of destination rectangles.
countThe number of rectangles.
Returns
0 on success, or -1 on error

Definition at line 2698 of file SDL_render.c.

2700{
2701 int i;
2702
2704
2705 if (!rects) {
2706 return SDL_SetError("SDL_RenderDrawRects(): Passed NULL rects");
2707 }
2708 if (count < 1) {
2709 return 0;
2710 }
2711
2712 /* Don't draw while we're hidden */
2713 if (renderer->hidden) {
2714 return 0;
2715 }
2716
2717 for (i = 0; i < count; ++i) {
2718 if (SDL_RenderDrawRectF(renderer, &rects[i]) < 0) {
2719 return -1;
2720 }
2721 }
2722 return 0;
2723}

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 662 of file SDL_render.c.

663{
664 SDL_Renderer *renderer = (SDL_Renderer *)userdata;
665
666 if (event->type == SDL_WINDOWEVENT) {
667 SDL_Window *window = SDL_GetWindowFromID(event->window.windowID);
668 if (window == renderer->window) {
669 if (renderer->WindowEvent) {
671 }
672
673 if (event->window.event == SDL_WINDOWEVENT_SIZE_CHANGED) {
674 /* Make sure we're operating on the default render target */
676 if (saved_target) {
678 }
679
680 if (renderer->logical_w) {
682 } else {
683 /* Window was resized, reset viewport */
684 int w, h;
685
686 if (renderer->GetOutputSize) {
688 } else {
690 }
691
692 if (renderer->target) {
697 } else {
698 renderer->viewport.x = 0;
699 renderer->viewport.y = 0;
700 renderer->viewport.w = w;
701 renderer->viewport.h = h;
704 }
705 }
706
707 if (saved_target) {
708 SDL_SetRenderTarget(renderer, saved_target);
709 }
710 } else if (event->window.event == SDL_WINDOWEVENT_HIDDEN) {
712 } else if (event->window.event == SDL_WINDOWEVENT_SHOWN) {
715 }
716 } else if (event->window.event == SDL_WINDOWEVENT_MINIMIZED) {
718 } else if (event->window.event == SDL_WINDOWEVENT_RESTORED ||
719 event->window.event == SDL_WINDOWEVENT_MAXIMIZED) {
722 }
723 }
724 }
725 } else if (event->type == SDL_MOUSEMOTION) {
726 SDL_Window *window = SDL_GetWindowFromID(event->motion.windowID);
727 if (window == renderer->window) {
728 int logical_w, logical_h;
731 GetWindowViewportValues(renderer, &logical_w, &logical_h, &viewport, &scale);
732 if (logical_w) {
733 event->motion.x -= (int)(viewport.x * renderer->dpi_scale.x);
734 event->motion.y -= (int)(viewport.y * renderer->dpi_scale.y);
735 event->motion.x = (int)(event->motion.x / (scale.x * renderer->dpi_scale.x));
736 event->motion.y = (int)(event->motion.y / (scale.y * renderer->dpi_scale.y));
737 if (event->motion.xrel > 0) {
738 event->motion.xrel = SDL_max(1, (int)(event->motion.xrel / (scale.x * renderer->dpi_scale.x)));
739 } else if (event->motion.xrel < 0) {
740 event->motion.xrel = SDL_min(-1, (int)(event->motion.xrel / (scale.x * renderer->dpi_scale.x)));
741 }
742 if (event->motion.yrel > 0) {
743 event->motion.yrel = SDL_max(1, (int)(event->motion.yrel / (scale.y * renderer->dpi_scale.y)));
744 } else if (event->motion.yrel < 0) {
745 event->motion.yrel = SDL_min(-1, (int)(event->motion.yrel / (scale.y * renderer->dpi_scale.y)));
746 }
747 }
748 }
749 } else if (event->type == SDL_MOUSEBUTTONDOWN ||
750 event->type == SDL_MOUSEBUTTONUP) {
751 SDL_Window *window = SDL_GetWindowFromID(event->button.windowID);
752 if (window == renderer->window) {
753 int logical_w, logical_h;
756 GetWindowViewportValues(renderer, &logical_w, &logical_h, &viewport, &scale);
757 if (logical_w) {
758 event->button.x -= (int)(viewport.x * renderer->dpi_scale.x);
759 event->button.y -= (int)(viewport.y * renderer->dpi_scale.y);
760 event->button.x = (int)(event->button.x / (scale.x * renderer->dpi_scale.x));
761 event->button.y = (int)(event->button.y / (scale.y * renderer->dpi_scale.y));
762 }
763 }
764 } else if (event->type == SDL_FINGERDOWN ||
765 event->type == SDL_FINGERUP ||
766 event->type == SDL_FINGERMOTION) {
767 int logical_w, logical_h;
770 GetWindowViewportValues(renderer, &logical_w, &logical_h, &viewport, &scale);
771 if (logical_w) {
772 int w = 1;
773 int h = 1;
775
776 event->tfinger.x *= (w - 1);
777 event->tfinger.y *= (h - 1);
778
779 event->tfinger.x -= (viewport.x * renderer->dpi_scale.x);
780 event->tfinger.y -= (viewport.y * renderer->dpi_scale.y);
781 event->tfinger.x = (event->tfinger.x / (scale.x * renderer->dpi_scale.x));
782 event->tfinger.y = (event->tfinger.y / (scale.y * renderer->dpi_scale.y));
783
784 if (logical_w > 1) {
785 event->tfinger.x = event->tfinger.x / (logical_w - 1);
786 } else {
787 event->tfinger.x = 0.5f;
788 }
789 if (logical_h > 1) {
790 event->tfinger.y = event->tfinger.y / (logical_h - 1);
791 } else {
792 event->tfinger.y = 0.5f;
793 }
794 }
795 }
796
797 return 0;
798}
#define SDL_GetWindowFromID
@ SDL_MOUSEMOTION
Definition: SDL_events.h:105
@ SDL_FINGERMOTION
Definition: SDL_events.h:130
@ SDL_MOUSEBUTTONUP
Definition: SDL_events.h:107
@ SDL_WINDOWEVENT
Definition: SDL_events.h:92
@ SDL_FINGERUP
Definition: SDL_events.h:129
@ SDL_MOUSEBUTTONDOWN
Definition: SDL_events.h:106
@ SDL_FINGERDOWN
Definition: SDL_events.h:128
struct _cl_event * event
static int UpdateLogicalSize(SDL_Renderer *renderer)
Definition: SDL_render.c:1918
int SDL_GetRendererOutputSize(SDL_Renderer *renderer, int *w, int *h)
Get the output size in pixels of a rendering context.
Definition: SDL_render.c:1022
static void GetWindowViewportValues(SDL_Renderer *renderer, int *logical_w, int *logical_h, SDL_Rect *viewport, SDL_FPoint *scale)
Definition: SDL_render.c:651
SDL_Texture * SDL_GetRenderTarget(SDL_Renderer *renderer)
Get the current render target or NULL for the default render target.
Definition: SDL_render.c:1912
@ SDL_WINDOWEVENT_HIDDEN
Definition: SDL_video.h:150
@ SDL_WINDOWEVENT_SHOWN
Definition: SDL_video.h:149
@ SDL_WINDOWEVENT_MINIMIZED
Definition: SDL_video.h:159
@ SDL_WINDOWEVENT_MAXIMIZED
Definition: SDL_video.h:160
@ SDL_WINDOWEVENT_SIZE_CHANGED
Definition: SDL_video.h:156
@ SDL_WINDOWEVENT_RESTORED
Definition: SDL_video.h:161
void(* WindowEvent)(SDL_Renderer *renderer, const SDL_WindowEvent *event)
The type used to identify a window.
Definition: SDL_sysvideo.h:74

References SDL_Renderer::dpi_scale, FlushRenderCommandsIfNotBatching(), SDL_Renderer::GetOutputSize, GetWindowViewportValues(), SDL_Rect::h, SDL_Renderer::hidden, SDL_Renderer::logical_w, NULL, QueueCmdSetViewport(), renderer, SDL_FALSE, SDL_FINGERDOWN, SDL_FINGERMOTION, SDL_FINGERUP, SDL_GetRendererOutputSize(), SDL_GetRenderTarget(), SDL_GetWindowFlags, SDL_GetWindowFromID, SDL_GetWindowSize, SDL_max, SDL_min, SDL_MOUSEBUTTONDOWN, SDL_MOUSEBUTTONUP, SDL_MOUSEMOTION, SDL_SetRenderTarget(), SDL_TRUE, 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_FPoint::y, and SDL_Rect::y.

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
rendererThe renderer which should fill a rectangle.
rectA pointer to the destination rectangle, or NULL for the entire rendering target.
Returns
0 on success, or -1 on error

Definition at line 2726 of file SDL_render.c.

2727{
2728 SDL_FRect frect;
2729
2731
2732 /* If 'rect' == NULL, then outline the whole surface */
2733 if (rect) {
2734 frect.x = (float) rect->x;
2735 frect.y = (float) rect->y;
2736 frect.w = (float) rect->w;
2737 frect.h = (float) rect->h;
2738 } else {
2739 SDL_Rect r;
2740 SDL_zero(r);
2742 frect.x = 0.0f;
2743 frect.y = 0.0f;
2744 frect.w = (float) r.w;
2745 frect.h = (float) r.h;
2746 }
2747 return SDL_RenderFillRectsF(renderer, &frect, 1);
2748}
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.
Definition: SDL_render.c:2813

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
rendererThe renderer which should fill a rectangle.
rectA pointer to the destination rectangle, or NULL for the entire rendering target.
Returns
0 on success, or -1 on error

Definition at line 2751 of file SDL_render.c.

2752{
2753 SDL_FRect frect;
2754
2756
2757 /* If 'rect' == NULL, then outline the whole surface */
2758 if (!rect) {
2759 SDL_Rect r;
2760 SDL_zero(r);
2762 frect.x = 0.0f;
2763 frect.y = 0.0f;
2764 frect.w = (float) r.w;
2765 frect.h = (float) r.h;
2766 rect = &frect;
2767 }
2769}

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
rendererThe renderer which should fill multiple rectangles.
rectsA pointer to an array of destination rectangles.
countThe number of rectangles.
Returns
0 on success, or -1 on error

Definition at line 2772 of file SDL_render.c.

2774{
2775 SDL_FRect *frects;
2776 int i;
2777 int retval;
2778 SDL_bool isstack;
2779
2781
2782 if (!rects) {
2783 return SDL_SetError("SDL_RenderFillRects(): Passed NULL rects");
2784 }
2785 if (count < 1) {
2786 return 0;
2787 }
2788
2789 /* Don't draw while we're hidden */
2790 if (renderer->hidden) {
2791 return 0;
2792 }
2793
2794 frects = SDL_small_alloc(SDL_FRect, count, &isstack);
2795 if (!frects) {
2796 return SDL_OutOfMemory();
2797 }
2798 for (i = 0; i < count; ++i) {
2799 frects[i].x = rects[i].x * renderer->scale.x;
2800 frects[i].y = rects[i].y * renderer->scale.y;
2801 frects[i].w = rects[i].w * renderer->scale.x;
2802 frects[i].h = rects[i].h * renderer->scale.y;
2803 }
2804
2806
2807 SDL_small_free(frects, isstack);
2808
2810}

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
rendererThe renderer which should fill multiple rectangles.
rectsA pointer to an array of destination rectangles.
countThe number of rectangles.
Returns
0 on success, or -1 on error

Definition at line 2813 of file SDL_render.c.

2815{
2816 SDL_FRect *frects;
2817 int i;
2818 int retval;
2819 SDL_bool isstack;
2820
2822
2823 if (!rects) {
2824 return SDL_SetError("SDL_RenderFillFRects(): Passed NULL rects");
2825 }
2826 if (count < 1) {
2827 return 0;
2828 }
2829
2830 /* Don't draw while we're hidden */
2831 if (renderer->hidden) {
2832 return 0;
2833 }
2834
2835 frects = SDL_small_alloc(SDL_FRect, count, &isstack);
2836 if (!frects) {
2837 return SDL_OutOfMemory();
2838 }
2839 for (i = 0; i < count; ++i) {
2840 frects[i].x = rects[i].x * renderer->scale.x;
2841 frects[i].y = rects[i].y * renderer->scale.y;
2842 frects[i].w = rects[i].w * renderer->scale.x;
2843 frects[i].h = rects[i].h * renderer->scale.y;
2844 }
2845
2847
2848 SDL_small_free(frects, isstack);
2849
2851}

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 261 of file SDL_render.c.

262{
264}

References FlushRenderCommands(), and renderer.

◆ SDL_RenderGetClipRect()

void SDL_RenderGetClipRect ( SDL_Renderer renderer,
SDL_Rect rect 
)

Get the clip rectangle for the current target.

Parameters
rendererThe renderer from which clip rectangle should be queried.
rectA pointer filled in with the current clip rectangle, or an empty rectangle if clipping is disabled.
See also
SDL_RenderSetClipRect()

Definition at line 2134 of file SDL_render.c.

2135{
2137
2138 if (rect) {
2139 rect->x = (int)(renderer->clip_rect.x / renderer->scale.x);
2140 rect->y = (int)(renderer->clip_rect.y / renderer->scale.y);
2141 rect->w = (int)(renderer->clip_rect.w / renderer->scale.x);
2142 rect->h = (int)(renderer->clip_rect.h / renderer->scale.y);
2143 }
2144}

References CHECK_RENDERER_MAGIC, SDL_Renderer::clip_rect, SDL_Rect::h, 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
rendererThe renderer from which integer scaling should be queried.
See also
SDL_RenderSetIntegerScale()

Definition at line 2070 of file SDL_render.c.

2071{
2073
2074 return renderer->integer_scale;
2075}
SDL_bool 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
rendererThe renderer from which resolution should be queried.
wA pointer filled with the width of the logical resolution
hA pointer filled with the height of the logical resolution
See also
SDL_RenderSetLogicalSize()

Definition at line 2047 of file SDL_render.c.

2048{
2050
2051 if (w) {
2052 *w = renderer->logical_w;
2053 }
2054 if (h) {
2055 *h = renderer->logical_h;
2056 }
2057}

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
rendererThe 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 3283 of file SDL_render.c.

3284{
3286
3288 FlushRenderCommands(renderer); /* in case the app is going to mess with it. */
3290 }
3291 return NULL;
3292}
void *(* GetMetalCommandEncoder)(SDL_Renderer *renderer)

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
rendererThe renderer to query
Returns
CAMetalLayer* on success, or NULL if the renderer isn't a Metal renderer
See also
SDL_RenderGetMetalCommandEncoder()

Definition at line 3271 of file SDL_render.c.

3272{
3274
3275 if (renderer->GetMetalLayer) {
3276 FlushRenderCommands(renderer); /* in case the app is going to mess with it. */
3278 }
3279 return NULL;
3280}
void *(* GetMetalLayer)(SDL_Renderer *renderer)

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
rendererThe renderer from which drawing scale should be queried.
scaleXA pointer filled in with the horizontal scaling factor
scaleYA pointer filled in with the vertical scaling factor
See also
SDL_RenderSetScale()

Definition at line 2164 of file SDL_render.c.

2165{
2167
2168 if (scaleX) {
2169 *scaleX = renderer->scale.x;
2170 }
2171 if (scaleY) {
2172 *scaleY = renderer->scale.y;
2173 }
2174}

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 2100 of file SDL_render.c.

2101{
2103
2104 if (rect) {
2105 rect->x = (int)(renderer->viewport.x / renderer->scale.x);
2106 rect->y = (int)(renderer->viewport.y / renderer->scale.y);
2107 rect->w = (int)(renderer->viewport.w / renderer->scale.x);
2108 rect->h = (int)(renderer->viewport.h / renderer->scale.y);
2109 }
2110}

References CHECK_RENDERER_MAGIC, SDL_Rect::h, 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
rendererThe renderer from which clip state should be queried.
See also
SDL_RenderGetClipRect()

Definition at line 2147 of file SDL_render.c.

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 3126 of file SDL_render.c.

3127{
3129
3130 FlushRenderCommands(renderer); /* time to send everything to the GPU! */
3131
3132 /* Don't present while we're hidden */
3133 if (renderer->hidden) {
3134 return;
3135 }
3137}
void(* RenderPresent)(SDL_Renderer *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
rendererThe renderer from which pixels should be read.
rectA pointer to the rectangle to read, or NULL for the entire render target.
formatThe desired format of the pixel data, or 0 to use the format of the rendering target
pixelsA pointer to be filled in with the pixel data
pitchThe 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 3087 of file SDL_render.c.

3089{
3090 SDL_Rect real_rect;
3091
3093
3094 if (!renderer->RenderReadPixels) {
3095 return SDL_Unsupported();
3096 }
3097
3098 FlushRenderCommands(renderer); /* we need to render before we read the results. */
3099
3100 if (!format) {
3102 }
3103
3104 real_rect.x = renderer->viewport.x;
3105 real_rect.y = renderer->viewport.y;
3106 real_rect.w = renderer->viewport.w;
3107 real_rect.h = renderer->viewport.h;
3108 if (rect) {
3109 if (!SDL_IntersectRect(rect, &real_rect, &real_rect)) {
3110 return 0;
3111 }
3112 if (real_rect.y > rect->y) {
3113 pixels = (Uint8 *)pixels + pitch * (real_rect.y - rect->y);
3114 }
3115 if (real_rect.x > rect->x) {
3116 int bpp = SDL_BYTESPERPIXEL(format);
3117 pixels = (Uint8 *)pixels + bpp * (real_rect.x - rect->x);
3118 }
3119 }
3120
3121 return renderer->RenderReadPixels(renderer, &real_rect,
3122 format, pixels, pitch);
3123}
#define SDL_GetWindowPixelFormat
int(* RenderReadPixels)(SDL_Renderer *renderer, const SDL_Rect *rect, Uint32 format, void *pixels, int pitch)

References 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
rendererThe renderer for which clip rectangle should be set.
rectA pointer to the rectangle to set as the clip rectangle, or NULL to disable clipping.
Returns
0 on success, or -1 on error
See also
SDL_RenderGetClipRect()

Definition at line 2113 of file SDL_render.c.

2114{
2115 int retval;
2117
2118 if (rect) {
2124 } else {
2127 }
2128
2131}
#define SDL_floor
#define SDL_ceil

References CHECK_RENDERER_MAGIC, SDL_Renderer::clip_rect, SDL_Renderer::clipping_enabled, FlushRenderCommandsIfNotBatching(), SDL_Rect::h, 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
rendererThe renderer for which integer scaling should be set.
enableEnable 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 2060 of file SDL_render.c.

2061{
2063
2065
2067}
GLboolean enable

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
rendererThe renderer for which resolution should be set.
wThe width of the logical resolution
hThe 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 2027 of file SDL_render.c.

2028{
2030
2031 if (!w || !h) {
2032 /* Clear any previous logical resolution */
2033 renderer->logical_w = 0;
2034 renderer->logical_h = 0;
2036 SDL_RenderSetScale(renderer, 1.0f, 1.0f);
2037 return 0;
2038 }
2039
2040 renderer->logical_w = w;
2041 renderer->logical_h = h;
2042
2044}
int SDL_RenderSetScale(SDL_Renderer *renderer, float scaleX, float scaleY)
Set the drawing scale for rendering on the current target.
Definition: SDL_render.c:2154

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
rendererThe renderer for which the drawing scale should be set.
scaleXThe horizontal scaling factor
scaleYThe 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 2154 of file SDL_render.c.

2155{
2157
2158 renderer->scale.x = scaleX;
2159 renderer->scale.y = scaleY;
2160 return 0;
2161}

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
rendererThe renderer for which the drawing area should be set.
rectThe 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 2078 of file SDL_render.c.

2079{
2080 int retval;
2082
2083 if (rect) {
2088 } else {
2089 renderer->viewport.x = 0;
2090 renderer->viewport.y = 0;
2092 return -1;
2093 }
2094 }
2097}

References CHECK_RENDERER_MAGIC, FlushRenderCommandsIfNotBatching(), SDL_Rect::h, 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
rendererThe renderer that will be checked
Returns
SDL_TRUE if supported, SDL_FALSE if not.

Definition at line 1824 of file SDL_render.c.

1825{
1826 if (!renderer || !renderer->SetRenderTarget) {
1827 return SDL_FALSE;
1828 }
1830}
@ SDL_RENDERER_TARGETTEXTURE
Definition: SDL_render.h:71
int(* SetRenderTarget)(SDL_Renderer *renderer, SDL_Texture *texture)

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
rendererThe renderer for which blend mode should be set.
blendModeSDL_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 2211 of file SDL_render.c.

2212{
2214
2216 return SDL_Unsupported();
2217 }
2219 return 0;
2220}
static SDL_bool IsSupportedBlendMode(SDL_Renderer *renderer, SDL_BlendMode blendMode)
Definition: SDL_render.c:1040

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
rendererThe renderer for which drawing color should be set.
rThe red value used to draw on the rendering target.
gThe green value used to draw on the rendering target.
bThe blue value used to draw on the rendering target.
aThe 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 2177 of file SDL_render.c.

2179{
2181
2182 renderer->r = r;
2183 renderer->g = g;
2184 renderer->b = b;
2185 renderer->a = a;
2186 return 0;
2187}

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
rendererThe renderer.
textureThe 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 1833 of file SDL_render.c.

1834{
1836 return SDL_Unsupported();
1837 }
1838 if (texture == renderer->target) {
1839 /* Nothing to do! */
1840 return 0;
1841 }
1842
1843 FlushRenderCommands(renderer); /* time to send everything to the GPU! */
1844
1845 /* texture == NULL is valid and means reset the target to the window */
1846 if (texture) {
1848 if (renderer != texture->renderer) {
1849 return SDL_SetError("Texture was not created with this renderer");
1850 }
1851 if (texture->access != SDL_TEXTUREACCESS_TARGET) {
1852 return SDL_SetError("Texture not created with SDL_TEXTUREACCESS_TARGET");
1853 }
1854 if (texture->native) {
1855 /* Always render to the native texture */
1856 texture = texture->native;
1857 }
1858 }
1859
1861
1862 if (texture && !renderer->target) {
1863 /* Make a backup of the viewport */
1870 }
1872
1875 return -1;
1876 }
1877
1878 if (texture) {
1879 renderer->viewport.x = 0;
1880 renderer->viewport.y = 0;
1881 renderer->viewport.w = texture->w;
1882 renderer->viewport.h = texture->h;
1885 renderer->scale.x = 1.0f;
1886 renderer->scale.y = 1.0f;
1889 } else {
1896 }
1897
1899
1900 if (QueueCmdSetViewport(renderer) < 0) {
1901 return -1;
1902 }
1903 if (QueueCmdSetClipRect(renderer) < 0) {
1904 return -1;
1905 }
1906
1907 /* All set! */
1909}
SDL_bool SDL_RenderTargetSupported(SDL_Renderer *renderer)
Determines whether a window supports the use of render targets.
Definition: SDL_render.c:1824
@ SDL_TEXTUREACCESS_TARGET
Definition: SDL_render.h:95
SDL_Rect clip_rect_backup
SDL_bool clipping_enabled_backup

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
textureThe texture to update.
alphaThe 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 1411 of file SDL_render.c.

1412{
1414
1415 if (alpha < 255) {
1417 } else {
1418 texture->modMode &= ~SDL_TEXTUREMODULATE_ALPHA;
1419 }
1420 texture->a = alpha;
1421 if (texture->native) {
1422 return SDL_SetTextureAlphaMod(texture->native, alpha);
1423 }
1424 return 0;
1425}
@ SDL_TEXTUREMODULATE_ALPHA
Definition: SDL_render.h:105

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
textureThe texture to update.
blendModeSDL_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 1439 of file SDL_render.c.

1440{
1442
1444
1445 renderer = texture->renderer;
1447 return SDL_Unsupported();
1448 }
1449 texture->blendMode = blendMode;
1450 if (texture->native) {
1451 return SDL_SetTextureBlendMode(texture->native, blendMode);
1452 }
1453 return 0;
1454}

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
textureThe texture to update.
rThe red color value multiplied into copy operations.
gThe green color value multiplied into copy operations.
bThe 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 1374 of file SDL_render.c.

1375{
1377
1378 if (r < 255 || g < 255 || b < 255) {
1380 } else {
1381 texture->modMode &= ~SDL_TEXTUREMODULATE_COLOR;
1382 }
1383 texture->r = r;
1384 texture->g = g;
1385 texture->b = b;
1386 if (texture->native) {
1387 return SDL_SetTextureColorMod(texture->native, r, g, b);
1388 }
1389 return 0;
1390}
@ SDL_TEXTUREMODULATE_COLOR
Definition: SDL_render.h:104

References CHECK_TEXTURE_MAGIC, SDL_SetTextureColorMod(), and SDL_TEXTUREMODULATE_COLOR.

Referenced by SDL_CreateTextureFromSurface(), and SDL_SetTextureColorMod().

◆ SDL_UnlockTexture()

void SDL_UnlockTexture ( SDL_Texture texture)

Unlock a texture, uploading the changes to video memory, if needed.

See also
SDL_LockTexture()

Definition at line 1806 of file SDL_render.c.

1807{
1809
1810 if (texture->access != SDL_TEXTUREACCESS_STREAMING) {
1811 return;
1812 }
1813 if (texture->yuv) {
1815 } else if (texture->native) {
1817 } else {
1818 SDL_Renderer *renderer = texture->renderer;
1820 }
1821}
static void SDL_UnlockTextureNative(SDL_Texture *texture)
Definition: SDL_render.c:1785
static void SDL_UnlockTextureYUV(SDL_Texture *texture)
Definition: SDL_render.c:1764
void(* UnlockTexture)(SDL_Renderer *renderer, SDL_Texture *texture)

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

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

◆ SDL_UnlockTextureNative()

static void SDL_UnlockTextureNative ( SDL_Texture texture)
static

Definition at line 1785 of file SDL_render.c.

1786{
1787 SDL_Texture *native = texture->native;
1788 void *native_pixels = NULL;
1789 int native_pitch = 0;
1790 const SDL_Rect *rect = &texture->locked_rect;
1791 const void* pixels = (void *) ((Uint8 *) texture->pixels +
1792 rect->y * texture->pitch +
1793 rect->x * SDL_BYTESPERPIXEL(texture->format));
1794 int pitch = texture->pitch;
1795
1796 if (SDL_LockTexture(native, rect, &native_pixels, &native_pitch) < 0) {
1797 return;
1798 }
1800 texture->format, pixels, pitch,
1801 native->format, native_pixels, native_pitch);
1802 SDL_UnlockTexture(native);
1803}
#define SDL_ConvertPixels
void SDL_UnlockTexture(SDL_Texture *texture)
Unlock a texture, uploading the changes to video memory, if needed.
Definition: SDL_render.c:1806
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.
Definition: SDL_render.c:1727
Uint32 format
Definition: SDL_sysrender.h:46
SDL_Texture * native
Definition: SDL_sysrender.h:58

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 1764 of file SDL_render.c.

1765{
1766 SDL_Texture *native = texture->native;
1767 void *native_pixels = NULL;
1768 int native_pitch = 0;
1769 SDL_Rect rect;
1770
1771 rect.x = 0;
1772 rect.y = 0;
1773 rect.w = texture->w;
1774 rect.h = texture->h;
1775
1776 if (SDL_LockTexture(native, &rect, &native_pixels, &native_pitch) < 0) {
1777 return;
1778 }
1779 SDL_SW_CopyYUVToRGB(texture->yuv, &rect, native->format,
1780 rect.w, rect.h, native_pixels, native_pitch);
1781 SDL_UnlockTexture(native);
1782}
int SDL_SW_CopyYUVToRGB(SDL_SW_YUVTexture *swdata, const SDL_Rect *srcrect, Uint32 target_format, int w, int h, void *pixels, int pitch)
Definition: SDL_yuv_sw.c:334

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
textureThe texture to update
rectA pointer to the rectangle of pixels to update, or NULL to update the entire texture.
pixelsThe raw pixel data in the format of the texture.
pitchThe 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 1555 of file SDL_render.c.

1557{
1558 SDL_Rect full_rect;
1559
1561
1562 if (!pixels) {
1563 return SDL_InvalidParamError("pixels");
1564 }
1565 if (!pitch) {
1566 return SDL_InvalidParamError("pitch");
1567 }
1568
1569 if (!rect) {
1570 full_rect.x = 0;
1571 full_rect.y = 0;
1572 full_rect.w = texture->w;
1573 full_rect.h = texture->h;
1574 rect = &full_rect;
1575 }
1576
1577 if ((rect->w == 0) || (rect->h == 0)) {
1578 return 0; /* nothing to do. */
1579 } else if (texture->yuv) {
1580 return SDL_UpdateTextureYUV(texture, rect, pixels, pitch);
1581 } else if (texture->native) {
1582 return SDL_UpdateTextureNative(texture, rect, pixels, pitch);
1583 } else {
1584 SDL_Renderer *renderer = texture->renderer;
1586 return -1;
1587 }
1588 return renderer->UpdateTexture(renderer, texture, rect, pixels, pitch);
1589 }
1590}
static int SDL_UpdateTextureNative(SDL_Texture *texture, const SDL_Rect *rect, const void *pixels, int pitch)
Definition: SDL_render.c:1514
static int SDL_UpdateTextureYUV(SDL_Texture *texture, const SDL_Rect *rect, const void *pixels, int pitch)
Definition: SDL_render.c:1468
int(* UpdateTexture)(SDL_Renderer *renderer, SDL_Texture *texture, const SDL_Rect *rect, const void *pixels, int 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 1514 of file SDL_render.c.

1516{
1517 SDL_Texture *native = texture->native;
1518
1519 if (!rect->w || !rect->h) {
1520 return 0; /* nothing to do. */
1521 }
1522
1523 if (texture->access == SDL_TEXTUREACCESS_STREAMING) {
1524 /* We can lock the texture and copy to it */
1525 void *native_pixels = NULL;
1526 int native_pitch = 0;
1527
1528 if (SDL_LockTexture(native, rect, &native_pixels, &native_pitch) < 0) {
1529 return -1;
1530 }
1532 texture->format, pixels, pitch,
1533 native->format, native_pixels, native_pitch);
1534 SDL_UnlockTexture(native);
1535 } else {
1536 /* Use a temporary buffer for updating */
1537 const int temp_pitch = (((rect->w * SDL_BYTESPERPIXEL(native->format)) + 3) & ~3);
1538 const size_t alloclen = rect->h * temp_pitch;
1539 if (alloclen > 0) {
1540 void *temp_pixels = SDL_malloc(alloclen);
1541 if (!temp_pixels) {
1542 return SDL_OutOfMemory();
1543 }
1545 texture->format, pixels, pitch,
1546 native->format, temp_pixels, temp_pitch);
1547 SDL_UpdateTexture(native, rect, temp_pixels, temp_pitch);
1548 SDL_free(temp_pixels);
1549 }
1550 }
1551 return 0;
1552}

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 1468 of file SDL_render.c.

1470{
1471 SDL_Texture *native = texture->native;
1472 SDL_Rect full_rect;
1473
1474 if (SDL_SW_UpdateYUVTexture(texture->yuv, rect, pixels, pitch) < 0) {
1475 return -1;
1476 }
1477
1478 full_rect.x = 0;
1479 full_rect.y = 0;
1480 full_rect.w = texture->w;
1481 full_rect.h = texture->h;
1482 rect = &full_rect;
1483
1484 if (texture->access == SDL_TEXTUREACCESS_STREAMING) {
1485 /* We can lock the texture and copy to it */
1486 void *native_pixels = NULL;
1487 int native_pitch = 0;
1488
1489 if (SDL_LockTexture(native, rect, &native_pixels, &native_pitch) < 0) {
1490 return -1;
1491 }
1492 SDL_SW_CopyYUVToRGB(texture->yuv, rect, native->format,
1493 rect->w, rect->h, native_pixels, native_pitch);
1494 SDL_UnlockTexture(native);
1495 } else {
1496 /* Use a temporary buffer for updating */
1497 const int temp_pitch = (((rect->w * SDL_BYTESPERPIXEL(native->format)) + 3) & ~3);
1498 const size_t alloclen = rect->h * temp_pitch;
1499 if (alloclen > 0) {
1500 void *temp_pixels = SDL_malloc(alloclen);
1501 if (!temp_pixels) {
1502 return SDL_OutOfMemory();
1503 }
1504 SDL_SW_CopyYUVToRGB(texture->yuv, rect, native->format,
1505 rect->w, rect->h, temp_pixels, temp_pitch);
1506 SDL_UpdateTexture(native, rect, temp_pixels, temp_pitch);
1507 SDL_free(temp_pixels);
1508 }
1509 }
1510 return 0;
1511}
int SDL_SW_UpdateYUVTexture(SDL_SW_YUVTexture *swdata, const SDL_Rect *rect, const void *pixels, int pitch)
Definition: SDL_yuv_sw.c:139

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 1593 of file SDL_render.c.

1597{
1598 SDL_Texture *native = texture->native;
1599 SDL_Rect full_rect;
1600
1601 if (SDL_SW_UpdateYUVTexturePlanar(texture->yuv, rect, Yplane, Ypitch, Uplane, Upitch, Vplane, Vpitch) < 0) {
1602 return -1;
1603 }
1604
1605 full_rect.x = 0;
1606 full_rect.y = 0;
1607 full_rect.w = texture->w;
1608 full_rect.h = texture->h;
1609 rect = &full_rect;
1610
1611 if (!rect->w || !rect->h) {
1612 return 0; /* nothing to do. */
1613 }
1614
1615 if (texture->access == SDL_TEXTUREACCESS_STREAMING) {
1616 /* We can lock the texture and copy to it */
1617 void *native_pixels = NULL;
1618 int native_pitch = 0;
1619
1620 if (SDL_LockTexture(native, rect, &native_pixels, &native_pitch) < 0) {
1621 return -1;
1622 }
1623 SDL_SW_CopyYUVToRGB(texture->yuv, rect, native->format,
1624 rect->w, rect->h, native_pixels, native_pitch);
1625 SDL_UnlockTexture(native);
1626 } else {
1627 /* Use a temporary buffer for updating */
1628 const int temp_pitch = (((rect->w * SDL_BYTESPERPIXEL(native->format)) + 3) & ~3);
1629 const size_t alloclen = rect->h * temp_pitch;
1630 if (alloclen > 0) {
1631 void *temp_pixels = SDL_malloc(alloclen);
1632 if (!temp_pixels) {
1633 return SDL_OutOfMemory();
1634 }
1635 SDL_SW_CopyYUVToRGB(texture->yuv, rect, native->format,
1636 rect->w, rect->h, temp_pixels, temp_pitch);
1637 SDL_UpdateTexture(native, rect, temp_pixels, temp_pitch);
1638 SDL_free(temp_pixels);
1639 }
1640 }
1641 return 0;
1642}
int SDL_SW_UpdateYUVTexturePlanar(SDL_SW_YUVTexture *swdata, const SDL_Rect *rect, const Uint8 *Yplane, int Ypitch, const Uint8 *Uplane, int Upitch, const Uint8 *Vplane, int Vpitch)
Definition: SDL_yuv_sw.c:247

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
textureThe texture to update
rectA pointer to the rectangle of pixels to update, or NULL to update the entire texture.
YplaneThe raw pixel data for the Y plane.
YpitchThe number of bytes between rows of pixel data for the Y plane.
UplaneThe raw pixel data for the U plane.
UpitchThe number of bytes between rows of pixel data for the U plane.
VplaneThe raw pixel data for the V plane.
VpitchThe 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 1644 of file SDL_render.c.

1648{
1650 SDL_Rect full_rect;
1651
1653
1654 if (!Yplane) {
1655 return SDL_InvalidParamError("Yplane");
1656 }
1657 if (!Ypitch) {
1658 return SDL_InvalidParamError("Ypitch");
1659 }
1660 if (!Uplane) {
1661 return SDL_InvalidParamError("Uplane");
1662 }
1663 if (!Upitch) {
1664 return SDL_InvalidParamError("Upitch");
1665 }
1666 if (!Vplane) {
1667 return SDL_InvalidParamError("Vplane");
1668 }
1669 if (!Vpitch) {
1670 return SDL_InvalidParamError("Vpitch");
1671 }
1672
1673 if (texture->format != SDL_PIXELFORMAT_YV12 &&
1674 texture->format != SDL_PIXELFORMAT_IYUV) {
1675 return SDL_SetError("Texture format must by YV12 or IYUV");
1676 }
1677
1678 if (!rect) {
1679 full_rect.x = 0;
1680 full_rect.y = 0;
1681 full_rect.w = texture->w;
1682 full_rect.h = texture->h;
1683 rect = &full_rect;
1684 }
1685
1686 if (!rect->w || !rect->h) {
1687 return 0; /* nothing to do. */
1688 }
1689
1690 if (texture->yuv) {
1691 return SDL_UpdateTextureYUVPlanar(texture, rect, Yplane, Ypitch, Uplane, Upitch, Vplane, Vpitch);
1692 } else {
1693 SDL_assert(!texture->native);
1694 renderer = texture->renderer;
1698 return -1;
1699 }
1700 return renderer->UpdateTextureYUV(renderer, texture, rect, Yplane, Ypitch, Uplane, Upitch, Vplane, Vpitch);
1701 } else {
1702 return SDL_Unsupported();
1703 }
1704 }
1705}
@ SDL_PIXELFORMAT_YV12
Definition: SDL_pixels.h:277
@ SDL_PIXELFORMAT_IYUV
Definition: SDL_pixels.h:279
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)
Definition: SDL_render.c:1593
int(* UpdateTextureYUV)(SDL_Renderer *renderer, SDL_Texture *texture, const SDL_Rect *rect, const Uint8 *Yplane, int Ypitch, const Uint8 *Uplane, int Upitch, const Uint8 *Vplane, int Vpitch)

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 1918 of file SDL_render.c.

1919{
1920 int w = 1, h = 1;
1921 float want_aspect;
1922 float real_aspect;
1923 float scale;
1925 /* 0 is for letterbox, 1 is for overscan */
1926 int scale_policy = 0;
1927 const char *hint;
1928
1929 if (!renderer->logical_w || !renderer->logical_h) {
1930 return 0;
1931 }
1932 if (SDL_GetRendererOutputSize(renderer, &w, &h) < 0) {
1933 return -1;
1934 }
1935
1937 if (hint && (*hint == '1' || SDL_strcasecmp(hint, "overscan") == 0)) {
1938#if SDL_VIDEO_RENDER_D3D
1939 SDL_bool overscan_supported = SDL_TRUE;
1940 /* Unfortunately, Direct3D 9 doesn't support negative viewport numbers
1941 which the overscan implementation relies on.
1942 */
1943 if (SDL_strcasecmp(SDL_GetCurrentVideoDriver(), "direct3d") == 0) {
1944 overscan_supported = SDL_FALSE;
1945 }
1946 if (overscan_supported) {
1947 scale_policy = 1;
1948 }
1949#else
1950 scale_policy = 1;
1951#endif
1952 }
1953
1954 want_aspect = (float)renderer->logical_w / renderer->logical_h;
1955 real_aspect = (float)w / h;
1956
1957 /* Clear the scale because we're setting viewport in output coordinates */
1958 SDL_RenderSetScale(renderer, 1.0f, 1.0f);
1959
1960 if (renderer->integer_scale) {
1961 if (want_aspect > real_aspect) {
1962 scale = (float)(w / renderer->logical_w);
1963 } else {
1964 scale = (float)(h / renderer->logical_h);
1965 }
1967 viewport.x = (w - viewport.w) / 2;
1969 viewport.y = (h - viewport.h) / 2;
1970
1972 } else if (SDL_fabs(want_aspect-real_aspect) < 0.0001) {
1973 /* The aspect ratios are the same, just scale appropriately */
1974 scale = (float)w / renderer->logical_w;
1976 } else if (want_aspect > real_aspect) {
1977 if (scale_policy == 1) {
1978 /* We want a wider aspect ratio than is available -
1979 zoom so logical height matches the real height
1980 and the width will grow off the screen
1981 */
1982 scale = (float)h / renderer->logical_h;
1983 viewport.y = 0;
1984 viewport.h = h;
1986 viewport.x = (w - viewport.w) / 2;
1988 } else {
1989 /* We want a wider aspect ratio than is available - letterbox it */
1990 scale = (float)w / renderer->logical_w;
1991 viewport.x = 0;
1992 viewport.w = w;
1994 viewport.y = (h - viewport.h) / 2;
1996 }
1997 } else {
1998 if (scale_policy == 1) {
1999 /* We want a narrower aspect ratio than is available -
2000 zoom so logical width matches the real width
2001 and the height will grow off the screen
2002 */
2003 scale = (float)w / renderer->logical_w;
2004 viewport.x = 0;
2005 viewport.w = w;
2007 viewport.y = (h - viewport.h) / 2;
2009 } else {
2010 /* We want a narrower aspect ratio than is available - use side-bars */
2011 scale = (float)h / renderer->logical_h;
2012 viewport.y = 0;
2013 viewport.h = h;
2015 viewport.x = (w - viewport.w) / 2;
2017 }
2018 }
2019
2020 /* Set the new scale */
2022
2023 return 0;
2024}
#define SDL_GetCurrentVideoDriver
#define SDL_fabs
#define SDL_HINT_RENDER_LOGICAL_SIZE_MODE
A variable controlling the scaling policy for SDL_RenderSetLogicalSize.
Definition: SDL_hints.h:131

References SDL_Rect::h, 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

Variable Documentation

◆ render_drivers

const SDL_RenderDriver* render_drivers[]
static
Initial value:
= {
}
SDL_RenderDriver SW_RenderDriver

Definition at line 79 of file SDL_render.c.

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

◆ renderer_magic

char renderer_magic
static

Definition at line 108 of file SDL_render.c.

Referenced by SDL_CreateRenderer(), and SDL_CreateSoftwareRenderer().

◆ texture_magic

char texture_magic
static

Definition at line 109 of file SDL_render.c.

Referenced by SDL_CreateTexture().