SDL  2.0
SDL_render.c
Go to the documentation of this file.
1 /*
2  Simple DirectMedia Layer
3  Copyright (C) 1997-2018 Sam Lantinga <slouken@libsdl.org>
4 
5  This software is provided 'as-is', without any express or implied
6  warranty. In no event will the authors be held liable for any damages
7  arising from the use of this software.
8 
9  Permission is granted to anyone to use this software for any purpose,
10  including commercial applications, and to alter it and redistribute it
11  freely, subject to the following restrictions:
12 
13  1. The origin of this software must not be misrepresented; you must not
14  claim that you wrote the original software. If you use this software
15  in a product, an acknowledgment in the product documentation would be
16  appreciated but is not required.
17  2. Altered source versions must be plainly marked as such, and must not be
18  misrepresented as being the original software.
19  3. This notice may not be removed or altered from any source distribution.
20 */
21 #include "../SDL_internal.h"
22 
23 /* The SDL 2D rendering system */
24 
25 #include "SDL_assert.h"
26 #include "SDL_hints.h"
27 #include "SDL_log.h"
28 #include "SDL_render.h"
29 #include "SDL_sysrender.h"
31 
32 
33 #define SDL_WINDOWRENDERDATA "_SDL_WindowRenderData"
34 
35 #define CHECK_RENDERER_MAGIC(renderer, retval) \
36  SDL_assert(renderer && renderer->magic == &renderer_magic); \
37  if (!renderer || renderer->magic != &renderer_magic) { \
38  SDL_SetError("Invalid renderer"); \
39  return retval; \
40  }
41 
42 #define CHECK_TEXTURE_MAGIC(texture, retval) \
43  SDL_assert(texture && texture->magic == &texture_magic); \
44  if (!texture || texture->magic != &texture_magic) { \
45  SDL_SetError("Invalid texture"); \
46  return retval; \
47  }
48 
49 /* Predefined blend modes */
50 #define SDL_COMPOSE_BLENDMODE(srcColorFactor, dstColorFactor, colorOperation, \
51  srcAlphaFactor, dstAlphaFactor, alphaOperation) \
52  (SDL_BlendMode)(((Uint32)colorOperation << 0) | \
53  ((Uint32)srcColorFactor << 4) | \
54  ((Uint32)dstColorFactor << 8) | \
55  ((Uint32)alphaOperation << 16) | \
56  ((Uint32)srcAlphaFactor << 20) | \
57  ((Uint32)dstAlphaFactor << 24))
58 
59 #define SDL_BLENDMODE_NONE_FULL \
60  SDL_COMPOSE_BLENDMODE(SDL_BLENDFACTOR_ONE, SDL_BLENDFACTOR_ZERO, SDL_BLENDOPERATION_ADD, \
61  SDL_BLENDFACTOR_ONE, SDL_BLENDFACTOR_ZERO, SDL_BLENDOPERATION_ADD)
62 
63 #define SDL_BLENDMODE_BLEND_FULL \
64  SDL_COMPOSE_BLENDMODE(SDL_BLENDFACTOR_SRC_ALPHA, SDL_BLENDFACTOR_ONE_MINUS_SRC_ALPHA, SDL_BLENDOPERATION_ADD, \
65  SDL_BLENDFACTOR_ONE, SDL_BLENDFACTOR_ONE_MINUS_SRC_ALPHA, SDL_BLENDOPERATION_ADD)
66 
67 #define SDL_BLENDMODE_ADD_FULL \
68  SDL_COMPOSE_BLENDMODE(SDL_BLENDFACTOR_SRC_ALPHA, SDL_BLENDFACTOR_ONE, SDL_BLENDOPERATION_ADD, \
69  SDL_BLENDFACTOR_ZERO, SDL_BLENDFACTOR_ONE, SDL_BLENDOPERATION_ADD)
70 
71 #define SDL_BLENDMODE_MOD_FULL \
72  SDL_COMPOSE_BLENDMODE(SDL_BLENDFACTOR_ZERO, SDL_BLENDFACTOR_SRC_COLOR, SDL_BLENDOPERATION_ADD, \
73  SDL_BLENDFACTOR_ZERO, SDL_BLENDFACTOR_ONE, SDL_BLENDOPERATION_ADD)
74 
75 #if !SDL_RENDER_DISABLED
76 static const SDL_RenderDriver *render_drivers[] = {
77 #if SDL_VIDEO_RENDER_D3D
79 #endif
80 #if SDL_VIDEO_RENDER_D3D11
82 #endif
83 #if SDL_VIDEO_RENDER_OGL
85 #endif
86 #if SDL_VIDEO_RENDER_OGL_ES2
88 #endif
89 #if SDL_VIDEO_RENDER_OGL_ES
91 #endif
92 #if SDL_VIDEO_RENDER_DIRECTFB
94 #endif
95 #if SDL_VIDEO_RENDER_METAL
97 #endif
98 #if SDL_VIDEO_RENDER_PSP
100 #endif
102 };
103 #endif /* !SDL_RENDER_DISABLED */
104 
105 static char renderer_magic;
106 static char texture_magic;
107 
109 
110 int
112 {
113 #if !SDL_RENDER_DISABLED
115 #else
116  return 0;
117 #endif
118 }
119 
120 int
122 {
123 #if !SDL_RENDER_DISABLED
125  return SDL_SetError("index must be in the range of 0 - %d",
127  }
128  *info = render_drivers[index]->info;
129  return 0;
130 #else
131  return SDL_SetError("SDL not built with rendering support");
132 #endif
133 }
134 
135 static void GetWindowViewportValues(SDL_Renderer *renderer, int *logical_w, int *logical_h, SDL_Rect *viewport, SDL_FPoint *scale)
136 {
143 }
144 
145 static int SDLCALL
147 {
148  SDL_Renderer *renderer = (SDL_Renderer *)userdata;
149 
150  if (event->type == SDL_WINDOWEVENT) {
151  SDL_Window *window = SDL_GetWindowFromID(event->window.windowID);
152  if (window == renderer->window) {
153  if (renderer->WindowEvent) {
155  }
156 
157  if (event->window.event == SDL_WINDOWEVENT_SIZE_CHANGED) {
158  /* Make sure we're operating on the default render target */
159  SDL_Texture *saved_target = SDL_GetRenderTarget(renderer);
160  if (saved_target) {
162  }
163 
164  if (renderer->logical_w) {
166  } else {
167  /* Window was resized, reset viewport */
168  int w, h;
169 
170  if (renderer->GetOutputSize) {
172  } else {
174  }
175 
176  if (renderer->target) {
181  } else {
182  renderer->viewport.x = 0;
183  renderer->viewport.y = 0;
184  renderer->viewport.w = w;
185  renderer->viewport.h = h;
187  }
188  }
189 
190  if (saved_target) {
191  SDL_SetRenderTarget(renderer, saved_target);
192  }
193  } else if (event->window.event == SDL_WINDOWEVENT_HIDDEN) {
195  } else if (event->window.event == SDL_WINDOWEVENT_SHOWN) {
198  }
199  } else if (event->window.event == SDL_WINDOWEVENT_MINIMIZED) {
201  } else if (event->window.event == SDL_WINDOWEVENT_RESTORED ||
202  event->window.event == SDL_WINDOWEVENT_MAXIMIZED) {
205  }
206  }
207  }
208  } else if (event->type == SDL_MOUSEMOTION) {
209  SDL_Window *window = SDL_GetWindowFromID(event->motion.windowID);
210  if (window == renderer->window) {
211  int logical_w, logical_h;
214  GetWindowViewportValues(renderer, &logical_w, &logical_h, &viewport, &scale);
215  if (logical_w) {
216  event->motion.x -= (int)(viewport.x * renderer->dpi_scale.x);
217  event->motion.y -= (int)(viewport.y * renderer->dpi_scale.y);
218  event->motion.x = (int)(event->motion.x / (scale.x * renderer->dpi_scale.x));
219  event->motion.y = (int)(event->motion.y / (scale.y * renderer->dpi_scale.y));
220  if (event->motion.xrel > 0) {
221  event->motion.xrel = SDL_max(1, (int)(event->motion.xrel / (scale.x * renderer->dpi_scale.x)));
222  } else if (event->motion.xrel < 0) {
223  event->motion.xrel = SDL_min(-1, (int)(event->motion.xrel / (scale.x * renderer->dpi_scale.x)));
224  }
225  if (event->motion.yrel > 0) {
226  event->motion.yrel = SDL_max(1, (int)(event->motion.yrel / (scale.y * renderer->dpi_scale.y)));
227  } else if (event->motion.yrel < 0) {
228  event->motion.yrel = SDL_min(-1, (int)(event->motion.yrel / (scale.y * renderer->dpi_scale.y)));
229  }
230  }
231  }
232  } else if (event->type == SDL_MOUSEBUTTONDOWN ||
233  event->type == SDL_MOUSEBUTTONUP) {
234  SDL_Window *window = SDL_GetWindowFromID(event->button.windowID);
235  if (window == renderer->window) {
236  int logical_w, logical_h;
239  GetWindowViewportValues(renderer, &logical_w, &logical_h, &viewport, &scale);
240  if (logical_w) {
241  event->button.x -= (int)(viewport.x * renderer->dpi_scale.x);
242  event->button.y -= (int)(viewport.y * renderer->dpi_scale.y);
243  event->button.x = (int)(event->button.x / (scale.x * renderer->dpi_scale.x));
244  event->button.y = (int)(event->button.y / (scale.y * renderer->dpi_scale.y));
245  }
246  }
247  } else if (event->type == SDL_FINGERDOWN ||
248  event->type == SDL_FINGERUP ||
249  event->type == SDL_FINGERMOTION) {
250  int logical_w, logical_h;
253  GetWindowViewportValues(renderer, &logical_w, &logical_h, &viewport, &scale);
254  if (logical_w) {
255  int w = 1;
256  int h = 1;
258 
259  event->tfinger.x *= (w - 1);
260  event->tfinger.y *= (h - 1);
261 
262  event->tfinger.x -= (viewport.x * renderer->dpi_scale.x);
263  event->tfinger.y -= (viewport.y * renderer->dpi_scale.y);
264  event->tfinger.x = (event->tfinger.x / (scale.x * renderer->dpi_scale.x));
265  event->tfinger.y = (event->tfinger.y / (scale.y * renderer->dpi_scale.y));
266 
267  if (logical_w > 1) {
268  event->tfinger.x = event->tfinger.x / (logical_w - 1);
269  } else {
270  event->tfinger.x = 0.5f;
271  }
272  if (logical_h > 1) {
273  event->tfinger.y = event->tfinger.y / (logical_h - 1);
274  } else {
275  event->tfinger.y = 0.5f;
276  }
277  }
278  }
279 
280  return 0;
281 }
282 
283 int
286 {
289  width, height, window_flags);
290  if (!*window) {
291  *renderer = NULL;
292  return -1;
293  }
294 
295  *renderer = SDL_CreateRenderer(*window, -1, 0);
296  if (!*renderer) {
297  return -1;
298  }
299 
300  return 0;
301 }
302 
303 SDL_Renderer *
305 {
306 #if !SDL_RENDER_DISABLED
308  int n = SDL_GetNumRenderDrivers();
309  const char *hint;
310 
311  if (!window) {
312  SDL_SetError("Invalid window");
313  return NULL;
314  }
315 
316  if (SDL_GetRenderer(window)) {
317  SDL_SetError("Renderer already associated with window");
318  return NULL;
319  }
320 
324  } else {
326  }
327  }
328 
329  if (index < 0) {
331  if (hint) {
332  for (index = 0; index < n; ++index) {
333  const SDL_RenderDriver *driver = render_drivers[index];
334 
335  if (SDL_strcasecmp(hint, driver->info.name) == 0) {
336  /* Create a new renderer instance */
337  renderer = driver->CreateRenderer(window, flags);
338  break;
339  }
340  }
341  }
342 
343  if (!renderer) {
344  for (index = 0; index < n; ++index) {
345  const SDL_RenderDriver *driver = render_drivers[index];
346 
347  if ((driver->info.flags & flags) == flags) {
348  /* Create a new renderer instance */
349  renderer = driver->CreateRenderer(window, flags);
350  if (renderer) {
351  /* Yay, we got one! */
352  break;
353  }
354  }
355  }
356  }
357  if (index == n) {
358  SDL_SetError("Couldn't find matching render driver");
359  return NULL;
360  }
361  } else {
362  if (index >= SDL_GetNumRenderDrivers()) {
363  SDL_SetError("index must be -1 or in the range of 0 - %d",
365  return NULL;
366  }
367  /* Create a new renderer instance */
369  }
370 
371  if (renderer) {
375  renderer->scale.x = 1.0f;
376  renderer->scale.y = 1.0f;
377  renderer->dpi_scale.x = 1.0f;
378  renderer->dpi_scale.y = 1.0f;
379 
380  if (window && renderer->GetOutputSize) {
381  int window_w, window_h;
382  int output_w, output_h;
383  if (renderer->GetOutputSize(renderer, &output_w, &output_h) == 0) {
385  renderer->dpi_scale.x = (float)window_w / output_w;
386  renderer->dpi_scale.y = (float)window_h / output_h;
387  }
388  }
389 
392  } else {
394  }
395 
397 
399 
401 
403  "Created renderer: %s", renderer->info.name);
404  }
405  return renderer;
406 #else
407  SDL_SetError("SDL not built with rendering support");
408  return NULL;
409 #endif
410 }
411 
412 SDL_Renderer *
414 {
415 #if !SDL_RENDER_DISABLED
417 
419 
420  if (renderer) {
423  renderer->scale.x = 1.0f;
424  renderer->scale.y = 1.0f;
425 
427  }
428  return renderer;
429 #else
430  SDL_SetError("SDL not built with rendering support");
431  return NULL;
432 #endif /* !SDL_RENDER_DISABLED */
433 }
434 
435 SDL_Renderer *
437 {
439 }
440 
441 int
443 {
445 
446  *info = renderer->info;
447  return 0;
448 }
449 
450 int
452 {
454 
455  if (renderer->target) {
456  return SDL_QueryTexture(renderer->target, NULL, NULL, w, h);
457  } else if (renderer->GetOutputSize) {
458  return renderer->GetOutputSize(renderer, w, h);
459  } else if (renderer->window) {
461  return 0;
462  } else {
463  SDL_assert(0 && "This should never happen");
464  return SDL_SetError("Renderer doesn't support querying output size");
465  }
466 }
467 
468 static SDL_bool
470 {
471  switch (blendMode)
472  {
473  /* These are required to be supported by all renderers */
474  case SDL_BLENDMODE_NONE:
475  case SDL_BLENDMODE_BLEND:
476  case SDL_BLENDMODE_ADD:
477  case SDL_BLENDMODE_MOD:
478  return SDL_TRUE;
479 
480  default:
482  }
483 }
484 
485 static SDL_bool
487 {
488  Uint32 i;
489 
490  for (i = 0; i < renderer->info.num_texture_formats; ++i) {
491  if (renderer->info.texture_formats[i] == format) {
492  return SDL_TRUE;
493  }
494  }
495  return SDL_FALSE;
496 }
497 
498 static Uint32
500 {
501  Uint32 i;
502 
504  /* Look for an exact match */
505  for (i = 0; i < renderer->info.num_texture_formats; ++i) {
506  if (renderer->info.texture_formats[i] == format) {
507  return renderer->info.texture_formats[i];
508  }
509  }
510  } else {
512 
513  /* We just want to match the first format that has the same channels */
514  for (i = 0; i < renderer->info.num_texture_formats; ++i) {
517  return renderer->info.texture_formats[i];
518  }
519  }
520  }
521  return renderer->info.texture_formats[0];
522 }
523 
524 
526 {
527  const char *hint = SDL_GetHint(SDL_HINT_RENDER_SCALE_QUALITY);
528 
529  if (!hint || SDL_strcasecmp(hint, "nearest") == 0) {
530  return SDL_ScaleModeNearest;
531  } else if (SDL_strcasecmp(hint, "linear") == 0) {
532  return SDL_ScaleModeLinear;
533  } else if (SDL_strcasecmp(hint, "best") == 0) {
534  return SDL_ScaleModeBest;
535  } else {
536  return (SDL_ScaleMode)SDL_atoi(hint);
537  }
538 }
539 
540 SDL_Texture *
542 {
544 
546 
547  if (!format) {
549  }
550  if (SDL_BYTESPERPIXEL(format) == 0) {
551  SDL_SetError("Invalid texture format");
552  return NULL;
553  }
555  SDL_SetError("Palettized textures are not supported");
556  return NULL;
557  }
558  if (w <= 0 || h <= 0) {
559  SDL_SetError("Texture dimensions can't be 0");
560  return NULL;
561  }
564  SDL_SetError("Texture dimensions are limited to %dx%d", renderer->info.max_texture_width, renderer->info.max_texture_height);
565  return NULL;
566  }
567  texture = (SDL_Texture *) SDL_calloc(1, sizeof(*texture));
568  if (!texture) {
569  SDL_OutOfMemory();
570  return NULL;
571  }
572  texture->magic = &texture_magic;
573  texture->format = format;
574  texture->access = access;
575  texture->w = w;
576  texture->h = h;
577  texture->r = 255;
578  texture->g = 255;
579  texture->b = 255;
580  texture->a = 255;
581  texture->scaleMode = SDL_GetScaleMode();
582  texture->renderer = renderer;
583  texture->next = renderer->textures;
584  if (renderer->textures) {
586  }
588 
590  if (renderer->CreateTexture(renderer, texture) < 0) {
592  return NULL;
593  }
594  } else {
597  access, w, h);
598  if (!texture->native) {
600  return NULL;
601  }
602 
603  /* Swap textures to have texture before texture->native in the list */
604  texture->native->next = texture->next;
605  if (texture->native->next) {
606  texture->native->next->prev = texture->native;
607  }
608  texture->prev = texture->native->prev;
609  if (texture->prev) {
610  texture->prev->next = texture;
611  }
612  texture->native->prev = texture;
613  texture->next = texture->native;
615 
616  if (SDL_ISPIXELFORMAT_FOURCC(texture->format)) {
618  if (!texture->yuv) {
620  return NULL;
621  }
622  } else if (access == SDL_TEXTUREACCESS_STREAMING) {
623  /* The pitch is 4 byte aligned */
624  texture->pitch = (((w * SDL_BYTESPERPIXEL(format)) + 3) & ~3);
625  texture->pixels = SDL_calloc(1, texture->pitch * h);
626  if (!texture->pixels) {
628  return NULL;
629  }
630  }
631  }
632  return texture;
633 }
634 
635 SDL_Texture *
637 {
638  const SDL_PixelFormat *fmt;
639  SDL_bool needAlpha;
640  Uint32 i;
641  Uint32 format;
643 
645 
646  if (!surface) {
647  SDL_SetError("SDL_CreateTextureFromSurface() passed NULL surface");
648  return NULL;
649  }
650 
651  /* See what the best texture format is */
652  fmt = surface->format;
653  if (fmt->Amask || SDL_HasColorKey(surface)) {
654  needAlpha = SDL_TRUE;
655  } else {
656  needAlpha = SDL_FALSE;
657  }
659  for (i = 0; i < renderer->info.num_texture_formats; ++i) {
663  break;
664  }
665  }
666 
668  surface->w, surface->h);
669  if (!texture) {
670  return NULL;
671  }
672 
673  if (format == surface->format->format) {
674  if (SDL_MUSTLOCK(surface)) {
676  SDL_UpdateTexture(texture, NULL, surface->pixels, surface->pitch);
678  } else {
679  SDL_UpdateTexture(texture, NULL, surface->pixels, surface->pitch);
680  }
681  } else {
682  SDL_PixelFormat *dst_fmt;
683  SDL_Surface *temp = NULL;
684 
685  /* Set up a destination surface for the texture update */
686  dst_fmt = SDL_AllocFormat(format);
687  if (!dst_fmt) {
689  return NULL;
690  }
691  temp = SDL_ConvertSurface(surface, dst_fmt, 0);
692  SDL_FreeFormat(dst_fmt);
693  if (temp) {
694  SDL_UpdateTexture(texture, NULL, temp->pixels, temp->pitch);
695  SDL_FreeSurface(temp);
696  } else {
698  return NULL;
699  }
700  }
701 
702  {
703  Uint8 r, g, b, a;
705 
708 
711 
712  if (SDL_HasColorKey(surface)) {
713  /* We converted to a texture with alpha format */
715  } else {
718  }
719  }
720  return texture;
721 }
722 
723 int
725  int *w, int *h)
726 {
728 
729  if (format) {
730  *format = texture->format;
731  }
732  if (access) {
733  *access = texture->access;
734  }
735  if (w) {
736  *w = texture->w;
737  }
738  if (h) {
739  *h = texture->h;
740  }
741  return 0;
742 }
743 
744 int
746 {
748 
750 
751  renderer = texture->renderer;
752  if (r < 255 || g < 255 || b < 255) {
754  } else {
755  texture->modMode &= ~SDL_TEXTUREMODULATE_COLOR;
756  }
757  texture->r = r;
758  texture->g = g;
759  texture->b = b;
760  if (texture->native) {
761  return SDL_SetTextureColorMod(texture->native, r, g, b);
762  } else if (renderer->SetTextureColorMod) {
764  } else {
765  return 0;
766  }
767 }
768 
769 int
771  Uint8 * b)
772 {
774 
775  if (r) {
776  *r = texture->r;
777  }
778  if (g) {
779  *g = texture->g;
780  }
781  if (b) {
782  *b = texture->b;
783  }
784  return 0;
785 }
786 
787 int
789 {
791 
793 
794  renderer = texture->renderer;
795  if (alpha < 255) {
797  } else {
798  texture->modMode &= ~SDL_TEXTUREMODULATE_ALPHA;
799  }
800  texture->a = alpha;
801  if (texture->native) {
802  return SDL_SetTextureAlphaMod(texture->native, alpha);
803  } else if (renderer->SetTextureAlphaMod) {
805  } else {
806  return 0;
807  }
808 }
809 
810 int
812 {
814 
815  if (alpha) {
816  *alpha = texture->a;
817  }
818  return 0;
819 }
820 
821 int
823 {
825 
827 
828  renderer = texture->renderer;
830  return SDL_Unsupported();
831  }
832  texture->blendMode = blendMode;
833  if (texture->native) {
834  return SDL_SetTextureBlendMode(texture->native, blendMode);
835  } else if (renderer->SetTextureBlendMode) {
837  } else {
838  return 0;
839  }
840 }
841 
842 int
844 {
846 
847  if (blendMode) {
848  *blendMode = texture->blendMode;
849  }
850  return 0;
851 }
852 
853 static int
855  const void *pixels, int pitch)
856 {
857  SDL_Texture *native = texture->native;
858  SDL_Rect full_rect;
859 
860  if (SDL_SW_UpdateYUVTexture(texture->yuv, rect, pixels, pitch) < 0) {
861  return -1;
862  }
863 
864  full_rect.x = 0;
865  full_rect.y = 0;
866  full_rect.w = texture->w;
867  full_rect.h = texture->h;
868  rect = &full_rect;
869 
870  if (texture->access == SDL_TEXTUREACCESS_STREAMING) {
871  /* We can lock the texture and copy to it */
872  void *native_pixels = NULL;
873  int native_pitch = 0;
874 
875  if (SDL_LockTexture(native, rect, &native_pixels, &native_pitch) < 0) {
876  return -1;
877  }
878  SDL_SW_CopyYUVToRGB(texture->yuv, rect, native->format,
879  rect->w, rect->h, native_pixels, native_pitch);
880  SDL_UnlockTexture(native);
881  } else {
882  /* Use a temporary buffer for updating */
883  const int temp_pitch = (((rect->w * SDL_BYTESPERPIXEL(native->format)) + 3) & ~3);
884  const size_t alloclen = rect->h * temp_pitch;
885  if (alloclen > 0) {
886  void *temp_pixels = SDL_malloc(alloclen);
887  if (!temp_pixels) {
888  return SDL_OutOfMemory();
889  }
890  SDL_SW_CopyYUVToRGB(texture->yuv, rect, native->format,
891  rect->w, rect->h, temp_pixels, temp_pitch);
892  SDL_UpdateTexture(native, rect, temp_pixels, temp_pitch);
893  SDL_free(temp_pixels);
894  }
895  }
896  return 0;
897 }
898 
899 static int
901  const void *pixels, int pitch)
902 {
903  SDL_Texture *native = texture->native;
904 
905  if (!rect->w || !rect->h) {
906  return 0; /* nothing to do. */
907  }
908 
909  if (texture->access == SDL_TEXTUREACCESS_STREAMING) {
910  /* We can lock the texture and copy to it */
911  void *native_pixels = NULL;
912  int native_pitch = 0;
913 
914  if (SDL_LockTexture(native, rect, &native_pixels, &native_pitch) < 0) {
915  return -1;
916  }
918  texture->format, pixels, pitch,
919  native->format, native_pixels, native_pitch);
920  SDL_UnlockTexture(native);
921  } else {
922  /* Use a temporary buffer for updating */
923  const int temp_pitch = (((rect->w * SDL_BYTESPERPIXEL(native->format)) + 3) & ~3);
924  const size_t alloclen = rect->h * temp_pitch;
925  if (alloclen > 0) {
926  void *temp_pixels = SDL_malloc(alloclen);
927  if (!temp_pixels) {
928  return SDL_OutOfMemory();
929  }
931  texture->format, pixels, pitch,
932  native->format, temp_pixels, temp_pitch);
933  SDL_UpdateTexture(native, rect, temp_pixels, temp_pitch);
934  SDL_free(temp_pixels);
935  }
936  }
937  return 0;
938 }
939 
940 int
942  const void *pixels, int pitch)
943 {
945  SDL_Rect full_rect;
946 
948 
949  if (!pixels) {
950  return SDL_InvalidParamError("pixels");
951  }
952  if (!pitch) {
953  return SDL_InvalidParamError("pitch");
954  }
955 
956  if (!rect) {
957  full_rect.x = 0;
958  full_rect.y = 0;
959  full_rect.w = texture->w;
960  full_rect.h = texture->h;
961  rect = &full_rect;
962  }
963 
964  if ((rect->w == 0) || (rect->h == 0)) {
965  return 0; /* nothing to do. */
966  } else if (texture->yuv) {
967  return SDL_UpdateTextureYUV(texture, rect, pixels, pitch);
968  } else if (texture->native) {
969  return SDL_UpdateTextureNative(texture, rect, pixels, pitch);
970  } else {
971  renderer = texture->renderer;
972  return renderer->UpdateTexture(renderer, texture, rect, pixels, pitch);
973  }
974 }
975 
976 static int
978  const Uint8 *Yplane, int Ypitch,
979  const Uint8 *Uplane, int Upitch,
980  const Uint8 *Vplane, int Vpitch)
981 {
982  SDL_Texture *native = texture->native;
983  SDL_Rect full_rect;
984 
985  if (SDL_SW_UpdateYUVTexturePlanar(texture->yuv, rect, Yplane, Ypitch, Uplane, Upitch, Vplane, Vpitch) < 0) {
986  return -1;
987  }
988 
989  full_rect.x = 0;
990  full_rect.y = 0;
991  full_rect.w = texture->w;
992  full_rect.h = texture->h;
993  rect = &full_rect;
994 
995  if (!rect->w || !rect->h) {
996  return 0; /* nothing to do. */
997  }
998 
999  if (texture->access == SDL_TEXTUREACCESS_STREAMING) {
1000  /* We can lock the texture and copy to it */
1001  void *native_pixels = NULL;
1002  int native_pitch = 0;
1003 
1004  if (SDL_LockTexture(native, rect, &native_pixels, &native_pitch) < 0) {
1005  return -1;
1006  }
1007  SDL_SW_CopyYUVToRGB(texture->yuv, rect, native->format,
1008  rect->w, rect->h, native_pixels, native_pitch);
1009  SDL_UnlockTexture(native);
1010  } else {
1011  /* Use a temporary buffer for updating */
1012  const int temp_pitch = (((rect->w * SDL_BYTESPERPIXEL(native->format)) + 3) & ~3);
1013  const size_t alloclen = rect->h * temp_pitch;
1014  if (alloclen > 0) {
1015  void *temp_pixels = SDL_malloc(alloclen);
1016  if (!temp_pixels) {
1017  return SDL_OutOfMemory();
1018  }
1019  SDL_SW_CopyYUVToRGB(texture->yuv, rect, native->format,
1020  rect->w, rect->h, temp_pixels, temp_pitch);
1021  SDL_UpdateTexture(native, rect, temp_pixels, temp_pitch);
1022  SDL_free(temp_pixels);
1023  }
1024  }
1025  return 0;
1026 }
1027 
1029  const Uint8 *Yplane, int Ypitch,
1030  const Uint8 *Uplane, int Upitch,
1031  const Uint8 *Vplane, int Vpitch)
1032 {
1034  SDL_Rect full_rect;
1035 
1037 
1038  if (!Yplane) {
1039  return SDL_InvalidParamError("Yplane");
1040  }
1041  if (!Ypitch) {
1042  return SDL_InvalidParamError("Ypitch");
1043  }
1044  if (!Uplane) {
1045  return SDL_InvalidParamError("Uplane");
1046  }
1047  if (!Upitch) {
1048  return SDL_InvalidParamError("Upitch");
1049  }
1050  if (!Vplane) {
1051  return SDL_InvalidParamError("Vplane");
1052  }
1053  if (!Vpitch) {
1054  return SDL_InvalidParamError("Vpitch");
1055  }
1056 
1057  if (texture->format != SDL_PIXELFORMAT_YV12 &&
1058  texture->format != SDL_PIXELFORMAT_IYUV) {
1059  return SDL_SetError("Texture format must by YV12 or IYUV");
1060  }
1061 
1062  if (!rect) {
1063  full_rect.x = 0;
1064  full_rect.y = 0;
1065  full_rect.w = texture->w;
1066  full_rect.h = texture->h;
1067  rect = &full_rect;
1068  }
1069 
1070  if (!rect->w || !rect->h) {
1071  return 0; /* nothing to do. */
1072  }
1073 
1074  if (texture->yuv) {
1075  return SDL_UpdateTextureYUVPlanar(texture, rect, Yplane, Ypitch, Uplane, Upitch, Vplane, Vpitch);
1076  } else {
1077  SDL_assert(!texture->native);
1078  renderer = texture->renderer;
1080  if (renderer->UpdateTextureYUV) {
1081  return renderer->UpdateTextureYUV(renderer, texture, rect, Yplane, Ypitch, Uplane, Upitch, Vplane, Vpitch);
1082  } else {
1083  return SDL_Unsupported();
1084  }
1085  }
1086 }
1087 
1088 static int
1090  void **pixels, int *pitch)
1091 {
1092  return SDL_SW_LockYUVTexture(texture->yuv, rect, pixels, pitch);
1093 }
1094 
1095 static int
1097  void **pixels, int *pitch)
1098 {
1099  texture->locked_rect = *rect;
1100  *pixels = (void *) ((Uint8 *) texture->pixels +
1101  rect->y * texture->pitch +
1102  rect->x * SDL_BYTESPERPIXEL(texture->format));
1103  *pitch = texture->pitch;
1104  return 0;
1105 }
1106 
1107 int
1109  void **pixels, int *pitch)
1110 {
1112  SDL_Rect full_rect;
1113 
1115 
1116  if (texture->access != SDL_TEXTUREACCESS_STREAMING) {
1117  return SDL_SetError("SDL_LockTexture(): texture must be streaming");
1118  }
1119 
1120  if (!rect) {
1121  full_rect.x = 0;
1122  full_rect.y = 0;
1123  full_rect.w = texture->w;
1124  full_rect.h = texture->h;
1125  rect = &full_rect;
1126  }
1127 
1128  if (texture->yuv) {
1129  return SDL_LockTextureYUV(texture, rect, pixels, pitch);
1130  } else if (texture->native) {
1131  return SDL_LockTextureNative(texture, rect, pixels, pitch);
1132  } else {
1133  renderer = texture->renderer;
1134  return renderer->LockTexture(renderer, texture, rect, pixels, pitch);
1135  }
1136 }
1137 
1138 static void
1140 {
1141  SDL_Texture *native = texture->native;
1142  void *native_pixels = NULL;
1143  int native_pitch = 0;
1144  SDL_Rect rect;
1145 
1146  rect.x = 0;
1147  rect.y = 0;
1148  rect.w = texture->w;
1149  rect.h = texture->h;
1150 
1151  if (SDL_LockTexture(native, &rect, &native_pixels, &native_pitch) < 0) {
1152  return;
1153  }
1154  SDL_SW_CopyYUVToRGB(texture->yuv, &rect, native->format,
1155  rect.w, rect.h, native_pixels, native_pitch);
1156  SDL_UnlockTexture(native);
1157 }
1158 
1159 static void
1161 {
1162  SDL_Texture *native = texture->native;
1163  void *native_pixels = NULL;
1164  int native_pitch = 0;
1165  const SDL_Rect *rect = &texture->locked_rect;
1166  const void* pixels = (void *) ((Uint8 *) texture->pixels +
1167  rect->y * texture->pitch +
1168  rect->x * SDL_BYTESPERPIXEL(texture->format));
1169  int pitch = texture->pitch;
1170 
1171  if (SDL_LockTexture(native, rect, &native_pixels, &native_pitch) < 0) {
1172  return;
1173  }
1175  texture->format, pixels, pitch,
1176  native->format, native_pixels, native_pitch);
1177  SDL_UnlockTexture(native);
1178 }
1179 
1180 void
1182 {
1184 
1186 
1187  if (texture->access != SDL_TEXTUREACCESS_STREAMING) {
1188  return;
1189  }
1190  if (texture->yuv) {
1192  } else if (texture->native) {
1194  } else {
1195  renderer = texture->renderer;
1197  }
1198 }
1199 
1200 SDL_bool
1202 {
1203  if (!renderer || !renderer->SetRenderTarget) {
1204  return SDL_FALSE;
1205  }
1206  return (renderer->info.flags & SDL_RENDERER_TARGETTEXTURE) != 0;
1207 }
1208 
1209 int
1211 {
1213  return SDL_Unsupported();
1214  }
1215  if (texture == renderer->target) {
1216  /* Nothing to do! */
1217  return 0;
1218  }
1219 
1220  /* texture == NULL is valid and means reset the target to the window */
1221  if (texture) {
1223  if (renderer != texture->renderer) {
1224  return SDL_SetError("Texture was not created with this renderer");
1225  }
1226  if (texture->access != SDL_TEXTUREACCESS_TARGET) {
1227  return SDL_SetError("Texture not created with SDL_TEXTUREACCESS_TARGET");
1228  }
1229  if (texture->native) {
1230  /* Always render to the native texture */
1231  texture = texture->native;
1232  }
1233  }
1234 
1236 
1237  if (texture && !renderer->target) {
1238  /* Make a backup of the viewport */
1245  }
1246  renderer->target = texture;
1247 
1250  return -1;
1251  }
1252 
1253  if (texture) {
1254  renderer->viewport.x = 0;
1255  renderer->viewport.y = 0;
1256  renderer->viewport.w = texture->w;
1257  renderer->viewport.h = texture->h;
1260  renderer->scale.x = 1.0f;
1261  renderer->scale.y = 1.0f;
1262  renderer->logical_w = texture->w;
1263  renderer->logical_h = texture->h;
1264  } else {
1271  }
1272 
1274 
1275  if (renderer->UpdateViewport(renderer) < 0) {
1276  return -1;
1277  }
1278  if (renderer->UpdateClipRect(renderer) < 0) {
1279  return -1;
1280  }
1281 
1282  /* All set! */
1283  return 0;
1284 }
1285 
1286 SDL_Texture *
1288 {
1289  return renderer->target;
1290 }
1291 
1292 static int
1294 {
1295  int w = 1, h = 1;
1296  float want_aspect;
1297  float real_aspect;
1298  float scale;
1300  /* 0 is for letterbox, 1 is for overscan */
1301  int scale_policy = 0;
1302  const char *hint;
1303 
1304  if (!renderer->logical_w || !renderer->logical_h) {
1305  return 0;
1306  }
1307  if (SDL_GetRendererOutputSize(renderer, &w, &h) < 0) {
1308  return -1;
1309  }
1310 
1312  if (hint && (*hint == '1' || SDL_strcasecmp(hint, "overscan") == 0)) {
1313 #if SDL_VIDEO_RENDER_D3D
1314  SDL_bool overscan_supported = SDL_TRUE;
1315  /* Unfortunately, Direct3D 9 doesn't support negative viewport numbers
1316  which the overscan implementation relies on.
1317  */
1318  if (SDL_strcasecmp(SDL_GetCurrentVideoDriver(), "direct3d") == 0) {
1319  overscan_supported = SDL_FALSE;
1320  }
1321  if (overscan_supported) {
1322  scale_policy = 1;
1323  }
1324 #else
1325  scale_policy = 1;
1326 #endif
1327  }
1328 
1329  want_aspect = (float)renderer->logical_w / renderer->logical_h;
1330  real_aspect = (float)w / h;
1331 
1332  /* Clear the scale because we're setting viewport in output coordinates */
1333  SDL_RenderSetScale(renderer, 1.0f, 1.0f);
1334 
1335  if (renderer->integer_scale) {
1336  if (want_aspect > real_aspect) {
1337  scale = (float)(w / renderer->logical_w);
1338  } else {
1339  scale = (float)(h / renderer->logical_h);
1340  }
1342  viewport.x = (w - viewport.w) / 2;
1344  viewport.y = (h - viewport.h) / 2;
1345 
1347  } else if (SDL_fabs(want_aspect-real_aspect) < 0.0001) {
1348  /* The aspect ratios are the same, just scale appropriately */
1349  scale = (float)w / renderer->logical_w;
1351  } else if (want_aspect > real_aspect) {
1352  if (scale_policy == 1) {
1353  /* We want a wider aspect ratio than is available -
1354  zoom so logical height matches the real height
1355  and the width will grow off the screen
1356  */
1357  scale = (float)h / renderer->logical_h;
1358  viewport.y = 0;
1359  viewport.h = h;
1361  viewport.x = (w - viewport.w) / 2;
1363  } else {
1364  /* We want a wider aspect ratio than is available - letterbox it */
1365  scale = (float)w / renderer->logical_w;
1366  viewport.x = 0;
1367  viewport.w = w;
1369  viewport.y = (h - viewport.h) / 2;
1371  }
1372  } else {
1373  if (scale_policy == 1) {
1374  /* We want a narrower aspect ratio than is available -
1375  zoom so logical width matches the real width
1376  and the height will grow off the screen
1377  */
1378  scale = (float)w / renderer->logical_w;
1379  viewport.x = 0;
1380  viewport.w = w;
1382  viewport.y = (h - viewport.h) / 2;
1384  } else {
1385  /* We want a narrower aspect ratio than is available - use side-bars */
1386  scale = (float)h / renderer->logical_h;
1387  viewport.y = 0;
1388  viewport.h = h;
1390  viewport.x = (w - viewport.w) / 2;
1392  }
1393  }
1394 
1395  /* Set the new scale */
1397 
1398  return 0;
1399 }
1400 
1401 int
1403 {
1405 
1406  if (!w || !h) {
1407  /* Clear any previous logical resolution */
1408  renderer->logical_w = 0;
1409  renderer->logical_h = 0;
1411  SDL_RenderSetScale(renderer, 1.0f, 1.0f);
1412  return 0;
1413  }
1414 
1415  renderer->logical_w = w;
1416  renderer->logical_h = h;
1417 
1418  return UpdateLogicalSize(renderer);
1419 }
1420 
1421 void
1423 {
1425 
1426  if (w) {
1427  *w = renderer->logical_w;
1428  }
1429  if (h) {
1430  *h = renderer->logical_h;
1431  }
1432 }
1433 
1434 int
1436 {
1438 
1440 
1441  return UpdateLogicalSize(renderer);
1442 }
1443 
1444 SDL_bool
1446 {
1448 
1449  return renderer->integer_scale;
1450 }
1451 
1452 int
1454 {
1456 
1457  if (rect) {
1458  renderer->viewport.x = (int)SDL_floor(rect->x * renderer->scale.x);
1459  renderer->viewport.y = (int)SDL_floor(rect->y * renderer->scale.y);
1460  renderer->viewport.w = (int)SDL_ceil(rect->w * renderer->scale.x);
1461  renderer->viewport.h = (int)SDL_ceil(rect->h * renderer->scale.y);
1462  } else {
1463  renderer->viewport.x = 0;
1464  renderer->viewport.y = 0;
1466  return -1;
1467  }
1468  }
1469  return renderer->UpdateViewport(renderer);
1470 }
1471 
1472 void
1474 {
1476 
1477  if (rect) {
1478  rect->x = (int)(renderer->viewport.x / renderer->scale.x);
1479  rect->y = (int)(renderer->viewport.y / renderer->scale.y);
1480  rect->w = (int)(renderer->viewport.w / renderer->scale.x);
1481  rect->h = (int)(renderer->viewport.h / renderer->scale.y);
1482  }
1483 }
1484 
1485 int
1487 {
1489 
1490  if (rect) {
1494  renderer->clip_rect.w = (int)SDL_ceil(rect->w * renderer->scale.x);
1495  renderer->clip_rect.h = (int)SDL_ceil(rect->h * renderer->scale.y);
1496  } else {
1499  }
1500  return renderer->UpdateClipRect(renderer);
1501 }
1502 
1503 void
1505 {
1507 
1508  if (rect) {
1509  rect->x = (int)(renderer->clip_rect.x / renderer->scale.x);
1510  rect->y = (int)(renderer->clip_rect.y / renderer->scale.y);
1511  rect->w = (int)(renderer->clip_rect.w / renderer->scale.x);
1512  rect->h = (int)(renderer->clip_rect.h / renderer->scale.y);
1513  }
1514 }
1515 
1516 SDL_bool
1518 {
1520  return renderer->clipping_enabled;
1521 }
1522 
1523 int
1524 SDL_RenderSetScale(SDL_Renderer * renderer, float scaleX, float scaleY)
1525 {
1527 
1528  renderer->scale.x = scaleX;
1529  renderer->scale.y = scaleY;
1530  return 0;
1531 }
1532 
1533 void
1534 SDL_RenderGetScale(SDL_Renderer * renderer, float *scaleX, float *scaleY)
1535 {
1537 
1538  if (scaleX) {
1539  *scaleX = renderer->scale.x;
1540  }
1541  if (scaleY) {
1542  *scaleY = renderer->scale.y;
1543  }
1544 }
1545 
1546 int
1548  Uint8 r, Uint8 g, Uint8 b, Uint8 a)
1549 {
1551 
1552  renderer->r = r;
1553  renderer->g = g;
1554  renderer->b = b;
1555  renderer->a = a;
1556  return 0;
1557 }
1558 
1559 int
1561  Uint8 * r, Uint8 * g, Uint8 * b, Uint8 * a)
1562 {
1564 
1565  if (r) {
1566  *r = renderer->r;
1567  }
1568  if (g) {
1569  *g = renderer->g;
1570  }
1571  if (b) {
1572  *b = renderer->b;
1573  }
1574  if (a) {
1575  *a = renderer->a;
1576  }
1577  return 0;
1578 }
1579 
1580 int
1582 {
1584 
1586  return SDL_Unsupported();
1587  }
1589  return 0;
1590 }
1591 
1592 int
1594 {
1596 
1598  return 0;
1599 }
1600 
1601 int
1603 {
1605 
1606  /* Don't draw while we're hidden */
1607  if (renderer->hidden) {
1608  return 0;
1609  }
1610  return renderer->RenderClear(renderer);
1611 }
1612 
1613 int
1615 {
1616  SDL_Point point;
1617 
1618  point.x = x;
1619  point.y = y;
1620  return SDL_RenderDrawPoints(renderer, &point, 1);
1621 }
1622 
1623 static int
1625  const SDL_Point * points, int count)
1626 {
1627  SDL_FRect *frects;
1628  int i;
1629  int status;
1630 
1631  frects = SDL_stack_alloc(SDL_FRect, count);
1632  if (!frects) {
1633  return SDL_OutOfMemory();
1634  }
1635  for (i = 0; i < count; ++i) {
1636  frects[i].x = points[i].x * renderer->scale.x;
1637  frects[i].y = points[i].y * renderer->scale.y;
1638  frects[i].w = renderer->scale.x;
1639  frects[i].h = renderer->scale.y;
1640  }
1641 
1642  status = renderer->RenderFillRects(renderer, frects, count);
1643 
1644  SDL_stack_free(frects);
1645 
1646  return status;
1647 }
1648 
1649 int
1651  const SDL_Point * points, int count)
1652 {
1653  SDL_FPoint *fpoints;
1654  int i;
1655  int status;
1656 
1658 
1659  if (!points) {
1660  return SDL_SetError("SDL_RenderDrawPoints(): Passed NULL points");
1661  }
1662  if (count < 1) {
1663  return 0;
1664  }
1665 
1666  /* Don't draw while we're hidden */
1667  if (renderer->hidden) {
1668  return 0;
1669  }
1670 
1671  if (renderer->scale.x != 1.0f || renderer->scale.y != 1.0f) {
1673  }
1674 
1675  fpoints = SDL_stack_alloc(SDL_FPoint, count);
1676  if (!fpoints) {
1677  return SDL_OutOfMemory();
1678  }
1679  for (i = 0; i < count; ++i) {
1680  fpoints[i].x = points[i].x * renderer->scale.x;
1681  fpoints[i].y = points[i].y * renderer->scale.y;
1682  }
1683 
1684  status = renderer->RenderDrawPoints(renderer, fpoints, count);
1685 
1686  SDL_stack_free(fpoints);
1687 
1688  return status;
1689 }
1690 
1691 int
1693 {
1694  SDL_Point points[2];
1695 
1696  points[0].x = x1;
1697  points[0].y = y1;
1698  points[1].x = x2;
1699  points[1].y = y2;
1700  return SDL_RenderDrawLines(renderer, points, 2);
1701 }
1702 
1703 static int
1705  const SDL_Point * points, int count)
1706 {
1707  SDL_FRect *frect;
1708  SDL_FRect *frects;
1709  SDL_FPoint fpoints[2];
1710  int i, nrects;
1711  int status;
1712 
1713  frects = SDL_stack_alloc(SDL_FRect, count-1);
1714  if (!frects) {
1715  return SDL_OutOfMemory();
1716  }
1717 
1718  status = 0;
1719  nrects = 0;
1720  for (i = 0; i < count-1; ++i) {
1721  if (points[i].x == points[i+1].x) {
1722  int minY = SDL_min(points[i].y, points[i+1].y);
1723  int maxY = SDL_max(points[i].y, points[i+1].y);
1724 
1725  frect = &frects[nrects++];
1726  frect->x = points[i].x * renderer->scale.x;
1727  frect->y = minY * renderer->scale.y;
1728  frect->w = renderer->scale.x;
1729  frect->h = (maxY - minY + 1) * renderer->scale.y;
1730  } else if (points[i].y == points[i+1].y) {
1731  int minX = SDL_min(points[i].x, points[i+1].x);
1732  int maxX = SDL_max(points[i].x, points[i+1].x);
1733 
1734  frect = &frects[nrects++];
1735  frect->x = minX * renderer->scale.x;
1736  frect->y = points[i].y * renderer->scale.y;
1737  frect->w = (maxX - minX + 1) * renderer->scale.x;
1738  frect->h = renderer->scale.y;
1739  } else {
1740  /* FIXME: We can't use a rect for this line... */
1741  fpoints[0].x = points[i].x * renderer->scale.x;
1742  fpoints[0].y = points[i].y * renderer->scale.y;
1743  fpoints[1].x = points[i+1].x * renderer->scale.x;
1744  fpoints[1].y = points[i+1].y * renderer->scale.y;
1745  status += renderer->RenderDrawLines(renderer, fpoints, 2);
1746  }
1747  }
1748 
1749  status += renderer->RenderFillRects(renderer, frects, nrects);
1750 
1751  SDL_stack_free(frects);
1752 
1753  if (status < 0) {
1754  status = -1;
1755  }
1756  return status;
1757 }
1758 
1759 int
1761  const SDL_Point * points, int count)
1762 {
1763  SDL_FPoint *fpoints;
1764  int i;
1765  int status;
1766 
1768 
1769  if (!points) {
1770  return SDL_SetError("SDL_RenderDrawLines(): Passed NULL points");
1771  }
1772  if (count < 2) {
1773  return 0;
1774  }
1775 
1776  /* Don't draw while we're hidden */
1777  if (renderer->hidden) {
1778  return 0;
1779  }
1780 
1781  if (renderer->scale.x != 1.0f || renderer->scale.y != 1.0f) {
1783  }
1784 
1785  fpoints = SDL_stack_alloc(SDL_FPoint, count);
1786  if (!fpoints) {
1787  return SDL_OutOfMemory();
1788  }
1789  for (i = 0; i < count; ++i) {
1790  fpoints[i].x = points[i].x * renderer->scale.x;
1791  fpoints[i].y = points[i].y * renderer->scale.y;
1792  }
1793 
1794  status = renderer->RenderDrawLines(renderer, fpoints, count);
1795 
1796  SDL_stack_free(fpoints);
1797 
1798  return status;
1799 }
1800 
1801 int
1803 {
1804  SDL_Rect full_rect;
1805  SDL_Point points[5];
1806 
1808 
1809  /* If 'rect' == NULL, then outline the whole surface */
1810  if (!rect) {
1811  SDL_RenderGetViewport(renderer, &full_rect);
1812  full_rect.x = 0;
1813  full_rect.y = 0;
1814  rect = &full_rect;
1815  }
1816 
1817  points[0].x = rect->x;
1818  points[0].y = rect->y;
1819  points[1].x = rect->x+rect->w-1;
1820  points[1].y = rect->y;
1821  points[2].x = rect->x+rect->w-1;
1822  points[2].y = rect->y+rect->h-1;
1823  points[3].x = rect->x;
1824  points[3].y = rect->y+rect->h-1;
1825  points[4].x = rect->x;
1826  points[4].y = rect->y;
1827  return SDL_RenderDrawLines(renderer, points, 5);
1828 }
1829 
1830 int
1832  const SDL_Rect * rects, int count)
1833 {
1834  int i;
1835 
1837 
1838  if (!rects) {
1839  return SDL_SetError("SDL_RenderDrawRects(): Passed NULL rects");
1840  }
1841  if (count < 1) {
1842  return 0;
1843  }
1844 
1845  /* Don't draw while we're hidden */
1846  if (renderer->hidden) {
1847  return 0;
1848  }
1849 
1850  for (i = 0; i < count; ++i) {
1851  if (SDL_RenderDrawRect(renderer, &rects[i]) < 0) {
1852  return -1;
1853  }
1854  }
1855  return 0;
1856 }
1857 
1858 int
1860 {
1861  SDL_Rect full_rect = { 0, 0, 0, 0 };
1862 
1864 
1865  /* If 'rect' == NULL, then outline the whole surface */
1866  if (!rect) {
1867  SDL_RenderGetViewport(renderer, &full_rect);
1868  full_rect.x = 0;
1869  full_rect.y = 0;
1870  rect = &full_rect;
1871  }
1872  return SDL_RenderFillRects(renderer, rect, 1);
1873 }
1874 
1875 int
1877  const SDL_Rect * rects, int count)
1878 {
1879  SDL_FRect *frects;
1880  int i;
1881  int status;
1882 
1884 
1885  if (!rects) {
1886  return SDL_SetError("SDL_RenderFillRects(): Passed NULL rects");
1887  }
1888  if (count < 1) {
1889  return 0;
1890  }
1891 
1892  /* Don't draw while we're hidden */
1893  if (renderer->hidden) {
1894  return 0;
1895  }
1896 
1897  frects = SDL_stack_alloc(SDL_FRect, count);
1898  if (!frects) {
1899  return SDL_OutOfMemory();
1900  }
1901  for (i = 0; i < count; ++i) {
1902  frects[i].x = rects[i].x * renderer->scale.x;
1903  frects[i].y = rects[i].y * renderer->scale.y;
1904  frects[i].w = rects[i].w * renderer->scale.x;
1905  frects[i].h = rects[i].h * renderer->scale.y;
1906  }
1907 
1908  status = renderer->RenderFillRects(renderer, frects, count);
1909 
1910  SDL_stack_free(frects);
1911 
1912  return status;
1913 }
1914 
1915 int
1917  const SDL_Rect * srcrect, const SDL_Rect * dstrect)
1918 {
1919  SDL_Rect real_srcrect = { 0, 0, 0, 0 };
1920  SDL_Rect real_dstrect = { 0, 0, 0, 0 };
1921  SDL_FRect frect;
1922 
1925 
1926  if (renderer != texture->renderer) {
1927  return SDL_SetError("Texture was not created with this renderer");
1928  }
1929 
1930  /* Don't draw while we're hidden */
1931  if (renderer->hidden) {
1932  return 0;
1933  }
1934 
1935  real_srcrect.x = 0;
1936  real_srcrect.y = 0;
1937  real_srcrect.w = texture->w;
1938  real_srcrect.h = texture->h;
1939  if (srcrect) {
1940  if (!SDL_IntersectRect(srcrect, &real_srcrect, &real_srcrect)) {
1941  return 0;
1942  }
1943  }
1944 
1945  SDL_RenderGetViewport(renderer, &real_dstrect);
1946  real_dstrect.x = 0;
1947  real_dstrect.y = 0;
1948  if (dstrect) {
1949  if (!SDL_HasIntersection(dstrect, &real_dstrect)) {
1950  return 0;
1951  }
1952  real_dstrect = *dstrect;
1953  }
1954 
1955  if (texture->native) {
1956  texture = texture->native;
1957  }
1958 
1959  frect.x = real_dstrect.x * renderer->scale.x;
1960  frect.y = real_dstrect.y * renderer->scale.y;
1961  frect.w = real_dstrect.w * renderer->scale.x;
1962  frect.h = real_dstrect.h * renderer->scale.y;
1963 
1964  return renderer->RenderCopy(renderer, texture, &real_srcrect, &frect);
1965 }
1966 
1967 
1968 int
1970  const SDL_Rect * srcrect, const SDL_Rect * dstrect,
1971  const double angle, const SDL_Point *center, const SDL_RendererFlip flip)
1972 {
1973  SDL_Rect real_srcrect = { 0, 0, 0, 0 };
1974  SDL_Rect real_dstrect = { 0, 0, 0, 0 };
1975  SDL_Point real_center;
1976  SDL_FRect frect;
1977  SDL_FPoint fcenter;
1978 
1979  if (flip == SDL_FLIP_NONE && (int)(angle/360) == angle/360) { /* fast path when we don't need rotation or flipping */
1980  return SDL_RenderCopy(renderer, texture, srcrect, dstrect);
1981  }
1982 
1985 
1986  if (renderer != texture->renderer) {
1987  return SDL_SetError("Texture was not created with this renderer");
1988  }
1989  if (!renderer->RenderCopyEx) {
1990  return SDL_SetError("Renderer does not support RenderCopyEx");
1991  }
1992 
1993  /* Don't draw while we're hidden */
1994  if (renderer->hidden) {
1995  return 0;
1996  }
1997 
1998  real_srcrect.x = 0;
1999  real_srcrect.y = 0;
2000  real_srcrect.w = texture->w;
2001  real_srcrect.h = texture->h;
2002  if (srcrect) {
2003  if (!SDL_IntersectRect(srcrect, &real_srcrect, &real_srcrect)) {
2004  return 0;
2005  }
2006  }
2007 
2008  /* We don't intersect the dstrect with the viewport as RenderCopy does because of potential rotation clipping issues... TODO: should we? */
2009  if (dstrect) {
2010  real_dstrect = *dstrect;
2011  } else {
2012  SDL_RenderGetViewport(renderer, &real_dstrect);
2013  real_dstrect.x = 0;
2014  real_dstrect.y = 0;
2015  }
2016 
2017  if (texture->native) {
2018  texture = texture->native;
2019  }
2020 
2021  if (center) {
2022  real_center = *center;
2023  } else {
2024  real_center.x = real_dstrect.w/2;
2025  real_center.y = real_dstrect.h/2;
2026  }
2027 
2028  frect.x = real_dstrect.x * renderer->scale.x;
2029  frect.y = real_dstrect.y * renderer->scale.y;
2030  frect.w = real_dstrect.w * renderer->scale.x;
2031  frect.h = real_dstrect.h * renderer->scale.y;
2032 
2033  fcenter.x = real_center.x * renderer->scale.x;
2034  fcenter.y = real_center.y * renderer->scale.y;
2035 
2036  return renderer->RenderCopyEx(renderer, texture, &real_srcrect, &frect, angle, &fcenter, flip);
2037 }
2038 
2039 int
2041  Uint32 format, void * pixels, int pitch)
2042 {
2043  SDL_Rect real_rect;
2044 
2046 
2047  if (!renderer->RenderReadPixels) {
2048  return SDL_Unsupported();
2049  }
2050 
2051  if (!format) {
2053  }
2054 
2055  real_rect.x = renderer->viewport.x;
2056  real_rect.y = renderer->viewport.y;
2057  real_rect.w = renderer->viewport.w;
2058  real_rect.h = renderer->viewport.h;
2059  if (rect) {
2060  if (!SDL_IntersectRect(rect, &real_rect, &real_rect)) {
2061  return 0;
2062  }
2063  if (real_rect.y > rect->y) {
2064  pixels = (Uint8 *)pixels + pitch * (real_rect.y - rect->y);
2065  }
2066  if (real_rect.x > rect->x) {
2067  int bpp = SDL_BYTESPERPIXEL(format);
2068  pixels = (Uint8 *)pixels + bpp * (real_rect.x - rect->x);
2069  }
2070  }
2071 
2072  return renderer->RenderReadPixels(renderer, &real_rect,
2073  format, pixels, pitch);
2074 }
2075 
2076 void
2078 {
2080 
2081  /* Don't draw while we're hidden */
2082  if (renderer->hidden) {
2083  return;
2084  }
2086 }
2087 
2088 void
2090 {
2092 
2094 
2095  renderer = texture->renderer;
2096  if (texture == renderer->target) {
2098  }
2099 
2100  texture->magic = NULL;
2101 
2102  if (texture->next) {
2103  texture->next->prev = texture->prev;
2104  }
2105  if (texture->prev) {
2106  texture->prev->next = texture->next;
2107  } else {
2109  }
2110 
2111  if (texture->native) {
2112  SDL_DestroyTexture(texture->native);
2113  }
2114  if (texture->yuv) {
2116  }
2117  SDL_free(texture->pixels);
2118 
2120  SDL_free(texture);
2121 }
2122 
2123 void
2125 {
2127 
2129 
2130  /* Free existing textures for this renderer */
2131  while (renderer->textures) {
2132  SDL_Texture *tex = renderer->textures; (void) tex;
2134  SDL_assert(tex != renderer->textures); /* satisfy static analysis. */
2135  }
2136 
2137  if (renderer->window) {
2139  }
2140 
2141  /* It's no longer magical... */
2142  renderer->magic = NULL;
2143 
2144  /* Free the target mutex */
2147 
2148  /* Free the renderer instance */
2150 }
2151 
2152 int SDL_GL_BindTexture(SDL_Texture *texture, float *texw, float *texh)
2153 {
2155 
2157  renderer = texture->renderer;
2158  if (texture->native) {
2159  return SDL_GL_BindTexture(texture->native, texw, texh);
2160  } else if (renderer && renderer->GL_BindTexture) {
2161  return renderer->GL_BindTexture(renderer, texture, texw, texh);
2162  } else {
2163  return SDL_Unsupported();
2164  }
2165 }
2166 
2168 {
2170 
2172  renderer = texture->renderer;
2173  if (texture->native) {
2174  return SDL_GL_UnbindTexture(texture->native);
2175  } else if (renderer && renderer->GL_UnbindTexture) {
2177  }
2178 
2179  return SDL_Unsupported();
2180 }
2181 
2182 void *
2184 {
2186 
2187  if (renderer->GetMetalLayer) {
2188  return renderer->GetMetalLayer(renderer);
2189  }
2190  return NULL;
2191 }
2192 
2193 void *
2195 {
2197 
2200  }
2201  return NULL;
2202 }
2203 
2204 static SDL_BlendMode
2206 {
2208  return SDL_BLENDMODE_NONE;
2209  }
2211  return SDL_BLENDMODE_BLEND;
2212  }
2214  return SDL_BLENDMODE_ADD;
2215  }
2217  return SDL_BLENDMODE_MOD;
2218  }
2219  return blendMode;
2220 }
2221 
2222 static SDL_BlendMode
2224 {
2225  if (blendMode == SDL_BLENDMODE_NONE) {
2226  return SDL_BLENDMODE_NONE_FULL;
2227  }
2228  if (blendMode == SDL_BLENDMODE_BLEND) {
2229  return SDL_BLENDMODE_BLEND_FULL;
2230  }
2231  if (blendMode == SDL_BLENDMODE_ADD) {
2232  return SDL_BLENDMODE_ADD_FULL;
2233  }
2234  if (blendMode == SDL_BLENDMODE_MOD) {
2235  return SDL_BLENDMODE_MOD_FULL;
2236  }
2237  return blendMode;
2238 }
2239 
2242  SDL_BlendOperation colorOperation,
2243  SDL_BlendFactor srcAlphaFactor, SDL_BlendFactor dstAlphaFactor,
2244  SDL_BlendOperation alphaOperation)
2245 {
2246  SDL_BlendMode blendMode = SDL_COMPOSE_BLENDMODE(srcColorFactor, dstColorFactor, colorOperation,
2247  srcAlphaFactor, dstAlphaFactor, alphaOperation);
2249 }
2250 
2253 {
2255  return (SDL_BlendFactor)(((Uint32)blendMode >> 4) & 0xF);
2256 }
2257 
2260 {
2262  return (SDL_BlendFactor)(((Uint32)blendMode >> 8) & 0xF);
2263 }
2264 
2267 {
2269  return (SDL_BlendOperation)(((Uint32)blendMode >> 0) & 0xF);
2270 }
2271 
2274 {
2276  return (SDL_BlendFactor)(((Uint32)blendMode >> 20) & 0xF);
2277 }
2278 
2281 {
2283  return (SDL_BlendFactor)(((Uint32)blendMode >> 24) & 0xF);
2284 }
2285 
2288 {
2290  return (SDL_BlendOperation)(((Uint32)blendMode >> 16) & 0xF);
2291 }
2292 
2293 /* vi: set ts=4 sw=4 expandtab: */
SDL_SetRenderDrawBlendMode
int SDL_SetRenderDrawBlendMode(SDL_Renderer *renderer, SDL_BlendMode blendMode)
Set the blend mode used for drawing operations (Fill and Line).
Definition: SDL_render.c:1581
SDL_zero
#define SDL_zero(x)
Definition: SDL_stdinc.h:416
DirectFB_RenderDriver
SDL_RenderDriver DirectFB_RenderDriver
SDL_UnlockSurface
#define SDL_UnlockSurface
Definition: SDL_dynapi_overrides.h:449
SDL_Texture::native
SDL_Texture * native
Definition: SDL_sysrender.h:72
SDL_SetRenderTarget
int SDL_SetRenderTarget(SDL_Renderer *renderer, SDL_Texture *texture)
Set a texture as the current rendering target.
Definition: SDL_render.c:1210
SDL_Renderer::blendMode
SDL_BlendMode blendMode
Definition: SDL_sysrender.h:179
SW_CreateRendererForSurface
SDL_Renderer * SW_CreateRendererForSurface(SDL_Surface *surface)
Definition: SDL_render_sw.c:126
format
GLint GLint GLsizei GLsizei GLsizei GLint GLenum format
Definition: SDL_opengl.h:1572
SDL_RenderDrawLine
int SDL_RenderDrawLine(SDL_Renderer *renderer, int x1, int y1, int x2, int y2)
Draw a line on the current rendering target.
Definition: SDL_render.c:1692
points
GLfixed GLfixed GLint GLint GLfixed points
Definition: SDL_opengl_glext.h:4558
Uint8
uint8_t Uint8
Definition: SDL_stdinc.h:179
SDL_Point::x
int x
Definition: SDL_rect.h:50
SDL_UnlockTexture
void SDL_UnlockTexture(SDL_Texture *texture)
Unlock a texture, uploading the changes to video memory, if needed.
Definition: SDL_render.c:1181
SDL_Renderer::GL_UnbindTexture
int(* GL_UnbindTexture)(SDL_Renderer *renderer, SDL_Texture *texture)
Definition: SDL_sysrender.h:133
SDL_HINT_RENDER_VSYNC
#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
SDL_CreateTexture
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:541
SDL_Renderer::clip_rect_backup
SDL_Rect clip_rect_backup
Definition: SDL_sysrender.h:160
SDL_GL_UnbindTexture
int SDL_GL_UnbindTexture(SDL_Texture *texture)
Unbind a texture from the current OpenGL/ES/ES2 context.
Definition: SDL_render.c:2167
scale
GLenum GLenum GLenum GLenum GLenum scale
Definition: SDL_opengl_glext.h:9375
SDL_GetWindowData
#define SDL_GetWindowData
Definition: SDL_dynapi_overrides.h:523
SDL_render.h
SDL_RenderSetIntegerScale
int SDL_RenderSetIntegerScale(SDL_Renderer *renderer, SDL_bool enable)
Set whether to force integer scales for resolution-independent rendering.
Definition: SDL_render.c:1435
blendMode
static SDL_BlendMode blendMode
Definition: testdraw2.c:34
SDL_SetTextureAlphaMod
int SDL_SetTextureAlphaMod(SDL_Texture *texture, Uint8 alpha)
Set an additional alpha value used in render copy operations.
Definition: SDL_render.c:788
SDL_Surface
A collection of pixels used in software blitting.
Definition: SDL_surface.h:70
SDL_HasIntersection
#define SDL_HasIntersection
Definition: SDL_dynapi_overrides.h:293
SDL_Renderer::UpdateClipRect
int(* UpdateClipRect)(SDL_Renderer *renderer)
Definition: SDL_sysrender.h:112
SDL_UpdateTextureYUV
static int SDL_UpdateTextureYUV(SDL_Texture *texture, const SDL_Rect *rect, const void *pixels, int pitch)
Definition: SDL_render.c:854
SDL_Renderer::GetMetalLayer
void *(* GetMetalLayer)(SDL_Renderer *renderer)
Definition: SDL_sysrender.h:135
SDL_WINDOW_MINIMIZED
@ SDL_WINDOW_MINIMIZED
Definition: SDL_video.h:106
SDL_RenderPresent
void SDL_RenderPresent(SDL_Renderer *renderer)
Update the screen with rendering performed.
Definition: SDL_render.c:2077
IsSupportedBlendMode
static SDL_bool IsSupportedBlendMode(SDL_Renderer *renderer, SDL_BlendMode blendMode)
Definition: SDL_render.c:469
GLES2_RenderDriver
SDL_RenderDriver GLES2_RenderDriver
SDL_RenderGetScale
void SDL_RenderGetScale(SDL_Renderer *renderer, float *scaleX, float *scaleY)
Get the drawing scale for the current target.
Definition: SDL_render.c:1534
SDL_RenderTargetSupported
SDL_bool SDL_RenderTargetSupported(SDL_Renderer *renderer)
Determines whether a window supports the use of render targets.
Definition: SDL_render.c:1201
SDL_TEXTUREMODULATE_COLOR
@ SDL_TEXTUREMODULATE_COLOR
Definition: SDL_render.h:104
SDL_LockMutex
#define SDL_LockMutex
Definition: SDL_dynapi_overrides.h:260
window_w
int window_w
Definition: testoverlay2.c:143
SDL_fabs
#define SDL_fabs
Definition: SDL_dynapi_overrides.h:430
SDL_FPoint::x
float x
Definition: SDL_sysrender.h:44
SDL_ceil
#define SDL_ceil
Definition: SDL_dynapi_overrides.h:426
SDL_FRect::h
float h
Definition: SDL_sysrender.h:53
NULL
#define NULL
Definition: begin_code.h:164
SDL_ScaleModeNearest
@ SDL_ScaleModeNearest
Definition: SDL_sysrender.h:37
surface
EGLSurface surface
Definition: eglext.h:248
SDL_PixelFormat::format
Uint32 format
Definition: SDL_pixels.h:317
b
GLboolean GLboolean GLboolean b
Definition: SDL_opengl_glext.h:1109
SDL_Renderer::SetRenderTarget
int(* SetRenderTarget)(SDL_Renderer *renderer, SDL_Texture *texture)
Definition: SDL_sysrender.h:110
enable
GLboolean enable
Definition: SDL_opengl_glext.h:4996
width
GLint GLint GLsizei width
Definition: SDL_opengl.h:1572
RenderDrawLinesWithRects
static int RenderDrawLinesWithRects(SDL_Renderer *renderer, const SDL_Point *points, int count)
Definition: SDL_render.c:1704
SDL_Surface::pixels
void * pixels
Definition: SDL_surface.h:75
SDL_CreateSoftwareRenderer
SDL_Renderer * SDL_CreateSoftwareRenderer(SDL_Surface *surface)
Create a 2D software rendering context for a surface.
Definition: SDL_render.c:413
g
GLboolean GLboolean g
Definition: SDL_opengl_glext.h:1109
access
GLuint GLint GLboolean GLint GLenum access
Definition: SDL_opengl_glext.h:2162
SDL_ScaleModeBest
@ SDL_ScaleModeBest
Definition: SDL_sysrender.h:39
render_drivers
static const SDL_RenderDriver * render_drivers[]
Definition: SDL_render.c:76
SDL_RenderGetIntegerScale
SDL_bool SDL_RenderGetIntegerScale(SDL_Renderer *renderer)
Get whether integer scales are forced for resolution-independent rendering.
Definition: SDL_render.c:1445
SDL_log.h
SDL_Renderer::g
Uint8 g
Definition: SDL_sysrender.h:178
SDL_UpdateTextureNative
static int SDL_UpdateTextureNative(SDL_Texture *texture, const SDL_Rect *rect, const void *pixels, int pitch)
Definition: SDL_render.c:900
SDL_COMPOSE_BLENDMODE
#define SDL_COMPOSE_BLENDMODE(srcColorFactor, dstColorFactor, colorOperation, srcAlphaFactor, dstAlphaFactor, alphaOperation)
Definition: SDL_render.c:50
SDL_render_sw_c.h
count
GLuint GLuint GLsizei count
Definition: SDL_opengl.h:1571
SDL_BLENDMODE_BLEND
@ SDL_BLENDMODE_BLEND
Definition: SDL_blendmode.h:44
SDL_UnlockTextureNative
static void SDL_UnlockTextureNative(SDL_Texture *texture)
Definition: SDL_render.c:1160
SDL_SW_LockYUVTexture
int SDL_SW_LockYUVTexture(SDL_SW_YUVTexture *swdata, const SDL_Rect *rect, void **pixels, int *pitch)
Definition: SDL_yuv_sw.c:302
SDL_Renderer::SetTextureBlendMode
int(* SetTextureBlendMode)(SDL_Renderer *renderer, SDL_Texture *texture)
Definition: SDL_sysrender.h:97
SDL_GetWindowFlags
#define SDL_GetWindowFlags
Definition: SDL_dynapi_overrides.h:518
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.
Definition: SDL_render.c:1916
SDLCALL
#define SDLCALL
Definition: SDL_internal.h:45
SDL_Renderer::hidden
SDL_bool hidden
Definition: SDL_sysrender.h:143
SDL_Renderer::scale
SDL_FPoint scale
Definition: SDL_sysrender.h:167
SDL_HINT_RENDER_SCALE_QUALITY
#define SDL_HINT_RENDER_SCALE_QUALITY
A variable controlling the scaling quality.
Definition: SDL_hints.h:143
r
GLdouble GLdouble GLdouble r
Definition: SDL_opengl.h:2079
SDL_MOUSEBUTTONUP
@ SDL_MOUSEBUTTONUP
Definition: SDL_events.h:107
SDL_ConvertSurface
#define SDL_ConvertSurface
Definition: SDL_dynapi_overrides.h:463
SDL_BlendOperation
SDL_BlendOperation
The blend operation used when combining source and destination pixel components.
Definition: SDL_blendmode.h:63
SDL_InvalidParamError
#define SDL_InvalidParamError(param)
Definition: SDL_error.h:54
viewport
SDL_Rect viewport
Definition: testviewport.c:28
SDL_CreateMutex
#define SDL_CreateMutex
Definition: SDL_dynapi_overrides.h:259
SDL_WINDOWPOS_UNDEFINED
#define SDL_WINDOWPOS_UNDEFINED
Definition: SDL_video.h:130
SDL_MUSTLOCK
#define SDL_MUSTLOCK(S)
Definition: SDL_surface.h:61
SDL_IntersectRect
#define SDL_IntersectRect
Definition: SDL_dynapi_overrides.h:294
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)
Definition: SDL_render.c:977
SDL_floor
#define SDL_floor
Definition: SDL_dynapi_overrides.h:431
SDL_Renderer::RenderFillRects
int(* RenderFillRects)(SDL_Renderer *renderer, const SDL_FRect *rects, int count)
Definition: SDL_sysrender.h:118
SDL_RenderClear
int SDL_RenderClear(SDL_Renderer *renderer)
Clear the current rendering target with the drawing color.
Definition: SDL_render.c:1602
SDL_RenderDriver
Definition: SDL_sysrender.h:186
SDL_RenderFillRect
int SDL_RenderFillRect(SDL_Renderer *renderer, const SDL_Rect *rect)
Fill a rectangle on the current rendering target with the drawing color.
Definition: SDL_render.c:1859
SDL_FRect::x
float x
Definition: SDL_sysrender.h:50
Uint32
uint32_t Uint32
Definition: SDL_stdinc.h:203
SDL_ISPIXELFORMAT_INDEXED
#define SDL_ISPIXELFORMAT_INDEXED(format)
Definition: SDL_pixels.h:134
SDL_Renderer::UpdateViewport
int(* UpdateViewport)(SDL_Renderer *renderer)
Definition: SDL_sysrender.h:111
SDL_Renderer::dpi_scale
SDL_FPoint dpi_scale
Definition: SDL_sysrender.h:171
SDL_Renderer::textures
SDL_Texture * textures
Definition: SDL_sysrender.h:174
SDL_RenderIsClipEnabled
SDL_bool SDL_RenderIsClipEnabled(SDL_Renderer *renderer)
Get whether clipping is enabled on the given renderer.
Definition: SDL_render.c:1517
SDL_Renderer::WindowEvent
void(* WindowEvent)(SDL_Renderer *renderer, const SDL_WindowEvent *event)
Definition: SDL_sysrender.h:89
SDL_GetRendererOutputSize
int SDL_GetRendererOutputSize(SDL_Renderer *renderer, int *w, int *h)
Get the output size in pixels of a rendering context.
Definition: SDL_render.c:451
SDL_BlendFactor
SDL_BlendFactor
The normalized factor used to multiply pixel components.
Definition: SDL_blendmode.h:76
GLES_RenderDriver
SDL_RenderDriver GLES_RenderDriver
index
GLuint index
Definition: SDL_opengl_glext.h:660
SDL_GetRenderTarget
SDL_Texture * SDL_GetRenderTarget(SDL_Renderer *renderer)
Get the current render target or NULL for the default render target.
Definition: SDL_render.c:1287
SDL_FPoint::y
float y
Definition: SDL_sysrender.h:45
x1
GLuint GLfloat GLfloat GLfloat x1
Definition: SDL_opengl_glext.h:8583
a
GLboolean GLboolean GLboolean GLboolean a
Definition: SDL_opengl_glext.h:1109
SDL_ScaleModeLinear
@ SDL_ScaleModeLinear
Definition: SDL_sysrender.h:38
SDL_GetHint
#define SDL_GetHint
Definition: SDL_dynapi_overrides.h:191
SDL_CreateWindow
#define SDL_CreateWindow
Definition: SDL_dynapi_overrides.h:514
renderer_magic
static char renderer_magic
Definition: SDL_render.c:105
h
GLfloat GLfloat GLfloat GLfloat h
Definition: SDL_opengl_glext.h:1946
SDL_Renderer::target_mutex
SDL_mutex * target_mutex
Definition: SDL_sysrender.h:176
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.
Definition: SDL_render.c:1108
SDL_GetSurfaceBlendMode
#define SDL_GetSurfaceBlendMode
Definition: SDL_dynapi_overrides.h:460
SDL_QueryTexture
int SDL_QueryTexture(SDL_Texture *texture, Uint32 *format, int *access, int *w, int *h)
Query the attributes of a texture.
Definition: SDL_render.c:724
SDL_Rect::x
int x
Definition: SDL_rect.h:66
SDL_CreateRenderer
SDL_Renderer * SDL_CreateRenderer(SDL_Window *window, int index, Uint32 flags)
Create a 2D rendering context for a window.
Definition: SDL_render.c:304
SDL_Renderer::logical_w
int logical_w
Definition: SDL_sysrender.h:146
SDL_Renderer::viewport_backup
SDL_Rect viewport_backup
Definition: SDL_sysrender.h:156
SDL_RendererInfo
Information on the capabilities of a render driver or context.
Definition: SDL_render.h:79
SDL_DestroyRenderer
void SDL_DestroyRenderer(SDL_Renderer *renderer)
Destroy the rendering context for a window and free associated textures.
Definition: SDL_render.c:2124
SDL_RenderSetLogicalSize
int SDL_RenderSetLogicalSize(SDL_Renderer *renderer, int w, int h)
Set device independent resolution for rendering.
Definition: SDL_render.c:1402
SDL_AllocFormat
#define SDL_AllocFormat
Definition: SDL_dynapi_overrides.h:280
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).
Definition: SDL_render.c:1560
SDL_Texture::prev
SDL_Texture * prev
Definition: SDL_sysrender.h:80
SDL_GetNumRenderDrivers
int SDL_GetNumRenderDrivers(void)
Get the number of 2D rendering drivers available for the current display.
Definition: SDL_render.c:111
SDL_Rect::w
int w
Definition: SDL_rect.h:67
SDL_Window
The type used to identify a window.
Definition: SDL_sysvideo.h:74
SDL_stack_alloc
#define SDL_stack_alloc(type, count)
Definition: SDL_stdinc.h:354
maxY
GLfloat GLfloat GLfloat GLfloat GLfloat maxY
Definition: gl2ext.h:446
n
GLdouble n
Definition: SDL_opengl_glext.h:1952
SDL_RenderGetViewport
void SDL_RenderGetViewport(SDL_Renderer *renderer, SDL_Rect *rect)
Get the drawing area for the current target.
Definition: SDL_render.c:1473
SDL_strcasecmp
#define SDL_strcasecmp
Definition: SDL_dynapi_overrides.h:419
alpha
GLfloat GLfloat GLfloat alpha
Definition: SDL_opengl_glext.h:412
SDL_CreateTextureFromSurface
SDL_Texture * SDL_CreateTextureFromSurface(SDL_Renderer *renderer, SDL_Surface *surface)
Create a texture from an existing surface.
Definition: SDL_render.c:636
SDL_WINDOWEVENT_SHOWN
@ SDL_WINDOWEVENT_SHOWN
Definition: SDL_video.h:149
SDL_RenderDriver::CreateRenderer
SDL_Renderer *(* CreateRenderer)(SDL_Window *window, Uint32 flags)
Definition: SDL_sysrender.h:187
SDL_GetWindowSize
#define SDL_GetWindowSize
Definition: SDL_dynapi_overrides.h:527
SDL_SW_CopyYUVToRGB
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
SDL_FINGERUP
@ SDL_FINGERUP
Definition: SDL_events.h:129
SDL_LockTextureNative
static int SDL_LockTextureNative(SDL_Texture *texture, const SDL_Rect *rect, void **pixels, int *pitch)
Definition: SDL_render.c:1096
SDL_Surface::pitch
int pitch
Definition: SDL_surface.h:74
SDL_Renderer::viewport
SDL_Rect viewport
Definition: SDL_sysrender.h:155
RenderDrawPointsWithRects
static int RenderDrawPointsWithRects(SDL_Renderer *renderer, const SDL_Point *points, int count)
Definition: SDL_render.c:1624
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.
Definition: SDL_render.c:1028
SDL_PIXELFORMAT_YV12
@ SDL_PIXELFORMAT_YV12
Definition: SDL_pixels.h:277
SDL_RenderSetScale
int SDL_RenderSetScale(SDL_Renderer *renderer, float scaleX, float scaleY)
Set the drawing scale for rendering on the current target.
Definition: SDL_render.c:1524
SDL_GetHintBoolean
#define SDL_GetHintBoolean
Definition: SDL_dynapi_overrides.h:608
event
struct _cl_event * event
Definition: SDL_opengl_glext.h:2649
D3D11_RenderDriver
SDL_RenderDriver D3D11_RenderDriver
SDL_Renderer
Definition: SDL_sysrender.h:86
SDL_MOUSEMOTION
@ SDL_MOUSEMOTION
Definition: SDL_events.h:105
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.
Definition: SDL_render.c:2152
SDL_FPoint
Definition: SDL_sysrender.h:43
SDL_BLENDMODE_ADD_FULL
#define SDL_BLENDMODE_ADD_FULL
Definition: SDL_render.c:67
SDL_FRect::y
float y
Definition: SDL_sysrender.h:51
SDL_Renderer::integer_scale
SDL_bool integer_scale
Definition: SDL_sysrender.h:152
SDL_FINGERDOWN
@ SDL_FINGERDOWN
Definition: SDL_events.h:128
SDL_Renderer::b
Uint8 b
Definition: SDL_sysrender.h:178
SDL_RenderGetLogicalSize
void SDL_RenderGetLogicalSize(SDL_Renderer *renderer, int *w, int *h)
Get device independent resolution for rendering.
Definition: SDL_render.c:1422
SDL_FRect::w
float w
Definition: SDL_sysrender.h:52
SDL_Renderer::scale_backup
SDL_FPoint scale_backup
Definition: SDL_sysrender.h:168
x
GLint GLint GLint GLint GLint x
Definition: SDL_opengl.h:1574
window_h
int window_h
Definition: testoverlay2.c:144
window
EGLSurface EGLNativeWindowType * window
Definition: eglext.h:1025
SDL_SetWindowData
#define SDL_SetWindowData
Definition: SDL_dynapi_overrides.h:522
SDL_Renderer::SetTextureColorMod
int(* SetTextureColorMod)(SDL_Renderer *renderer, SDL_Texture *texture)
Definition: SDL_sysrender.h:93
SDL_RendererInfo::flags
Uint32 flags
Definition: SDL_render.h:81
D3D_RenderDriver
SDL_RenderDriver D3D_RenderDriver
SDL_Rect::y
int y
Definition: SDL_rect.h:66
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.
Definition: SDL_render.c:941
SDL_BLENDMODE_MOD_FULL
#define SDL_BLENDMODE_MOD_FULL
Definition: SDL_render.c:71
SDL_Rect::h
int h
Definition: SDL_rect.h:67
SDL_Renderer::logical_h_backup
int logical_h_backup
Definition: SDL_sysrender.h:149
SDL_free
#define SDL_free
Definition: SDL_dynapi_overrides.h:377
minY
GLfloat minY
Definition: gl2ext.h:446
f
GLfloat f
Definition: SDL_opengl_glext.h:1870
SDL_TEXTUREACCESS_STATIC
@ SDL_TEXTUREACCESS_STATIC
Definition: SDL_render.h:93
SDL_FLIP_NONE
@ SDL_FLIP_NONE
Definition: SDL_render.h:113
SDL_BLENDMODE_NONE
@ SDL_BLENDMODE_NONE
Definition: SDL_blendmode.h:42
height
GLint GLint GLsizei GLsizei height
Definition: SDL_opengl.h:1572
SDL_max
#define SDL_max(x, y)
Definition: SDL_stdinc.h:407
SDL_Renderer::SupportsBlendMode
SDL_bool(* SupportsBlendMode)(SDL_Renderer *renderer, SDL_BlendMode blendMode)
Definition: SDL_sysrender.h:91
SDL_CreateWindowAndRenderer
int SDL_CreateWindowAndRenderer(int width, int height, Uint32 window_flags, SDL_Window **window, SDL_Renderer **renderer)
Create a window and default renderer.
Definition: SDL_render.c:284
UpdateLogicalSize
static int UpdateLogicalSize(SDL_Renderer *renderer)
Definition: SDL_render.c:1293
SDL_RENDERER_PRESENTVSYNC
@ SDL_RENDERER_PRESENTVSYNC
Definition: SDL_render.h:69
SDL_RenderGetMetalLayer
void * SDL_RenderGetMetalLayer(SDL_Renderer *renderer)
Get the CAMetalLayer associated with the given Metal renderer.
Definition: SDL_render.c:2183
SDL_DestroyTexture
void SDL_DestroyTexture(SDL_Texture *texture)
Destroy the specified texture.
Definition: SDL_render.c:2089
rect
SDL_Rect rect
Definition: testrelative.c:27
SDL_FreeSurface
#define SDL_FreeSurface
Definition: SDL_dynapi_overrides.h:446
SDL_Renderer::RenderDrawLines
int(* RenderDrawLines)(SDL_Renderer *renderer, const SDL_FPoint *points, int count)
Definition: SDL_sysrender.h:116
SDL_LockTextureYUV
static int SDL_LockTextureYUV(SDL_Texture *texture, const SDL_Rect *rect, void **pixels, int *pitch)
Definition: SDL_render.c:1089
SDL_ScaleMode
SDL_ScaleMode
Definition: SDL_sysrender.h:36
SDL_sysrender.h
SDL_GetWindowFromID
#define SDL_GetWindowFromID
Definition: SDL_dynapi_overrides.h:517
SDL_assert.h
SDL_SW_DestroyYUVTexture
void SDL_SW_DestroyYUVTexture(SDL_SW_YUVTexture *swdata)
Definition: SDL_yuv_sw.c:404
SDL_Renderer::RenderClear
int(* RenderClear)(SDL_Renderer *renderer)
Definition: SDL_sysrender.h:113
SDL_min
#define SDL_min(x, y)
Definition: SDL_stdinc.h:406
SDL_FINGERMOTION
@ SDL_FINGERMOTION
Definition: SDL_events.h:130
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.
Definition: SDL_render.c:2241
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.
Definition: SDL_render.c:2040
SDL_GetTextureColorMod
int SDL_GetTextureColorMod(SDL_Texture *texture, Uint8 *r, Uint8 *g, Uint8 *b)
Get the additional color value used in render copy operations.
Definition: SDL_render.c:770
SDL_UnlockTextureYUV
static void SDL_UnlockTextureYUV(SDL_Texture *texture)
Definition: SDL_render.c:1139
SDL_FreeFormat
#define SDL_FreeFormat
Definition: SDL_dynapi_overrides.h:281
SDL_PixelFormat::Amask
Uint32 Amask
Definition: SDL_pixels.h:325
SDL_GetBlendModeDstAlphaFactor
SDL_BlendFactor SDL_GetBlendModeDstAlphaFactor(SDL_BlendMode blendMode)
Definition: SDL_render.c:2280
SDL_Texture::next
SDL_Texture * next
Definition: SDL_sysrender.h:81
SDL_WINDOWEVENT_SIZE_CHANGED
@ SDL_WINDOWEVENT_SIZE_CHANGED
Definition: SDL_video.h:156
SDL_Renderer::GL_BindTexture
int(* GL_BindTexture)(SDL_Renderer *renderer, SDL_Texture *texture, float *texw, float *texh)
Definition: SDL_sysrender.h:132
SDL_TRUE
@ SDL_TRUE
Definition: SDL_stdinc.h:164
SDL_PixelFormat
Definition: SDL_pixels.h:316
SDL_PIXELFORMAT_IYUV
@ SDL_PIXELFORMAT_IYUV
Definition: SDL_pixels.h:279
SDL_Renderer::RenderDrawPoints
int(* RenderDrawPoints)(SDL_Renderer *renderer, const SDL_FPoint *points, int count)
Definition: SDL_sysrender.h:114
SDL_HINT_RENDER_LOGICAL_SIZE_MODE
#define SDL_HINT_RENDER_LOGICAL_SIZE_MODE
A variable controlling the scaling policy for SDL_RenderSetLogicalSize.
Definition: SDL_hints.h:131
SDL_SW_UpdateYUVTexturePlanar
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
GetWindowViewportValues
static void GetWindowViewportValues(SDL_Renderer *renderer, int *logical_w, int *logical_h, SDL_Rect *viewport, SDL_FPoint *scale)
Definition: SDL_render.c:135
SDL_RenderSetClipRect
int SDL_RenderSetClipRect(SDL_Renderer *renderer, const SDL_Rect *rect)
Set the clip rectangle for the current target.
Definition: SDL_render.c:1486
SDL_TEXTUREMODULATE_ALPHA
@ SDL_TEXTUREMODULATE_ALPHA
Definition: SDL_render.h:105
SDL_assert
#define SDL_assert(condition)
Definition: SDL_assert.h:169
SDL_GetRenderDrawBlendMode
int SDL_GetRenderDrawBlendMode(SDL_Renderer *renderer, SDL_BlendMode *blendMode)
Get the blend mode used for drawing operations.
Definition: SDL_render.c:1593
SDL_WINDOWEVENT_MINIMIZED
@ SDL_WINDOWEVENT_MINIMIZED
Definition: SDL_video.h:159
pixels
GLint GLint GLsizei GLsizei GLsizei GLint GLenum GLenum const GLvoid * pixels
Definition: SDL_opengl.h:1572
SDL_Renderer::GetOutputSize
int(* GetOutputSize)(SDL_Renderer *renderer, int *w, int *h)
Definition: SDL_sysrender.h:90
SDL_RenderDrawPoint
int SDL_RenderDrawPoint(SDL_Renderer *renderer, int x, int y)
Draw a point on the current rendering target.
Definition: SDL_render.c:1614
maxX
GLfloat GLfloat GLfloat GLfloat maxX
Definition: gl2ext.h:446
SDL_Renderer::RenderCopy
int(* RenderCopy)(SDL_Renderer *renderer, SDL_Texture *texture, const SDL_Rect *srcrect, const SDL_FRect *dstrect)
Definition: SDL_sysrender.h:120
SDL_OutOfMemory
#define SDL_OutOfMemory()
Definition: SDL_error.h:52
SDL_Renderer::SetTextureAlphaMod
int(* SetTextureAlphaMod)(SDL_Renderer *renderer, SDL_Texture *texture)
Definition: SDL_sysrender.h:95
SDL_Renderer::CreateTexture
int(* CreateTexture)(SDL_Renderer *renderer, SDL_Texture *texture)
Definition: SDL_sysrender.h:92
y
GLint GLint GLint GLint GLint GLint y
Definition: SDL_opengl.h:1574
SDL_LOG_CATEGORY_RENDER
@ SDL_LOG_CATEGORY_RENDER
Definition: SDL_log.h:72
SDL_Texture::format
Uint32 format
Definition: SDL_sysrender.h:60
SDL_LockSurface
#define SDL_LockSurface
Definition: SDL_dynapi_overrides.h:448
SDL_Renderer::DestroyRenderer
void(* DestroyRenderer)(SDL_Renderer *renderer)
Definition: SDL_sysrender.h:130
SDL_Renderer::LockTexture
int(* LockTexture)(SDL_Renderer *renderer, SDL_Texture *texture, const SDL_Rect *rect, void **pixels, int *pitch)
Definition: SDL_sysrender.h:107
SDL_Renderer::GetMetalCommandEncoder
void *(* GetMetalCommandEncoder)(SDL_Renderer *renderer)
Definition: SDL_sysrender.h:136
SDL_SW_CreateYUVTexture
SDL_SW_YUVTexture * SDL_SW_CreateYUVTexture(Uint32 format, int w, int h)
Definition: SDL_yuv_sw.c:31
SDL_GetSurfaceAlphaMod
#define SDL_GetSurfaceAlphaMod
Definition: SDL_dynapi_overrides.h:458
SDL_arraysize
#define SDL_arraysize(array)
Definition: SDL_stdinc.h:115
SDL_calloc
#define SDL_calloc
Definition: SDL_dynapi_overrides.h:375
SDL_atoi
#define SDL_atoi
Definition: SDL_dynapi_overrides.h:410
SDL_GetLongBlendMode
static SDL_BlendMode SDL_GetLongBlendMode(SDL_BlendMode blendMode)
Definition: SDL_render.c:2223
SDL_Renderer::logical_h
int logical_h
Definition: SDL_sysrender.h:147
SDL_LogInfo
#define SDL_LogInfo
Definition: SDL_dynapi_overrides.h:34
SDL_Renderer::RenderReadPixels
int(* RenderReadPixels)(SDL_Renderer *renderer, const SDL_Rect *rect, Uint32 format, void *pixels, int pitch)
Definition: SDL_sysrender.h:125
SDL_GetBlendModeSrcAlphaFactor
SDL_BlendFactor SDL_GetBlendModeSrcAlphaFactor(SDL_BlendMode blendMode)
Definition: SDL_render.c:2273
SDL_GetBlendModeColorOperation
SDL_BlendOperation SDL_GetBlendModeColorOperation(SDL_BlendMode blendMode)
Definition: SDL_render.c:2266
SDL_Renderer::RenderCopyEx
int(* RenderCopyEx)(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_sysrender.h:122
SDL_RendererFlip
SDL_RendererFlip
Flip constants for SDL_RenderCopyEx.
Definition: SDL_render.h:112
SW_RenderDriver
SDL_RenderDriver SW_RenderDriver
Definition: SDL_render_sw.c:78
renderer
static SDL_Renderer * renderer
Definition: testaudiocapture.c:21
SDL_WINDOW_HIDDEN
@ SDL_WINDOW_HIDDEN
Definition: SDL_video.h:103
SDL_GetCurrentVideoDriver
#define SDL_GetCurrentVideoDriver
Definition: SDL_dynapi_overrides.h:500
SDL_stack_free
#define SDL_stack_free(data)
Definition: SDL_stdinc.h:355
SDL_ISPIXELFORMAT_FOURCC
#define SDL_ISPIXELFORMAT_FOURCC(format)
Definition: SDL_pixels.h:167
SDL_GetRenderer
SDL_Renderer * SDL_GetRenderer(SDL_Window *window)
Get the renderer associated with a window.
Definition: SDL_render.c:436
SDL_GetBlendModeDstColorFactor
SDL_BlendFactor SDL_GetBlendModeDstColorFactor(SDL_BlendMode blendMode)
Definition: SDL_render.c:2259
SDL_Point
The structure that defines a point.
Definition: SDL_rect.h:49
SDL_Renderer::info
SDL_RendererInfo info
Definition: SDL_sysrender.h:139
SDL_RENDERER_TARGETTEXTURE
@ SDL_RENDERER_TARGETTEXTURE
Definition: SDL_render.h:71
SDL_GetWindowPixelFormat
#define SDL_GetWindowPixelFormat
Definition: SDL_dynapi_overrides.h:513
x2
GLfixed GLfixed x2
Definition: SDL_opengl_glext.h:4583
CHECK_TEXTURE_MAGIC
#define CHECK_TEXTURE_MAGIC(texture, retval)
Definition: SDL_render.c:42
SDL_GetTextureAlphaMod
int SDL_GetTextureAlphaMod(SDL_Texture *texture, Uint8 *alpha)
Get the additional alpha value used in render copy operations.
Definition: SDL_render.c:811
SDL_SetError
#define SDL_SetError
Definition: SDL_dynapi_overrides.h:30
SDL_Renderer::RenderPresent
void(* RenderPresent)(SDL_Renderer *renderer)
Definition: SDL_sysrender.h:127
SDL_BYTESPERPIXEL
#define SDL_BYTESPERPIXEL(X)
Definition: SDL_pixels.h:128
SDL_RenderSetViewport
int SDL_RenderSetViewport(SDL_Renderer *renderer, const SDL_Rect *rect)
Set the drawing area for rendering on the current target.
Definition: SDL_render.c:1453
SDL_RenderDrawPoints
int SDL_RenderDrawPoints(SDL_Renderer *renderer, const SDL_Point *points, int count)
Draw multiple points on the current rendering target.
Definition: SDL_render.c:1650
SDL_Rect
A rectangle, with the origin at the upper left.
Definition: SDL_rect.h:65
SDL_RendererInfo::max_texture_width
int max_texture_width
Definition: SDL_render.h:84
METAL_RenderDriver
SDL_RenderDriver METAL_RenderDriver
SDL_GetScaleMode
static SDL_ScaleMode SDL_GetScaleMode(void)
Definition: SDL_render.c:525
IsSupportedFormat
static SDL_bool IsSupportedFormat(SDL_Renderer *renderer, Uint32 format)
Definition: SDL_render.c:486
SDL_Texture
Definition: SDL_sysrender.h:58
SDL_Renderer::UpdateTexture
int(* UpdateTexture)(SDL_Renderer *renderer, SDL_Texture *texture, const SDL_Rect *rect, const void *pixels, int pitch)
Definition: SDL_sysrender.h:99
SDL_hints.h
SDL_TEXTUREACCESS_TARGET
@ SDL_TEXTUREACCESS_TARGET
Definition: SDL_render.h:95
y1
GLfixed y1
Definition: SDL_opengl_glext.h:4583
SDL_BLENDMODE_BLEND_FULL
#define SDL_BLENDMODE_BLEND_FULL
Definition: SDL_render.c:63
SDL_DestroyMutex
#define SDL_DestroyMutex
Definition: SDL_dynapi_overrides.h:263
SDL_AddEventWatch
#define SDL_AddEventWatch
Definition: SDL_dynapi_overrides.h:128
SDL_RendererEventWatch
static int SDL_RendererEventWatch(void *userdata, SDL_Event *event)
Definition: SDL_render.c:146
SDL_FRect
Definition: SDL_sysrender.h:49
y2
GLfixed GLfixed GLfixed y2
Definition: SDL_opengl_glext.h:4583
SDL_GetSurfaceColorMod
#define SDL_GetSurfaceColorMod
Definition: SDL_dynapi_overrides.h:456
SDL_RenderDriver::info
SDL_RendererInfo info
Definition: SDL_sysrender.h:190
SDL_ConvertPixels
#define SDL_ConvertPixels
Definition: SDL_dynapi_overrides.h:465
SDL_RenderGetClipRect
void SDL_RenderGetClipRect(SDL_Renderer *renderer, SDL_Rect *rect)
Get the clip rectangle for the current target.
Definition: SDL_render.c:1504
SDL_MOUSEBUTTONDOWN
@ SDL_MOUSEBUTTONDOWN
Definition: SDL_events.h:106
angle
GLfloat angle
Definition: SDL_opengl_glext.h:6097
SDL_Renderer::logical_w_backup
int logical_w_backup
Definition: SDL_sysrender.h:148
SDL_Renderer::clipping_enabled
SDL_bool clipping_enabled
Definition: SDL_sysrender.h:163
SDL_Renderer::magic
const void * magic
Definition: SDL_sysrender.h:87
SDL_bool
SDL_bool
Definition: SDL_stdinc.h:162
SDL_RendererInfo::name
const char * name
Definition: SDL_render.h:80
SDL_BLENDMODE_NONE_FULL
#define SDL_BLENDMODE_NONE_FULL
Definition: SDL_render.c:59
SDL_WINDOWEVENT_HIDDEN
@ SDL_WINDOWEVENT_HIDDEN
Definition: SDL_video.h:150
SDL_SetTextureColorMod
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:745
CHECK_RENDERER_MAGIC
#define CHECK_RENDERER_MAGIC(renderer, retval)
Definition: SDL_render.c:35
SDL_Event
General event structure.
Definition: SDL_events.h:558
SDL_WINDOWEVENT
@ SDL_WINDOWEVENT
Definition: SDL_events.h:92
SDL_HINT_RENDER_DRIVER
#define SDL_HINT_RENDER_DRIVER
A variable specifying which render driver to use.
Definition: SDL_hints.h:85
SDL_WINDOWEVENT_RESTORED
@ SDL_WINDOWEVENT_RESTORED
Definition: SDL_video.h:161
SDL_ISPIXELFORMAT_ALPHA
#define SDL_ISPIXELFORMAT_ALPHA(format)
Definition: SDL_pixels.h:154
SDL_FALSE
@ SDL_FALSE
Definition: SDL_stdinc.h:163
SDL_Renderer::r
Uint8 r
Definition: SDL_sysrender.h:178
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.
Definition: SDL_render.c:1876
SDL_Unsupported
#define SDL_Unsupported()
Definition: SDL_error.h:53
SDL_Renderer::a
Uint8 a
Definition: SDL_sysrender.h:178
SDL_SetTextureBlendMode
int SDL_SetTextureBlendMode(SDL_Texture *texture, SDL_BlendMode blendMode)
Set the blend mode used for texture copy operations.
Definition: SDL_render.c:822
SDL_malloc
#define SDL_malloc
Definition: SDL_dynapi_overrides.h:374
SDL_RendererInfo::texture_formats
Uint32 texture_formats[16]
Definition: SDL_render.h:83
SDL_RendererInfo::max_texture_height
int max_texture_height
Definition: SDL_render.h:85
SDL_GetRenderDriverInfo
int SDL_GetRenderDriverInfo(int index, SDL_RendererInfo *info)
Get information about a specific 2D rendering driver for the current display.
Definition: SDL_render.c:121
void
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
Definition: SDL_dynapi_procs.h:89
SDL_UnlockMutex
#define SDL_UnlockMutex
Definition: SDL_dynapi_overrides.h:262
flags
GLbitfield flags
Definition: SDL_opengl_glext.h:1480
SDL_GetTextureBlendMode
int SDL_GetTextureBlendMode(SDL_Texture *texture, SDL_BlendMode *blendMode)
Get the blend mode used for texture copy operations.
Definition: SDL_render.c:843
SDL_Renderer::window
SDL_Window * window
Definition: SDL_sysrender.h:142
SDL_TEXTUREACCESS_STREAMING
@ SDL_TEXTUREACCESS_STREAMING
Definition: SDL_render.h:94
SDL_Renderer::target
SDL_Texture * target
Definition: SDL_sysrender.h:175
texture
GLenum GLenum GLuint texture
Definition: SDL_opengl_glext.h:1178
texture_magic
static char texture_magic
Definition: SDL_render.c:106
SDL_RenderDrawRects
int SDL_RenderDrawRects(SDL_Renderer *renderer, const SDL_Rect *rects, int count)
Draw some number of rectangles on the current rendering target.
Definition: SDL_render.c:1831
rects
EGLSurface EGLint * rects
Definition: eglext.h:282
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...
Definition: SDL_render.c:1969
SDL_GetBlendModeAlphaOperation
SDL_BlendOperation SDL_GetBlendModeAlphaOperation(SDL_BlendMode blendMode)
Definition: SDL_render.c:2287
i
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
SDL_RenderDrawRect
int SDL_RenderDrawRect(SDL_Renderer *renderer, const SDL_Rect *rect)
Draw a rectangle on the current rendering target.
Definition: SDL_render.c:1802
GL_RenderDriver
SDL_RenderDriver GL_RenderDriver
SDL_GetBlendModeSrcColorFactor
SDL_BlendFactor SDL_GetBlendModeSrcColorFactor(SDL_BlendMode blendMode)
Definition: SDL_render.c:2252
SDL_Renderer::clipping_enabled_backup
SDL_bool clipping_enabled_backup
Definition: SDL_sysrender.h:164
PSP_RenderDriver
SDL_RenderDriver PSP_RenderDriver
SDL_BLENDMODE_MOD
@ SDL_BLENDMODE_MOD
Definition: SDL_blendmode.h:50
SDL_GetRendererInfo
int SDL_GetRendererInfo(SDL_Renderer *renderer, SDL_RendererInfo *info)
Get information about a rendering context.
Definition: SDL_render.c:442
SDL_HasColorKey
#define SDL_HasColorKey
Definition: SDL_dynapi_overrides.h:699
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.
Definition: SDL_render.c:1760
SDL_Renderer::clip_rect
SDL_Rect clip_rect
Definition: SDL_sysrender.h:159
SDL_RenderGetMetalCommandEncoder
void * SDL_RenderGetMetalCommandEncoder(SDL_Renderer *renderer)
Get the Metal command encoder for the current frame.
Definition: SDL_render.c:2194
SDL_Point::y
int y
Definition: SDL_rect.h:51
SDL_WINDOWEVENT_MAXIMIZED
@ SDL_WINDOWEVENT_MAXIMIZED
Definition: SDL_video.h:160
SDL_BLENDMODE_ADD
@ SDL_BLENDMODE_ADD
Definition: SDL_blendmode.h:47
SDL_BlendMode
SDL_BlendMode
The blend mode used in SDL_RenderCopy() and drawing operations.
Definition: SDL_blendmode.h:41
SDL_WINDOWRENDERDATA
#define SDL_WINDOWRENDERDATA
Definition: SDL_render.c:33
GetClosestSupportedFormat
static Uint32 GetClosestSupportedFormat(SDL_Renderer *renderer, Uint32 format)
Definition: SDL_render.c:499
SDL_Renderer::UnlockTexture
void(* UnlockTexture)(SDL_Renderer *renderer, SDL_Texture *texture)
Definition: SDL_sysrender.h:109
SDL_RendererInfo::num_texture_formats
Uint32 num_texture_formats
Definition: SDL_render.h:82
SDL_DelEventWatch
#define SDL_DelEventWatch
Definition: SDL_dynapi_overrides.h:129
SDL_GetShortBlendMode
static SDL_BlendMode SDL_GetShortBlendMode(SDL_BlendMode blendMode)
Definition: SDL_render.c:2205
SDL_SW_UpdateYUVTexture
int SDL_SW_UpdateYUVTexture(SDL_SW_YUVTexture *swdata, const SDL_Rect *rect, const void *pixels, int pitch)
Definition: SDL_yuv_sw.c:139
SDL_Renderer::DestroyTexture
void(* DestroyTexture)(SDL_Renderer *renderer, SDL_Texture *texture)
Definition: SDL_sysrender.h:128
SDL_Renderer::UpdateTextureYUV
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)
Definition: SDL_sysrender.h:102
w
GLubyte GLubyte GLubyte GLubyte w
Definition: SDL_opengl_glext.h:731
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).
Definition: SDL_render.c:1547