SDL  2.0
SDL_render_sw.c
Go to the documentation of this file.
1 /*
2  Simple DirectMedia Layer
3  Copyright (C) 1997-2019 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 #if !SDL_RENDER_DISABLED
24 
25 #include "../SDL_sysrender.h"
26 #include "SDL_render_sw_c.h"
27 #include "SDL_hints.h"
28 #include "SDL_assert.h"
29 
30 #include "SDL_draw.h"
31 #include "SDL_blendfillrect.h"
32 #include "SDL_blendline.h"
33 #include "SDL_blendpoint.h"
34 #include "SDL_drawline.h"
35 #include "SDL_drawpoint.h"
36 #include "SDL_rotate.h"
37 
38 /* SDL surface based renderer implementation */
39 
40 typedef struct
41 {
46 
47 typedef struct
48 {
52 
53 
54 static SDL_Surface *
56 {
58 
59  if (!data->surface) {
60  data->surface = data->window;
61  }
62  if (!data->surface) {
64  if (surface) {
65  data->surface = data->window = surface;
66  }
67  }
68  return data->surface;
69 }
70 
71 static void
73 {
75 
76  if (event->event == SDL_WINDOWEVENT_SIZE_CHANGED) {
77  data->surface = NULL;
78  data->window = NULL;
79  }
80 }
81 
82 static int
84 {
86 
87  if (data->surface) {
88  if (w) {
89  *w = data->surface->w;
90  }
91  if (h) {
92  *h = data->surface->h;
93  }
94  return 0;
95  }
96 
97  if (renderer->window) {
99  return 0;
100  }
101 
102  SDL_SetError("Software renderer doesn't have an output surface");
103  return -1;
104 }
105 
106 static int
108 {
109  int bpp;
110  Uint32 Rmask, Gmask, Bmask, Amask;
111 
113  (texture->format, &bpp, &Rmask, &Gmask, &Bmask, &Amask)) {
114  return SDL_SetError("Unknown texture format");
115  }
116 
117  texture->driverdata =
118  SDL_CreateRGBSurface(0, texture->w, texture->h, bpp, Rmask, Gmask,
119  Bmask, Amask);
120  SDL_SetSurfaceColorMod(texture->driverdata, texture->r, texture->g,
121  texture->b);
122  SDL_SetSurfaceAlphaMod(texture->driverdata, texture->a);
123  SDL_SetSurfaceBlendMode(texture->driverdata, texture->blendMode);
124 
125  /* Only RLE encode textures without an alpha channel since the RLE coder
126  * discards the color values of pixels with an alpha value of zero.
127  */
128  if (texture->access == SDL_TEXTUREACCESS_STATIC && !Amask) {
129  SDL_SetSurfaceRLE(texture->driverdata, 1);
130  }
131 
132  if (!texture->driverdata) {
133  return -1;
134  }
135  return 0;
136 }
137 
138 static int
140  const SDL_Rect * rect, const void *pixels, int pitch)
141 {
142  SDL_Surface *surface = (SDL_Surface *) texture->driverdata;
143  Uint8 *src, *dst;
144  int row;
145  size_t length;
146 
147  if(SDL_MUSTLOCK(surface))
149  src = (Uint8 *) pixels;
150  dst = (Uint8 *) surface->pixels +
151  rect->y * surface->pitch +
152  rect->x * surface->format->BytesPerPixel;
153  length = rect->w * surface->format->BytesPerPixel;
154  for (row = 0; row < rect->h; ++row) {
156  src += pitch;
157  dst += surface->pitch;
158  }
159  if(SDL_MUSTLOCK(surface))
161  return 0;
162 }
163 
164 static int
166  const SDL_Rect * rect, void **pixels, int *pitch)
167 {
168  SDL_Surface *surface = (SDL_Surface *) texture->driverdata;
169 
170  *pixels =
171  (void *) ((Uint8 *) surface->pixels + rect->y * surface->pitch +
172  rect->x * surface->format->BytesPerPixel);
173  *pitch = surface->pitch;
174  return 0;
175 }
176 
177 static void
179 {
180 }
181 
182 static int
184 {
186 
187  if (texture) {
188  data->surface = (SDL_Surface *) texture->driverdata;
189  } else {
190  data->surface = data->window;
191  }
192  return 0;
193 }
194 
195 static int
197 {
198  return 0; /* nothing to do in this backend. */
199 }
200 
201 static int
203 {
204  SDL_Point *verts = (SDL_Point *) SDL_AllocateRenderVertices(renderer, count * sizeof (SDL_Point), 0, &cmd->data.draw.first);
205  int i;
206 
207  if (!verts) {
208  return -1;
209  }
210 
211  cmd->data.draw.count = count;
212 
213  if (renderer->viewport.x || renderer->viewport.y) {
214  const int x = renderer->viewport.x;
215  const int y = renderer->viewport.y;
216  for (i = 0; i < count; i++, verts++, points++) {
217  verts->x = (int)(x + points->x);
218  verts->y = (int)(y + points->y);
219  }
220  } else {
221  for (i = 0; i < count; i++, verts++, points++) {
222  verts->x = (int)points->x;
223  verts->y = (int)points->y;
224  }
225  }
226 
227  return 0;
228 }
229 
230 static int
232 {
233  SDL_Rect *verts = (SDL_Rect *) SDL_AllocateRenderVertices(renderer, count * sizeof (SDL_Rect), 0, &cmd->data.draw.first);
234  int i;
235 
236  if (!verts) {
237  return -1;
238  }
239 
240  cmd->data.draw.count = count;
241 
242  if (renderer->viewport.x || renderer->viewport.y) {
243  const int x = renderer->viewport.x;
244  const int y = renderer->viewport.y;
245 
246  for (i = 0; i < count; i++, verts++, rects++) {
247  verts->x = (int)(x + rects->x);
248  verts->y = (int)(y + rects->y);
249  verts->w = SDL_max((int)rects->w, 1);
250  verts->h = SDL_max((int)rects->h, 1);
251  }
252  } else {
253  for (i = 0; i < count; i++, verts++, rects++) {
254  verts->x = (int)rects->x;
255  verts->y = (int)rects->y;
256  verts->w = SDL_max((int)rects->w, 1);
257  verts->h = SDL_max((int)rects->h, 1);
258  }
259  }
260 
261  return 0;
262 }
263 
264 static int
266  const SDL_Rect * srcrect, const SDL_FRect * dstrect)
267 {
268  SDL_Rect *verts = (SDL_Rect *) SDL_AllocateRenderVertices(renderer, 2 * sizeof (SDL_Rect), 0, &cmd->data.draw.first);
269 
270  if (!verts) {
271  return -1;
272  }
273 
274  cmd->data.draw.count = 1;
275 
276  SDL_memcpy(verts, srcrect, sizeof (SDL_Rect));
277  verts++;
278 
279  if (renderer->viewport.x || renderer->viewport.y) {
280  verts->x = (int)(renderer->viewport.x + dstrect->x);
281  verts->y = (int)(renderer->viewport.y + dstrect->y);
282  } else {
283  verts->x = (int)dstrect->x;
284  verts->y = (int)dstrect->y;
285  }
286  verts->w = (int)dstrect->w;
287  verts->h = (int)dstrect->h;
288 
289  return 0;
290 }
291 
292 typedef struct CopyExData
293 {
296  double angle;
299 } CopyExData;
300 
301 static int
303  const SDL_Rect * srcrect, const SDL_FRect * dstrect,
304  const double angle, const SDL_FPoint *center, const SDL_RendererFlip flip)
305 {
306  CopyExData *verts = (CopyExData *) SDL_AllocateRenderVertices(renderer, sizeof (CopyExData), 0, &cmd->data.draw.first);
307 
308  if (!verts) {
309  return -1;
310  }
311 
312  cmd->data.draw.count = 1;
313 
314  SDL_memcpy(&verts->srcrect, srcrect, sizeof (SDL_Rect));
315 
316  if (renderer->viewport.x || renderer->viewport.y) {
317  verts->dstrect.x = (int)(renderer->viewport.x + dstrect->x);
318  verts->dstrect.y = (int)(renderer->viewport.y + dstrect->y);
319  } else {
320  verts->dstrect.x = (int)dstrect->x;
321  verts->dstrect.y = (int)dstrect->y;
322  }
323  verts->dstrect.w = (int)dstrect->w;
324  verts->dstrect.h = (int)dstrect->h;
325  verts->angle = angle;
326  SDL_memcpy(&verts->center, center, sizeof (SDL_FPoint));
327  verts->flip = flip;
328 
329  return 0;
330 }
331 
332 static int
334  const SDL_Rect * srcrect, const SDL_Rect * final_rect,
335  const double angle, const SDL_FPoint * center, const SDL_RendererFlip flip)
336 {
337  SDL_Surface *src = (SDL_Surface *) texture->driverdata;
338  SDL_Rect tmp_rect;
339  SDL_Surface *src_clone, *src_rotated, *src_scaled;
340  SDL_Surface *mask = NULL, *mask_rotated = NULL;
341  int retval = 0, dstwidth, dstheight, abscenterx, abscentery;
342  double cangle, sangle, px, py, p1x, p1y, p2x, p2y, p3x, p3y, p4x, p4y;
343  SDL_BlendMode blendmode;
344  Uint8 alphaMod, rMod, gMod, bMod;
345  int applyModulation = SDL_FALSE;
346  int blitRequired = SDL_FALSE;
347  int isOpaque = SDL_FALSE;
348 
349  if (!surface) {
350  return -1;
351  }
352 
353  tmp_rect.x = 0;
354  tmp_rect.y = 0;
355  tmp_rect.w = final_rect->w;
356  tmp_rect.h = final_rect->h;
357 
358  /* It is possible to encounter an RLE encoded surface here and locking it is
359  * necessary because this code is going to access the pixel buffer directly.
360  */
361  if (SDL_MUSTLOCK(src)) {
363  }
364 
365  /* Clone the source surface but use its pixel buffer directly.
366  * The original source surface must be treated as read-only.
367  */
368  src_clone = SDL_CreateRGBSurfaceFrom(src->pixels, src->w, src->h, src->format->BitsPerPixel, src->pitch,
369  src->format->Rmask, src->format->Gmask,
370  src->format->Bmask, src->format->Amask);
371  if (src_clone == NULL) {
372  if (SDL_MUSTLOCK(src)) {
374  }
375  return -1;
376  }
377 
378  SDL_GetSurfaceBlendMode(src, &blendmode);
379  SDL_GetSurfaceAlphaMod(src, &alphaMod);
380  SDL_GetSurfaceColorMod(src, &rMod, &gMod, &bMod);
381 
382  /* SDLgfx_rotateSurface only accepts 32-bit surfaces with a 8888 layout. Everything else has to be converted. */
383  if (src->format->BitsPerPixel != 32 || SDL_PIXELLAYOUT(src->format->format) != SDL_PACKEDLAYOUT_8888 || !src->format->Amask) {
384  blitRequired = SDL_TRUE;
385  }
386 
387  /* If scaling and cropping is necessary, it has to be taken care of before the rotation. */
388  if (!(srcrect->w == final_rect->w && srcrect->h == final_rect->h && srcrect->x == 0 && srcrect->y == 0)) {
389  blitRequired = SDL_TRUE;
390  }
391 
392  /* srcrect is not selecting the whole src surface, so cropping is needed */
393  if (!(srcrect->w == src->w && srcrect->h == src->h && srcrect->x == 0 && srcrect->y == 0)) {
394  blitRequired = SDL_TRUE;
395  }
396 
397  /* The color and alpha modulation has to be applied before the rotation when using the NONE and MOD blend modes. */
398  if ((blendmode == SDL_BLENDMODE_NONE || blendmode == SDL_BLENDMODE_MOD) && (alphaMod & rMod & gMod & bMod) != 255) {
399  applyModulation = SDL_TRUE;
400  SDL_SetSurfaceAlphaMod(src_clone, alphaMod);
401  SDL_SetSurfaceColorMod(src_clone, rMod, gMod, bMod);
402  }
403 
404  /* Opaque surfaces are much easier to handle with the NONE blend mode. */
405  if (blendmode == SDL_BLENDMODE_NONE && !src->format->Amask && alphaMod == 255) {
406  isOpaque = SDL_TRUE;
407  }
408 
409  /* The NONE blend mode requires a mask for non-opaque surfaces. This mask will be used
410  * to clear the pixels in the destination surface. The other steps are explained below.
411  */
412  if (blendmode == SDL_BLENDMODE_NONE && !isOpaque) {
413  mask = SDL_CreateRGBSurface(0, final_rect->w, final_rect->h, 32,
414  0x00ff0000, 0x0000ff00, 0x000000ff, 0xff000000);
415  if (mask == NULL) {
416  retval = -1;
417  } else {
419  }
420  }
421 
422  /* Create a new surface should there be a format mismatch or if scaling, cropping,
423  * or modulation is required. It's possible to use the source surface directly otherwise.
424  */
425  if (!retval && (blitRequired || applyModulation)) {
426  SDL_Rect scale_rect = tmp_rect;
427  src_scaled = SDL_CreateRGBSurface(0, final_rect->w, final_rect->h, 32,
428  0x00ff0000, 0x0000ff00, 0x000000ff, 0xff000000);
429  if (src_scaled == NULL) {
430  retval = -1;
431  } else {
433  retval = SDL_BlitScaled(src_clone, srcrect, src_scaled, &scale_rect);
434  SDL_FreeSurface(src_clone);
435  src_clone = src_scaled;
436  src_scaled = NULL;
437  }
438  }
439 
440  /* SDLgfx_rotateSurface is going to make decisions depending on the blend mode. */
441  SDL_SetSurfaceBlendMode(src_clone, blendmode);
442 
443  if (!retval) {
444  SDLgfx_rotozoomSurfaceSizeTrig(tmp_rect.w, tmp_rect.h, angle, &dstwidth, &dstheight, &cangle, &sangle);
445  src_rotated = SDLgfx_rotateSurface(src_clone, angle, dstwidth/2, dstheight/2, (texture->scaleMode == SDL_ScaleModeNearest) ? 0 : 1, flip & SDL_FLIP_HORIZONTAL, flip & SDL_FLIP_VERTICAL, dstwidth, dstheight, cangle, sangle);
446  if (src_rotated == NULL) {
447  retval = -1;
448  }
449  if (!retval && mask != NULL) {
450  /* The mask needed for the NONE blend mode gets rotated with the same parameters. */
451  mask_rotated = SDLgfx_rotateSurface(mask, angle, dstwidth/2, dstheight/2, SDL_FALSE, 0, 0, dstwidth, dstheight, cangle, sangle);
452  if (mask_rotated == NULL) {
453  retval = -1;
454  }
455  }
456  if (!retval) {
457  /* Find out where the new origin is by rotating the four final_rect points around the center and then taking the extremes */
458  abscenterx = final_rect->x + (int)center->x;
459  abscentery = final_rect->y + (int)center->y;
460  /* Compensate the angle inversion to match the behaviour of the other backends */
461  sangle = -sangle;
462 
463  /* Top Left */
464  px = final_rect->x - abscenterx;
465  py = final_rect->y - abscentery;
466  p1x = px * cangle - py * sangle + abscenterx;
467  p1y = px * sangle + py * cangle + abscentery;
468 
469  /* Top Right */
470  px = final_rect->x + final_rect->w - abscenterx;
471  py = final_rect->y - abscentery;
472  p2x = px * cangle - py * sangle + abscenterx;
473  p2y = px * sangle + py * cangle + abscentery;
474 
475  /* Bottom Left */
476  px = final_rect->x - abscenterx;
477  py = final_rect->y + final_rect->h - abscentery;
478  p3x = px * cangle - py * sangle + abscenterx;
479  p3y = px * sangle + py * cangle + abscentery;
480 
481  /* Bottom Right */
482  px = final_rect->x + final_rect->w - abscenterx;
483  py = final_rect->y + final_rect->h - abscentery;
484  p4x = px * cangle - py * sangle + abscenterx;
485  p4y = px * sangle + py * cangle + abscentery;
486 
487  tmp_rect.x = (int)MIN(MIN(p1x, p2x), MIN(p3x, p4x));
488  tmp_rect.y = (int)MIN(MIN(p1y, p2y), MIN(p3y, p4y));
489  tmp_rect.w = dstwidth;
490  tmp_rect.h = dstheight;
491 
492  /* The NONE blend mode needs some special care with non-opaque surfaces.
493  * Other blend modes or opaque surfaces can be blitted directly.
494  */
495  if (blendmode != SDL_BLENDMODE_NONE || isOpaque) {
496  if (applyModulation == SDL_FALSE) {
497  /* If the modulation wasn't already applied, make it happen now. */
498  SDL_SetSurfaceAlphaMod(src_rotated, alphaMod);
499  SDL_SetSurfaceColorMod(src_rotated, rMod, gMod, bMod);
500  }
501  retval = SDL_BlitSurface(src_rotated, NULL, surface, &tmp_rect);
502  } else {
503  /* The NONE blend mode requires three steps to get the pixels onto the destination surface.
504  * First, the area where the rotated pixels will be blitted to get set to zero.
505  * This is accomplished by simply blitting a mask with the NONE blend mode.
506  * The colorkey set by the rotate function will discard the correct pixels.
507  */
508  SDL_Rect mask_rect = tmp_rect;
510  retval = SDL_BlitSurface(mask_rotated, NULL, surface, &mask_rect);
511  if (!retval) {
512  /* The next step copies the alpha value. This is done with the BLEND blend mode and
513  * by modulating the source colors with 0. Since the destination is all zeros, this
514  * will effectively set the destination alpha to the source alpha.
515  */
516  SDL_SetSurfaceColorMod(src_rotated, 0, 0, 0);
517  mask_rect = tmp_rect;
518  retval = SDL_BlitSurface(src_rotated, NULL, surface, &mask_rect);
519  if (!retval) {
520  /* The last step gets the color values in place. The ADD blend mode simply adds them to
521  * the destination (where the color values are all zero). However, because the ADD blend
522  * mode modulates the colors with the alpha channel, a surface without an alpha mask needs
523  * to be created. This makes all source pixels opaque and the colors get copied correctly.
524  */
525  SDL_Surface *src_rotated_rgb;
526  src_rotated_rgb = SDL_CreateRGBSurfaceFrom(src_rotated->pixels, src_rotated->w, src_rotated->h,
527  src_rotated->format->BitsPerPixel, src_rotated->pitch,
528  src_rotated->format->Rmask, src_rotated->format->Gmask,
529  src_rotated->format->Bmask, 0);
530  if (src_rotated_rgb == NULL) {
531  retval = -1;
532  } else {
533  SDL_SetSurfaceBlendMode(src_rotated_rgb, SDL_BLENDMODE_ADD);
534  retval = SDL_BlitSurface(src_rotated_rgb, NULL, surface, &tmp_rect);
535  SDL_FreeSurface(src_rotated_rgb);
536  }
537  }
538  }
539  SDL_FreeSurface(mask_rotated);
540  }
541  if (src_rotated != NULL) {
542  SDL_FreeSurface(src_rotated);
543  }
544  }
545  }
546 
547  if (SDL_MUSTLOCK(src)) {
549  }
550  if (mask != NULL) {
552  }
553  if (src_clone != NULL) {
554  SDL_FreeSurface(src_clone);
555  }
556  return retval;
557 }
558 
559 static void
561 {
562  const Uint8 r = cmd->data.draw.r;
563  const Uint8 g = cmd->data.draw.g;
564  const Uint8 b = cmd->data.draw.b;
565  const Uint8 a = cmd->data.draw.a;
566  const SDL_BlendMode blend = cmd->data.draw.blend;
567  SDL_Texture *texture = cmd->data.draw.texture;
568  SDL_Surface *surface = (SDL_Surface *) texture->driverdata;
569  const SDL_bool colormod = ((r & g & b) != 0xFF);
570  const SDL_bool alphamod = (a != 0xFF);
571  const SDL_bool blending = ((blend == SDL_BLENDMODE_ADD) || (blend == SDL_BLENDMODE_MOD));
572 
573  if (colormod || alphamod || blending) {
575  }
576 
577  /* !!! FIXME: we can probably avoid some of these calls. */
581 }
582 
583 static void
585 {
586  if (drawstate->surface_cliprect_dirty) {
587  const SDL_Rect *viewport = drawstate->viewport;
588  const SDL_Rect *cliprect = drawstate->cliprect;
589  SDL_assert(viewport != NULL); /* the higher level should have forced a SDL_RENDERCMD_SETVIEWPORT */
590 
591  if (cliprect != NULL) {
592  SDL_Rect clip_rect;
593  clip_rect.x = cliprect->x + viewport->x;
594  clip_rect.y = cliprect->y + viewport->y;
595  clip_rect.w = cliprect->w;
596  clip_rect.h = cliprect->h;
597  SDL_IntersectRect(viewport, &clip_rect, &clip_rect);
598  SDL_SetClipRect(surface, &clip_rect);
599  } else {
600  SDL_SetClipRect(surface, drawstate->viewport);
601  }
602  drawstate->surface_cliprect_dirty = SDL_FALSE;
603  }
604 }
605 
606 static int
607 SW_RunCommandQueue(SDL_Renderer * renderer, SDL_RenderCommand *cmd, void *vertices, size_t vertsize)
608 {
610  SW_DrawStateCache drawstate;
611 
612  if (!surface) {
613  return -1;
614  }
615 
616  drawstate.viewport = NULL;
617  drawstate.cliprect = NULL;
618  drawstate.surface_cliprect_dirty = SDL_TRUE;
619 
620  while (cmd) {
621  switch (cmd->command) {
623  break; /* Not used in this backend. */
624  }
625 
627  drawstate.viewport = &cmd->data.viewport.rect;
628  drawstate.surface_cliprect_dirty = SDL_TRUE;
629  break;
630  }
631 
633  drawstate.cliprect = cmd->data.cliprect.enabled ? &cmd->data.cliprect.rect : NULL;
634  drawstate.surface_cliprect_dirty = SDL_TRUE;
635  break;
636  }
637 
638  case SDL_RENDERCMD_CLEAR: {
639  const Uint8 r = cmd->data.color.r;
640  const Uint8 g = cmd->data.color.g;
641  const Uint8 b = cmd->data.color.b;
642  const Uint8 a = cmd->data.color.a;
643  /* By definition the clear ignores the clip rect */
645  SDL_FillRect(surface, NULL, SDL_MapRGBA(surface->format, r, g, b, a));
646  drawstate.surface_cliprect_dirty = SDL_TRUE;
647  break;
648  }
649 
651  const Uint8 r = cmd->data.draw.r;
652  const Uint8 g = cmd->data.draw.g;
653  const Uint8 b = cmd->data.draw.b;
654  const Uint8 a = cmd->data.draw.a;
655  const int count = (int) cmd->data.draw.count;
656  const SDL_Point *verts = (SDL_Point *) (((Uint8 *) vertices) + cmd->data.draw.first);
657  const SDL_BlendMode blend = cmd->data.draw.blend;
658  SetDrawState(surface, &drawstate);
659  if (blend == SDL_BLENDMODE_NONE) {
660  SDL_DrawPoints(surface, verts, count, SDL_MapRGBA(surface->format, r, g, b, a));
661  } else {
662  SDL_BlendPoints(surface, verts, count, blend, r, g, b, a);
663  }
664  break;
665  }
666 
668  const Uint8 r = cmd->data.draw.r;
669  const Uint8 g = cmd->data.draw.g;
670  const Uint8 b = cmd->data.draw.b;
671  const Uint8 a = cmd->data.draw.a;
672  const int count = (int) cmd->data.draw.count;
673  const SDL_Point *verts = (SDL_Point *) (((Uint8 *) vertices) + cmd->data.draw.first);
674  const SDL_BlendMode blend = cmd->data.draw.blend;
675  SetDrawState(surface, &drawstate);
676  if (blend == SDL_BLENDMODE_NONE) {
677  SDL_DrawLines(surface, verts, count, SDL_MapRGBA(surface->format, r, g, b, a));
678  } else {
679  SDL_BlendLines(surface, verts, count, blend, r, g, b, a);
680  }
681  break;
682  }
683 
685  const Uint8 r = cmd->data.draw.r;
686  const Uint8 g = cmd->data.draw.g;
687  const Uint8 b = cmd->data.draw.b;
688  const Uint8 a = cmd->data.draw.a;
689  const int count = (int) cmd->data.draw.count;
690  const SDL_Rect *verts = (SDL_Rect *) (((Uint8 *) vertices) + cmd->data.draw.first);
691  const SDL_BlendMode blend = cmd->data.draw.blend;
692  SetDrawState(surface, &drawstate);
693  if (blend == SDL_BLENDMODE_NONE) {
694  SDL_FillRects(surface, verts, count, SDL_MapRGBA(surface->format, r, g, b, a));
695  } else {
696  SDL_BlendFillRects(surface, verts, count, blend, r, g, b, a);
697  }
698  break;
699  }
700 
701  case SDL_RENDERCMD_COPY: {
702  SDL_Rect *verts = (SDL_Rect *) (((Uint8 *) vertices) + cmd->data.draw.first);
703  const SDL_Rect *srcrect = verts;
704  SDL_Rect *dstrect = verts + 1;
705  SDL_Texture *texture = cmd->data.draw.texture;
706  SDL_Surface *src = (SDL_Surface *) texture->driverdata;
707 
708  SetDrawState(surface, &drawstate);
709 
710  PrepTextureForCopy(cmd);
711 
712  if ( srcrect->w == dstrect->w && srcrect->h == dstrect->h ) {
713  SDL_BlitSurface(src, srcrect, surface, dstrect);
714  } else {
715  /* If scaling is ever done, permanently disable RLE (which doesn't support scaling)
716  * to avoid potentially frequent RLE encoding/decoding.
717  */
719  SDL_BlitScaled(src, srcrect, surface, dstrect);
720  }
721  break;
722  }
723 
724  case SDL_RENDERCMD_COPY_EX: {
725  const CopyExData *copydata = (CopyExData *) (((Uint8 *) vertices) + cmd->data.draw.first);
726  SetDrawState(surface, &drawstate);
727  PrepTextureForCopy(cmd);
728  SW_RenderCopyEx(renderer, surface, cmd->data.draw.texture, &copydata->srcrect,
729  &copydata->dstrect, copydata->angle, &copydata->center, copydata->flip);
730  break;
731  }
732 
733  case SDL_RENDERCMD_NO_OP:
734  break;
735  }
736 
737  cmd = cmd->next;
738  }
739 
740  return 0;
741 }
742 
743 static int
745  Uint32 format, void * pixels, int pitch)
746 {
748  Uint32 src_format;
749  void *src_pixels;
750 
751  if (!surface) {
752  return -1;
753  }
754 
755  /* NOTE: The rect is already adjusted according to the viewport by
756  * SDL_RenderReadPixels.
757  */
758 
759  if (rect->x < 0 || rect->x+rect->w > surface->w ||
760  rect->y < 0 || rect->y+rect->h > surface->h) {
761  return SDL_SetError("Tried to read outside of surface bounds");
762  }
763 
764  src_format = surface->format->format;
765  src_pixels = (void*)((Uint8 *) surface->pixels +
766  rect->y * surface->pitch +
767  rect->x * surface->format->BytesPerPixel);
768 
769  return SDL_ConvertPixels(rect->w, rect->h,
770  src_format, src_pixels, surface->pitch,
771  format, pixels, pitch);
772 }
773 
774 static void
776 {
778 
779  if (window) {
781  }
782 }
783 
784 static void
786 {
787  SDL_Surface *surface = (SDL_Surface *) texture->driverdata;
788 
790 }
791 
792 static void
794 {
796 
797  SDL_free(data);
799 }
800 
801 SDL_Renderer *
803 {
806 
807  if (!surface) {
808  SDL_SetError("Can't create renderer for NULL surface");
809  return NULL;
810  }
811 
812  renderer = (SDL_Renderer *) SDL_calloc(1, sizeof(*renderer));
813  if (!renderer) {
814  SDL_OutOfMemory();
815  return NULL;
816  }
817 
818  data = (SW_RenderData *) SDL_calloc(1, sizeof(*data));
819  if (!data) {
821  SDL_OutOfMemory();
822  return NULL;
823  }
824  data->surface = surface;
825  data->window = surface;
826 
835  renderer->QueueSetDrawColor = SW_QueueSetViewport; /* SetViewport and SetDrawColor are (currently) no-ops. */
837  renderer->QueueDrawLines = SW_QueueDrawPoints; /* lines and points queue vertices the same way. */
848 
850 
851  return renderer;
852 }
853 
854 static SDL_Renderer *
856 {
858 
860  if (!surface) {
861  return NULL;
862  }
864 }
865 
868  {
869  "software",
871  8,
872  {
881  },
882  0,
883  0}
884 };
885 
886 #endif /* !SDL_RENDER_DISABLED */
887 
888 /* vi: set ts=4 sw=4 expandtab: */
SDL_UnlockSurface
#define SDL_UnlockSurface
Definition: SDL_dynapi_overrides.h:449
SW_CreateRendererForSurface
SDL_Renderer * SW_CreateRendererForSurface(SDL_Surface *surface)
Definition: SDL_render_sw.c:802
format
GLint GLint GLsizei GLsizei GLsizei GLint GLenum format
Definition: SDL_opengl.h:1571
SW_DestroyTexture
static void SW_DestroyTexture(SDL_Renderer *renderer, SDL_Texture *texture)
Definition: SDL_render_sw.c:785
points
GLfixed GLfixed GLint GLint GLfixed points
Definition: SDL_opengl_glext.h:4558
SW_RenderCopyEx
static int SW_RenderCopyEx(SDL_Renderer *renderer, SDL_Surface *surface, SDL_Texture *texture, const SDL_Rect *srcrect, const SDL_Rect *final_rect, const double angle, const SDL_FPoint *center, const SDL_RendererFlip flip)
Definition: SDL_render_sw.c:333
SDL_blendline.h
mask
GLenum GLint GLuint mask
Definition: SDL_opengl_glext.h:657
SDL_MapRGBA
#define SDL_MapRGBA
Definition: SDL_dynapi_overrides.h:287
SDL_Surface
A collection of pixels used in software blitting.
Definition: SDL_surface.h:70
SDL_RenderCommand::color
struct SDL_RenderCommand::@30::@34 color
PrepTextureForCopy
static void PrepTextureForCopy(const SDL_RenderCommand *cmd)
Definition: SDL_render_sw.c:560
SDL_Renderer::QueueCopyEx
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)
Definition: SDL_sysrender.h:140
SDL_BlendFillRects
int SDL_BlendFillRects(SDL_Surface *dst, const SDL_Rect *rects, int count, SDL_BlendMode blendMode, Uint8 r, Uint8 g, Uint8 b, Uint8 a)
Definition: SDL_blendfillrect.c:263
SW_CreateRenderer
static SDL_Renderer * SW_CreateRenderer(SDL_Window *window, Uint32 flags)
Definition: SDL_render_sw.c:855
SDL_PIXELFORMAT_RGB888
Definition: SDL_pixels.h:236
SDL_AllocateRenderVertices
void * SDL_AllocateRenderVertices(SDL_Renderer *renderer, const size_t numbytes, const size_t alignment, size_t *offset)
Definition: SDL_render.c:284
SDL_Renderer::RunCommandQueue
int(* RunCommandQueue)(SDL_Renderer *renderer, SDL_RenderCommand *cmd, void *vertices, size_t vertsize)
Definition: SDL_sysrender.h:143
SDL_FPoint::x
float x
Definition: SDL_rect.h:62
SDL_FillRects
#define SDL_FillRects
Definition: SDL_dynapi_overrides.h:467
SDL_FRect::h
float h
Definition: SDL_rect.h:92
NULL
#define NULL
Definition: begin_code.h:167
SDL_ScaleModeNearest
Definition: SDL_sysrender.h:37
surface
EGLSurface surface
Definition: eglext.h:248
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:155
g
GLboolean GLboolean g
Definition: SDL_opengl_glext.h:1109
SDL_PIXELLAYOUT
#define SDL_PIXELLAYOUT(X)
Definition: SDL_pixels.h:126
SW_QueueDrawPoints
static int SW_QueueDrawPoints(SDL_Renderer *renderer, SDL_RenderCommand *cmd, const SDL_FPoint *points, int count)
Definition: SDL_render_sw.c:202
SDL_render_sw_c.h
count
GLuint GLuint GLsizei count
Definition: SDL_opengl.h:1570
SDL_PACKEDLAYOUT_8888
Definition: SDL_pixels.h:112
SDL_RenderCommand::next
struct SDL_RenderCommand * next
Definition: SDL_sysrender.h:110
SDL_PIXELFORMAT_BGR888
Definition: SDL_pixels.h:242
CopyExData::dstrect
SDL_Rect dstrect
Definition: SDL_render_sw.c:295
SW_DrawStateCache::cliprect
const SDL_Rect * cliprect
Definition: SDL_render_sw.c:43
r
GLdouble GLdouble GLdouble r
Definition: SDL_opengl.h:2078
SW_RenderDriver
SDL_RenderDriver SW_RenderDriver
Definition: SDL_render_sw.c:866
viewport
SDL_Rect viewport
Definition: testviewport.c:28
SW_QueueCopy
static int SW_QueueCopy(SDL_Renderer *renderer, SDL_RenderCommand *cmd, SDL_Texture *texture, const SDL_Rect *srcrect, const SDL_FRect *dstrect)
Definition: SDL_render_sw.c:265
SDL_MUSTLOCK
#define SDL_MUSTLOCK(S)
Definition: SDL_surface.h:62
SDL_IntersectRect
#define SDL_IntersectRect
Definition: SDL_dynapi_overrides.h:294
SDL_RenderDriver
Definition: SDL_sysrender.h:236
SDL_FRect::x
float x
Definition: SDL_rect.h:89
SDL_RenderCommand::data
union SDL_RenderCommand::@30 data
SDL_Renderer::WindowEvent
void(* WindowEvent)(SDL_Renderer *renderer, const SDL_WindowEvent *event)
Definition: SDL_sysrender.h:126
SDL_PIXELFORMAT_RGB565
Definition: SDL_pixels.h:224
SDL_FPoint::y
float y
Definition: SDL_rect.h:63
a
GLboolean GLboolean GLboolean GLboolean a
Definition: SDL_opengl_glext.h:1109
SDL_BlendLines
int SDL_BlendLines(SDL_Surface *dst, const SDL_Point *points, int count, SDL_BlendMode blendMode, Uint8 r, Uint8 g, Uint8 b, Uint8 a)
Definition: SDL_blendline.c:733
h
GLfloat GLfloat GLfloat GLfloat h
Definition: SDL_opengl_glext.h:1946
SW_DrawStateCache
Definition: SDL_render_sw.c:40
length
GLuint GLsizei GLsizei * length
Definition: SDL_opengl_glext.h:669
SDL_GetSurfaceBlendMode
#define SDL_GetSurfaceBlendMode
Definition: SDL_dynapi_overrides.h:460
SDL_Rect::x
int x
Definition: SDL_rect.h:79
SDL_RENDERCMD_COPY
Definition: SDL_sysrender.h:82
SW_RenderReadPixels
static int SW_RenderReadPixels(SDL_Renderer *renderer, const SDL_Rect *rect, Uint32 format, void *pixels, int pitch)
Definition: SDL_render_sw.c:744
SDL_RENDERCMD_SETCLIPRECT
Definition: SDL_sysrender.h:76
data
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
Definition: SDL_opengl.h:1973
SDL_Rect::w
int w
Definition: SDL_rect.h:80
SDL_Window
The type used to identify a window.
Definition: SDL_sysvideo.h:73
row
GLenum GLenum void * row
Definition: SDL_opengl_glext.h:3138
SDL_UpdateWindowSurface
#define SDL_UpdateWindowSurface
Definition: SDL_dynapi_overrides.h:541
SDL_BLENDMODE_MOD
Definition: SDL_blendmode.h:50
SDL_BlendPoints
int SDL_BlendPoints(SDL_Surface *dst, const SDL_Point *points, int count, SDL_BlendMode blendMode, Uint8 r, Uint8 g, Uint8 b, Uint8 a)
Definition: SDL_blendpoint.c:257
dst
GLenum GLenum dst
Definition: SDL_opengl_glext.h:1737
SDL_GetWindowSize
#define SDL_GetWindowSize
Definition: SDL_dynapi_overrides.h:527
SDL_Surface::pitch
int pitch
Definition: SDL_surface.h:75
SDL_RENDERER_SOFTWARE
Definition: SDL_render.h:66
SDL_Renderer::viewport
SDL_Rect viewport
Definition: SDL_sysrender.h:186
SDL_CreateRGBSurfaceFrom
#define SDL_CreateRGBSurfaceFrom
Definition: SDL_dynapi_overrides.h:445
SW_QueueFillRects
static int SW_QueueFillRects(SDL_Renderer *renderer, SDL_RenderCommand *cmd, const SDL_FRect *rects, int count)
Definition: SDL_render_sw.c:231
SDL_memcpy
#define SDL_memcpy
Definition: SDL_dynapi_overrides.h:387
Uint8
uint8_t Uint8
Definition: SDL_stdinc.h:179
event
struct _cl_event * event
Definition: SDL_opengl_glext.h:2649
SDL_Renderer
Definition: SDL_sysrender.h:122
SDL_Renderer::QueueSetDrawColor
int(* QueueSetDrawColor)(SDL_Renderer *renderer, SDL_RenderCommand *cmd)
Definition: SDL_sysrender.h:131
SDL_FPoint
The structure that defines a point (floating point)
Definition: SDL_rect.h:60
SDL_Renderer::driverdata
void * driverdata
Definition: SDL_sysrender.h:232
SDL_FRect::y
float y
Definition: SDL_rect.h:90
SDL_DrawPoints
int SDL_DrawPoints(SDL_Surface *dst, const SDL_Point *points, int count, Uint32 color)
Definition: SDL_drawpoint.c:65
SDL_FRect::w
float w
Definition: SDL_rect.h:91
retval
SDL_bool retval
Definition: testgamecontroller.c:65
x
GLint GLint GLint GLint GLint x
Definition: SDL_opengl.h:1573
window
EGLSurface EGLNativeWindowType * window
Definition: eglext.h:1025
CopyExData::angle
double angle
Definition: SDL_render_sw.c:296
SDL_RenderCommand::viewport
struct SDL_RenderCommand::@30::@31 viewport
SDL_Rect::y
int y
Definition: SDL_rect.h:79
SDL_SetSurfaceColorMod
#define SDL_SetSurfaceColorMod
Definition: SDL_dynapi_overrides.h:455
SDL_Rect::h
int h
Definition: SDL_rect.h:80
SDL_free
#define SDL_free
Definition: SDL_dynapi_overrides.h:377
SDL_TEXTUREACCESS_STATIC
Definition: SDL_render.h:93
SDL_BlitSurface
#define SDL_BlitSurface
Definition: SDL_surface.h:484
SW_DrawStateCache::viewport
const SDL_Rect * viewport
Definition: SDL_render_sw.c:42
SDL_max
#define SDL_max(x, y)
Definition: SDL_stdinc.h:407
SW_SetRenderTarget
static int SW_SetRenderTarget(SDL_Renderer *renderer, SDL_Texture *texture)
Definition: SDL_render_sw.c:183
SDL_draw.h
SDL_blendpoint.h
SDL_RENDERCMD_SETVIEWPORT
Definition: SDL_sysrender.h:75
SDL_FLIP_HORIZONTAL
Definition: SDL_render.h:114
SDL_Renderer::QueueDrawLines
int(* QueueDrawLines)(SDL_Renderer *renderer, SDL_RenderCommand *cmd, const SDL_FPoint *points, int count)
Definition: SDL_sysrender.h:134
SDL_FALSE
Definition: SDL_stdinc.h:163
SW_DrawStateCache::surface_cliprect_dirty
SDL_bool surface_cliprect_dirty
Definition: SDL_render_sw.c:44
SDL_RENDERCMD_DRAW_POINTS
Definition: SDL_sysrender.h:79
rect
SDL_Rect rect
Definition: testrelative.c:27
SDL_FreeSurface
#define SDL_FreeSurface
Definition: SDL_dynapi_overrides.h:446
SDL_RenderCommand::draw
struct SDL_RenderCommand::@30::@33 draw
SW_GetOutputSize
static int SW_GetOutputSize(SDL_Renderer *renderer, int *w, int *h)
Definition: SDL_render_sw.c:83
SDL_rotate.h
SDL_PixelFormatEnumToMasks
#define SDL_PixelFormatEnumToMasks
Definition: SDL_dynapi_overrides.h:278
SDL_assert.h
CopyExData::flip
SDL_RendererFlip flip
Definition: SDL_render_sw.c:298
SetDrawState
static void SetDrawState(SDL_Surface *surface, SW_DrawStateCache *drawstate)
Definition: SDL_render_sw.c:584
SW_RenderData
Definition: SDL_render_sw.c:47
SDL_WINDOWEVENT_SIZE_CHANGED
Definition: SDL_video.h:156
SDL_SetSurfaceRLE
#define SDL_SetSurfaceRLE
Definition: SDL_dynapi_overrides.h:452
SDL_RenderCommand::command
SDL_RenderCommandType command
Definition: SDL_sysrender.h:88
SDL_RENDERCMD_NO_OP
Definition: SDL_sysrender.h:74
SDL_Renderer::QueueSetViewport
int(* QueueSetViewport)(SDL_Renderer *renderer, SDL_RenderCommand *cmd)
Definition: SDL_sysrender.h:130
SDL_PIXELFORMAT_ARGB8888
Definition: SDL_pixels.h:248
SDL_assert
#define SDL_assert(condition)
Definition: SDL_assert.h:169
SDL_DrawLines
int SDL_DrawLines(SDL_Surface *dst, const SDL_Point *points, int count, Uint32 color)
Definition: SDL_drawline.c:166
SW_UpdateTexture
static int SW_UpdateTexture(SDL_Renderer *renderer, SDL_Texture *texture, const SDL_Rect *rect, const void *pixels, int pitch)
Definition: SDL_render_sw.c:139
SDL_RENDERCMD_DRAW_LINES
Definition: SDL_sysrender.h:80
pixels
GLint GLint GLsizei GLsizei GLsizei GLint GLenum GLenum const GLvoid * pixels
Definition: SDL_opengl.h:1571
SDL_BlendMode
SDL_BlendMode
The blend mode used in SDL_RenderCopy() and drawing operations.
Definition: SDL_blendmode.h:40
CopyExData::srcrect
SDL_Rect srcrect
Definition: SDL_render_sw.c:294
SDL_GetWindowSurface
#define SDL_GetWindowSurface
Definition: SDL_dynapi_overrides.h:540
SDL_Renderer::GetOutputSize
int(* GetOutputSize)(SDL_Renderer *renderer, int *w, int *h)
Definition: SDL_sysrender.h:127
CopyExData::center
SDL_FPoint center
Definition: SDL_render_sw.c:297
SDL_OutOfMemory
#define SDL_OutOfMemory()
Definition: SDL_error.h:52
SDL_Renderer::CreateTexture
int(* CreateTexture)(SDL_Renderer *renderer, SDL_Texture *texture)
Definition: SDL_sysrender.h:129
y
GLint GLint GLint GLint GLint GLint y
Definition: SDL_opengl.h:1573
SDL_drawline.h
SDL_RENDERCMD_FILL_RECTS
Definition: SDL_sysrender.h:81
SDL_LockSurface
#define SDL_LockSurface
Definition: SDL_dynapi_overrides.h:448
SDL_CreateRGBSurface
#define SDL_CreateRGBSurface
Definition: SDL_dynapi_overrides.h:444
SDL_Renderer::DestroyRenderer
void(* DestroyRenderer)(SDL_Renderer *renderer)
Definition: SDL_sysrender.h:161
SDL_Renderer::LockTexture
int(* LockTexture)(SDL_Renderer *renderer, SDL_Texture *texture, const SDL_Rect *rect, void **pixels, int *pitch)
Definition: SDL_sysrender.h:152
SW_QueueCopyEx
static int SW_QueueCopyEx(SDL_Renderer *renderer, SDL_RenderCommand *cmd, SDL_Texture *texture, const SDL_Rect *srcrect, const SDL_FRect *dstrect, const double angle, const SDL_FPoint *center, const SDL_RendererFlip flip)
Definition: SDL_render_sw.c:302
SDL_GetSurfaceAlphaMod
#define SDL_GetSurfaceAlphaMod
Definition: SDL_dynapi_overrides.h:458
SW_RenderData::surface
SDL_Surface * surface
Definition: SDL_render_sw.c:49
SDL_calloc
#define SDL_calloc
Definition: SDL_dynapi_overrides.h:375
SDL_PIXELFORMAT_RGB555
Definition: SDL_pixels.h:194
SW_DestroyRenderer
static void SW_DestroyRenderer(SDL_Renderer *renderer)
Definition: SDL_render_sw.c:793
SDL_Renderer::RenderReadPixels
int(* RenderReadPixels)(SDL_Renderer *renderer, const SDL_Rect *rect, Uint32 format, void *pixels, int pitch)
Definition: SDL_sysrender.h:156
SW_RenderData::window
SDL_Surface * window
Definition: SDL_render_sw.c:50
SDL_RENDERCMD_COPY_EX
Definition: SDL_sysrender.h:83
SDL_bool
SDL_bool
Definition: SDL_stdinc.h:161
SDL_blendfillrect.h
SDL_RenderCommand
Definition: SDL_sysrender.h:86
src
GLenum src
Definition: SDL_opengl_glext.h:1737
SDL_RendererFlip
SDL_RendererFlip
Flip constants for SDL_RenderCopyEx.
Definition: SDL_render.h:111
renderer
static SDL_Renderer * renderer
Definition: testaudiocapture.c:21
CopyExData
Definition: SDL_render_sw.c:292
SDL_FLIP_VERTICAL
Definition: SDL_render.h:115
SDL_Point
The structure that defines a point (integer)
Definition: SDL_rect.h:48
SDL_Renderer::info
SDL_RendererInfo info
Definition: SDL_sysrender.h:170
SDL_RENDERER_TARGETTEXTURE
Definition: SDL_render.h:71
SDL_BLENDMODE_ADD
Definition: SDL_blendmode.h:47
SDL_PIXELFORMAT_RGBA8888
Definition: SDL_pixels.h:251
SDL_SetError
#define SDL_SetError
Definition: SDL_dynapi_overrides.h:30
SDL_Renderer::RenderPresent
void(* RenderPresent)(SDL_Renderer *renderer)
Definition: SDL_sysrender.h:158
SW_ActivateRenderer
static SDL_Surface * SW_ActivateRenderer(SDL_Renderer *renderer)
Definition: SDL_render_sw.c:55
SDL_Rect
A rectangle, with the origin at the upper left (integer).
Definition: SDL_rect.h:77
SDL_TRUE
Definition: SDL_stdinc.h:164
SDL_drawpoint.h
SDL_Texture
Definition: SDL_sysrender.h:43
SDL_Renderer::QueueFillRects
int(* QueueFillRects)(SDL_Renderer *renderer, SDL_RenderCommand *cmd, const SDL_FRect *rects, int count)
Definition: SDL_sysrender.h:136
SDL_Renderer::UpdateTexture
int(* UpdateTexture)(SDL_Renderer *renderer, SDL_Texture *texture, const SDL_Rect *rect, const void *pixels, int pitch)
Definition: SDL_sysrender.h:144
SDL_hints.h
SDL_RenderCommand::cliprect
struct SDL_RenderCommand::@30::@32 cliprect
SW_RunCommandQueue
static int SW_RunCommandQueue(SDL_Renderer *renderer, SDL_RenderCommand *cmd, void *vertices, size_t vertsize)
Definition: SDL_render_sw.c:607
SW_QueueSetViewport
static int SW_QueueSetViewport(SDL_Renderer *renderer, SDL_RenderCommand *cmd)
Definition: SDL_render_sw.c:196
SDL_WindowEvent
Window state change event data (event.window.*)
Definition: SDL_events.h:195
SDL_PIXELFORMAT_BGRA8888
Definition: SDL_pixels.h:257
SDL_FRect
A rectangle, with the origin at the upper left (floating point).
Definition: SDL_rect.h:87
SDL_SetSurfaceBlendMode
#define SDL_SetSurfaceBlendMode
Definition: SDL_dynapi_overrides.h:459
SDL_GetSurfaceColorMod
#define SDL_GetSurfaceColorMod
Definition: SDL_dynapi_overrides.h:456
SDL_RenderDriver::info
SDL_RendererInfo info
Definition: SDL_sysrender.h:241
SDL_ConvertPixels
#define SDL_ConvertPixels
Definition: SDL_dynapi_overrides.h:465
SW_LockTexture
static int SW_LockTexture(SDL_Renderer *renderer, SDL_Texture *texture, const SDL_Rect *rect, void **pixels, int *pitch)
Definition: SDL_render_sw.c:165
angle
GLfloat angle
Definition: SDL_opengl_glext.h:6097
Uint32
uint32_t Uint32
Definition: SDL_stdinc.h:203
SDLgfx_rotozoomSurfaceSizeTrig
void SDLgfx_rotozoomSurfaceSizeTrig(int width, int height, double angle, int *dstwidth, int *dstheight, double *cangle, double *sangle)
Definition: SDL_rotate.c:106
SDL_FillRect
#define SDL_FillRect
Definition: SDL_dynapi_overrides.h:466
SDLgfx_rotateSurface
SDL_Surface * SDLgfx_rotateSurface(SDL_Surface *src, double angle, int centerx, int centery, int smooth, int flipx, int flipy, int dstwidth, int dstheight, double cangle, double sangle)
Definition: SDL_rotate.c:415
SDL_BLENDMODE_NONE
Definition: SDL_blendmode.h:42
SDL_Renderer::QueueDrawPoints
int(* QueueDrawPoints)(SDL_Renderer *renderer, SDL_RenderCommand *cmd, const SDL_FPoint *points, int count)
Definition: SDL_sysrender.h:132
flags
GLbitfield flags
Definition: SDL_opengl_glext.h:1480
SDL_RENDERCMD_SETDRAWCOLOR
Definition: SDL_sysrender.h:77
SW_WindowEvent
static void SW_WindowEvent(SDL_Renderer *renderer, const SDL_WindowEvent *event)
Definition: SDL_render_sw.c:72
SDL_Renderer::QueueCopy
int(* QueueCopy)(SDL_Renderer *renderer, SDL_RenderCommand *cmd, SDL_Texture *texture, const SDL_Rect *srcrect, const SDL_FRect *dstrect)
Definition: SDL_sysrender.h:138
SDL_Renderer::window
SDL_Window * window
Definition: SDL_sysrender.h:173
SW_CreateTexture
static int SW_CreateTexture(SDL_Renderer *renderer, SDL_Texture *texture)
Definition: SDL_render_sw.c:107
texture
GLenum GLenum GLuint texture
Definition: SDL_opengl_glext.h:1178
SW_RenderPresent
static void SW_RenderPresent(SDL_Renderer *renderer)
Definition: SDL_render_sw.c:775
rects
EGLSurface EGLint * rects
Definition: eglext.h:282
MIN
#define MIN(a, b)
Definition: SDL_rotate.h:26
SDL_PIXELFORMAT_ABGR8888
Definition: SDL_pixels.h:254
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
SW_UnlockTexture
static void SW_UnlockTexture(SDL_Renderer *renderer, SDL_Texture *texture)
Definition: SDL_render_sw.c:178
SDL_RENDERCMD_CLEAR
Definition: SDL_sysrender.h:78
SDL_BlitScaled
#define SDL_BlitScaled
Definition: SDL_surface.h:513
SDL_SetClipRect
#define SDL_SetClipRect
Definition: SDL_dynapi_overrides.h:461
SDL_Renderer::UnlockTexture
void(* UnlockTexture)(SDL_Renderer *renderer, SDL_Texture *texture)
Definition: SDL_sysrender.h:154
SDL_SetSurfaceAlphaMod
#define SDL_SetSurfaceAlphaMod
Definition: SDL_dynapi_overrides.h:457
SDL_Renderer::DestroyTexture
void(* DestroyTexture)(SDL_Renderer *renderer, SDL_Texture *texture)
Definition: SDL_sysrender.h:159
w
GLubyte GLubyte GLubyte GLubyte w
Definition: SDL_opengl_glext.h:731