SDL  2.0
SDL_rotate.c
Go to the documentation of this file.
1 /*
2 
3 SDL_rotate.c: rotates 32bit or 8bit surfaces
4 
5 Shamelessly stolen from SDL_gfx by Andreas Schiffler. Original copyright follows:
6 
7 Copyright (C) 2001-2011 Andreas Schiffler
8 
9 This software is provided 'as-is', without any express or implied
10 warranty. In no event will the authors be held liable for any damages
11 arising from the use of this software.
12 
13 Permission is granted to anyone to use this software for any purpose,
14 including commercial applications, and to alter it and redistribute it
15 freely, subject to the following restrictions:
16 
17  1. The origin of this software must not be misrepresented; you must not
18  claim that you wrote the original software. If you use this software
19  in a product, an acknowledgment in the product documentation would be
20  appreciated but is not required.
21 
22  2. Altered source versions must be plainly marked as such, and must not be
23  misrepresented as being the original software.
24 
25  3. This notice may not be removed or altered from any source
26  distribution.
27 
28 Andreas Schiffler -- aschiffler at ferzkopp dot net
29 
30 */
31 #include "../../SDL_internal.h"
32 
33 #if defined(__WIN32__)
34 #include "../../core/windows/SDL_windows.h"
35 #endif
36 
37 #include <stdlib.h>
38 #include <string.h>
39 
40 #include "SDL.h"
41 #include "SDL_rotate.h"
42 
43 /* ---- Internally used structures */
44 
45 /* !
46 \brief A 32 bit RGBA pixel.
47 */
48 typedef struct tColorRGBA {
53 } tColorRGBA;
54 
55 /* !
56 \brief A 8bit Y/palette pixel.
57 */
58 typedef struct tColorY {
60 } tColorY;
61 
62 /* !
63 \brief Returns maximum of two numbers a and b.
64 */
65 #define MAX(a,b) (((a) > (b)) ? (a) : (b))
66 
67 /* !
68 \brief Number of guard rows added to destination surfaces.
69 
70 This is a simple but effective workaround for observed issues.
71 These rows allocate extra memory and are then hidden from the surface.
72 Rows are added to the end of destination surfaces when they are allocated.
73 This catches any potential overflows which seem to happen with
74 just the right src image dimensions and scale/rotation and can lead
75 to a situation where the program can segfault.
76 */
77 #define GUARD_ROWS (2)
78 
79 /* !
80 \brief Returns colorkey info for a surface
81 */
82 static Uint32
84 {
85  Uint32 key = 0;
86  if (SDL_HasColorKey(src)) {
88  }
89  return key;
90 }
91 
92 
93 /* !
94 \brief Internal target surface sizing function for rotations with trig result return.
95 
96 \param width The source surface width.
97 \param height The source surface height.
98 \param angle The angle to rotate in degrees.
99 \param dstwidth The calculated width of the destination surface.
100 \param dstheight The calculated height of the destination surface.
101 \param cangle The sine of the angle
102 \param sangle The cosine of the angle
103 
104 */
105 void
107  int *dstwidth, int *dstheight,
108  double *cangle, double *sangle)
109 {
110  /* The trig code below gets the wrong size (due to FP inaccuracy?) when angle is a multiple of 90 degrees */
111  int angle90 = (int)(angle/90);
112  if(angle90 == angle/90) { /* if the angle is a multiple of 90 degrees */
113  angle90 %= 4;
114  if(angle90 < 0) angle90 += 4; /* 0:0 deg, 1:90 deg, 2:180 deg, 3:270 deg */
115  if(angle90 & 1) {
116  *dstwidth = height;
117  *dstheight = width;
118  *cangle = 0;
119  *sangle = angle90 == 1 ? -1 : 1; /* reversed because our rotations are clockwise */
120  } else {
121  *dstwidth = width;
122  *dstheight = height;
123  *cangle = angle90 == 0 ? 1 : -1;
124  *sangle = 0;
125  }
126  } else {
127  double x, y, cx, cy, sx, sy;
128  double radangle;
129  int dstwidthhalf, dstheighthalf;
130  /*
131  * Determine destination width and height by rotating a centered source box
132  */
133  radangle = angle * (M_PI / -180.0); /* reverse the angle because our rotations are clockwise */
134  *sangle = SDL_sin(radangle);
135  *cangle = SDL_cos(radangle);
136  x = (double)(width / 2);
137  y = (double)(height / 2);
138  cx = *cangle * x;
139  cy = *cangle * y;
140  sx = *sangle * x;
141  sy = *sangle * y;
142 
143  dstwidthhalf = MAX((int)
144  SDL_ceil(MAX(MAX(MAX(SDL_fabs(cx + sy), SDL_fabs(cx - sy)), SDL_fabs(-cx + sy)), SDL_fabs(-cx - sy))), 1);
145  dstheighthalf = MAX((int)
146  SDL_ceil(MAX(MAX(MAX(SDL_fabs(sx + cy), SDL_fabs(sx - cy)), SDL_fabs(-sx + cy)), SDL_fabs(-sx - cy))), 1);
147  *dstwidth = 2 * dstwidthhalf;
148  *dstheight = 2 * dstheighthalf;
149  }
150 }
151 
152 /* Computes source pointer X/Y increments for a rotation that's a multiple of 90 degrees. */
153 static void
154 computeSourceIncrements90(SDL_Surface * src, int bpp, int angle, int flipx, int flipy,
155  int *sincx, int *sincy, int *signx, int *signy)
156 {
157  int pitch = flipy ? -src->pitch : src->pitch;
158  if (flipx) {
159  bpp = -bpp;
160  }
161  switch (angle) { /* 0:0 deg, 1:90 deg, 2:180 deg, 3:270 deg */
162  case 0: *sincx = bpp; *sincy = pitch - src->w * *sincx; *signx = *signy = 1; break;
163  case 1: *sincx = -pitch; *sincy = bpp - *sincx * src->h; *signx = 1; *signy = -1; break;
164  case 2: *sincx = -bpp; *sincy = -src->w * *sincx - pitch; *signx = *signy = -1; break;
165  case 3: default: *sincx = pitch; *sincy = -*sincx * src->h - bpp; *signx = -1; *signy = 1; break;
166  }
167  if (flipx) {
168  *signx = -*signx;
169  }
170  if (flipy) {
171  *signy = -*signy;
172  }
173 }
174 
175 /* Performs a relatively fast rotation/flip when the angle is a multiple of 90 degrees. */
176 #define TRANSFORM_SURFACE_90(pixelType) \
177  int dy, dincy = dst->pitch - dst->w*sizeof(pixelType), sincx, sincy, signx, signy; \
178  Uint8 *sp = (Uint8*)src->pixels, *dp = (Uint8*)dst->pixels, *de; \
179  \
180  computeSourceIncrements90(src, sizeof(pixelType), angle, flipx, flipy, &sincx, &sincy, &signx, &signy); \
181  if (signx < 0) sp += (src->w-1)*sizeof(pixelType); \
182  if (signy < 0) sp += (src->h-1)*src->pitch; \
183  \
184  for (dy = 0; dy < dst->h; sp += sincy, dp += dincy, dy++) { \
185  if (sincx == sizeof(pixelType)) { /* if advancing src and dest equally, use memcpy */ \
186  SDL_memcpy(dp, sp, dst->w*sizeof(pixelType)); \
187  sp += dst->w*sizeof(pixelType); \
188  dp += dst->w*sizeof(pixelType); \
189  } else { \
190  for (de = dp + dst->w*sizeof(pixelType); dp != de; sp += sincx, dp += sizeof(pixelType)) { \
191  *(pixelType*)dp = *(pixelType*)sp; \
192  } \
193  } \
194  }
195 
196 static void
197 transformSurfaceRGBA90(SDL_Surface * src, SDL_Surface * dst, int angle, int flipx, int flipy)
198 {
200 }
201 
202 static void
203 transformSurfaceY90(SDL_Surface * src, SDL_Surface * dst, int angle, int flipx, int flipy)
204 {
206 }
207 
208 #undef TRANSFORM_SURFACE_90
209 
210 /* !
211 \brief Internal 32 bit rotozoomer with optional anti-aliasing.
212 
213 Rotates and zooms 32 bit RGBA/ABGR 'src' surface to 'dst' surface based on the control
214 parameters by scanning the destination surface and applying optionally anti-aliasing
215 by bilinear interpolation.
216 Assumes src and dst surfaces are of 32 bit depth.
217 Assumes dst surface was allocated with the correct dimensions.
218 
219 \param src Source surface.
220 \param dst Destination surface.
221 \param cx Horizontal center coordinate.
222 \param cy Vertical center coordinate.
223 \param isin Integer version of sine of angle.
224 \param icos Integer version of cosine of angle.
225 \param flipx Flag indicating horizontal mirroring should be applied.
226 \param flipy Flag indicating vertical mirroring should be applied.
227 \param smooth Flag indicating anti-aliasing should be used.
228 */
229 static void
230 _transformSurfaceRGBA(SDL_Surface * src, SDL_Surface * dst, int cx, int cy, int isin, int icos, int flipx, int flipy, int smooth)
231 {
232  int x, y, t1, t2, dx, dy, xd, yd, sdx, sdy, ax, ay, ex, ey, sw, sh;
233  tColorRGBA c00, c01, c10, c11, cswap;
234  tColorRGBA *pc, *sp;
235  int gap;
236 
237  /*
238  * Variable setup
239  */
240  xd = ((src->w - dst->w) << 15);
241  yd = ((src->h - dst->h) << 15);
242  ax = (cx << 16) - (icos * cx);
243  ay = (cy << 16) - (isin * cx);
244  sw = src->w - 1;
245  sh = src->h - 1;
246  pc = (tColorRGBA*) dst->pixels;
247  gap = dst->pitch - dst->w * 4;
248 
249  /*
250  * Switch between interpolating and non-interpolating code
251  */
252  if (smooth) {
253  for (y = 0; y < dst->h; y++) {
254  dy = cy - y;
255  sdx = (ax + (isin * dy)) + xd;
256  sdy = (ay - (icos * dy)) + yd;
257  for (x = 0; x < dst->w; x++) {
258  dx = (sdx >> 16);
259  dy = (sdy >> 16);
260  if (flipx) dx = sw - dx;
261  if (flipy) dy = sh - dy;
262  if ((dx > -1) && (dy > -1) && (dx < (src->w-1)) && (dy < (src->h-1))) {
263  sp = (tColorRGBA *) ((Uint8 *) src->pixels + src->pitch * dy) + dx;
264  c00 = *sp;
265  sp += 1;
266  c01 = *sp;
267  sp += (src->pitch/4);
268  c11 = *sp;
269  sp -= 1;
270  c10 = *sp;
271  if (flipx) {
272  cswap = c00; c00=c01; c01=cswap;
273  cswap = c10; c10=c11; c11=cswap;
274  }
275  if (flipy) {
276  cswap = c00; c00=c10; c10=cswap;
277  cswap = c01; c01=c11; c11=cswap;
278  }
279  /*
280  * Interpolate colors
281  */
282  ex = (sdx & 0xffff);
283  ey = (sdy & 0xffff);
284  t1 = ((((c01.r - c00.r) * ex) >> 16) + c00.r) & 0xff;
285  t2 = ((((c11.r - c10.r) * ex) >> 16) + c10.r) & 0xff;
286  pc->r = (((t2 - t1) * ey) >> 16) + t1;
287  t1 = ((((c01.g - c00.g) * ex) >> 16) + c00.g) & 0xff;
288  t2 = ((((c11.g - c10.g) * ex) >> 16) + c10.g) & 0xff;
289  pc->g = (((t2 - t1) * ey) >> 16) + t1;
290  t1 = ((((c01.b - c00.b) * ex) >> 16) + c00.b) & 0xff;
291  t2 = ((((c11.b - c10.b) * ex) >> 16) + c10.b) & 0xff;
292  pc->b = (((t2 - t1) * ey) >> 16) + t1;
293  t1 = ((((c01.a - c00.a) * ex) >> 16) + c00.a) & 0xff;
294  t2 = ((((c11.a - c10.a) * ex) >> 16) + c10.a) & 0xff;
295  pc->a = (((t2 - t1) * ey) >> 16) + t1;
296  }
297  sdx += icos;
298  sdy += isin;
299  pc++;
300  }
301  pc = (tColorRGBA *) ((Uint8 *) pc + gap);
302  }
303  } else {
304  for (y = 0; y < dst->h; y++) {
305  dy = cy - y;
306  sdx = (ax + (isin * dy)) + xd;
307  sdy = (ay - (icos * dy)) + yd;
308  for (x = 0; x < dst->w; x++) {
309  dx = (sdx >> 16);
310  dy = (sdy >> 16);
311  if ((unsigned)dx < (unsigned)src->w && (unsigned)dy < (unsigned)src->h) {
312  if(flipx) dx = sw - dx;
313  if(flipy) dy = sh - dy;
314  *pc = *((tColorRGBA *)((Uint8 *)src->pixels + src->pitch * dy) + dx);
315  }
316  sdx += icos;
317  sdy += isin;
318  pc++;
319  }
320  pc = (tColorRGBA *) ((Uint8 *) pc + gap);
321  }
322  }
323 }
324 
325 /* !
326 
327 \brief Rotates and zooms 8 bit palette/Y 'src' surface to 'dst' surface without smoothing.
328 
329 Rotates and zooms 8 bit RGBA/ABGR 'src' surface to 'dst' surface based on the control
330 parameters by scanning the destination surface.
331 Assumes src and dst surfaces are of 8 bit depth.
332 Assumes dst surface was allocated with the correct dimensions.
333 
334 \param src Source surface.
335 \param dst Destination surface.
336 \param cx Horizontal center coordinate.
337 \param cy Vertical center coordinate.
338 \param isin Integer version of sine of angle.
339 \param icos Integer version of cosine of angle.
340 \param flipx Flag indicating horizontal mirroring should be applied.
341 \param flipy Flag indicating vertical mirroring should be applied.
342 */
343 static void
344 transformSurfaceY(SDL_Surface * src, SDL_Surface * dst, int cx, int cy, int isin, int icos, int flipx, int flipy)
345 {
346  int x, y, dx, dy, xd, yd, sdx, sdy, ax, ay;
347  tColorY *pc;
348  int gap;
349 
350  /*
351  * Variable setup
352  */
353  xd = ((src->w - dst->w) << 15);
354  yd = ((src->h - dst->h) << 15);
355  ax = (cx << 16) - (icos * cx);
356  ay = (cy << 16) - (isin * cx);
357  pc = (tColorY*) dst->pixels;
358  gap = dst->pitch - dst->w;
359  /*
360  * Clear surface to colorkey
361  */
362  SDL_memset(pc, (int)(_colorkey(src) & 0xff), dst->pitch * dst->h);
363  /*
364  * Iterate through destination surface
365  */
366  for (y = 0; y < dst->h; y++) {
367  dy = cy - y;
368  sdx = (ax + (isin * dy)) + xd;
369  sdy = (ay - (icos * dy)) + yd;
370  for (x = 0; x < dst->w; x++) {
371  dx = (sdx >> 16);
372  dy = (sdy >> 16);
373  if ((unsigned)dx < (unsigned)src->w && (unsigned)dy < (unsigned)src->h) {
374  if (flipx) dx = (src->w-1)-dx;
375  if (flipy) dy = (src->h-1)-dy;
376  *pc = *((tColorY *)src->pixels + src->pitch * dy + dx);
377  }
378  sdx += icos;
379  sdy += isin;
380  pc++;
381  }
382  pc += gap;
383  }
384 }
385 
386 
387 /* !
388 \brief Rotates and zooms a surface with different horizontal and vertival scaling factors and optional anti-aliasing.
389 
390 Rotates a 32-bit or 8-bit 'src' surface to newly created 'dst' surface.
391 'angle' is the rotation in degrees, 'centerx' and 'centery' the rotation center. If 'smooth' is set
392 then the destination 32-bit surface is anti-aliased. 8-bit surfaces must have a colorkey. 32-bit
393 surfaces must have a 8888 layout with red, green, blue and alpha masks (any ordering goes).
394 The blend mode of the 'src' surface has some effects on generation of the 'dst' surface: The NONE
395 mode will set the BLEND mode on the 'dst' surface. The MOD mode either generates a white 'dst'
396 surface and sets the colorkey or fills the it with the colorkey before copying the pixels.
397 When using the NONE and MOD modes, color and alpha modulation must be applied before using this function.
398 
399 \param src The surface to rotozoom.
400 \param angle The angle to rotate in degrees.
401 \param centerx The horizontal coordinate of the center of rotation
402 \param zoomy The vertical coordinate of the center of rotation
403 \param smooth Antialiasing flag; set to SMOOTHING_ON to enable.
404 \param flipx Set to 1 to flip the image horizontally
405 \param flipy Set to 1 to flip the image vertically
406 \param dstwidth The destination surface width
407 \param dstheight The destination surface height
408 \param cangle The angle cosine
409 \param sangle The angle sine
410 \return The new rotated surface.
411 
412 */
413 
414 SDL_Surface *
415 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)
416 {
417  SDL_Surface *rz_dst;
418  int is8bit, angle90;
419  int i;
420  SDL_BlendMode blendmode;
421  Uint32 colorkey = 0;
422  int colorKeyAvailable = SDL_FALSE;
423  double sangleinv, cangleinv;
424 
425  /* Sanity check */
426  if (src == NULL)
427  return NULL;
428 
429  if (SDL_HasColorKey(src)) {
430  if (SDL_GetColorKey(src, &colorkey) == 0) {
431  colorKeyAvailable = SDL_TRUE;
432  }
433  }
434 
435  /* This function requires a 32-bit surface or 8-bit surface with a colorkey */
436  is8bit = src->format->BitsPerPixel == 8 && colorKeyAvailable;
437  if (!(is8bit || (src->format->BitsPerPixel == 32 && src->format->Amask)))
438  return NULL;
439 
440  /* Calculate target factors from sin/cos and zoom */
441  sangleinv = sangle*65536.0;
442  cangleinv = cangle*65536.0;
443 
444  /* Alloc space to completely contain the rotated surface */
445  rz_dst = NULL;
446  if (is8bit) {
447  /* Target surface is 8 bit */
448  rz_dst = SDL_CreateRGBSurface(0, dstwidth, dstheight + GUARD_ROWS, 8, 0, 0, 0, 0);
449  if (rz_dst != NULL) {
450  for (i = 0; i < src->format->palette->ncolors; i++) {
451  rz_dst->format->palette->colors[i] = src->format->palette->colors[i];
452  }
453  rz_dst->format->palette->ncolors = src->format->palette->ncolors;
454  }
455  } else {
456  /* Target surface is 32 bit with source RGBA ordering */
457  rz_dst = SDL_CreateRGBSurface(0, dstwidth, dstheight + GUARD_ROWS, 32,
458  src->format->Rmask, src->format->Gmask,
459  src->format->Bmask, src->format->Amask);
460  }
461 
462  /* Check target */
463  if (rz_dst == NULL)
464  return NULL;
465 
466  /* Adjust for guard rows */
467  rz_dst->h = dstheight;
468 
469  SDL_GetSurfaceBlendMode(src, &blendmode);
470 
471  if (colorKeyAvailable == SDL_TRUE) {
472  /* If available, the colorkey will be used to discard the pixels that are outside of the rotated area. */
473  SDL_SetColorKey(rz_dst, SDL_TRUE, colorkey);
474  SDL_FillRect(rz_dst, NULL, colorkey);
475  } else if (blendmode == SDL_BLENDMODE_NONE) {
476  blendmode = SDL_BLENDMODE_BLEND;
477  } else if (blendmode == SDL_BLENDMODE_MOD) {
478  /* Without a colorkey, the target texture has to be white for the MOD blend mode so
479  * that the pixels outside the rotated area don't affect the destination surface.
480  */
481  colorkey = SDL_MapRGBA(rz_dst->format, 255, 255, 255, 0);
482  SDL_FillRect(rz_dst, NULL, colorkey);
483  /* Setting a white colorkey for the destination surface makes the final blit discard
484  * all pixels outside of the rotated area. This doesn't interfere with anything because
485  * white pixels are already a no-op and the MOD blend mode does not interact with alpha.
486  */
487  SDL_SetColorKey(rz_dst, SDL_TRUE, colorkey);
488  }
489 
490  SDL_SetSurfaceBlendMode(rz_dst, blendmode);
491 
492  /* Lock source surface */
493  if (SDL_MUSTLOCK(src)) {
495  }
496 
497  /* check if the rotation is a multiple of 90 degrees so we can take a fast path and also somewhat reduce
498  * the off-by-one problem in _transformSurfaceRGBA that expresses itself when the rotation is near
499  * multiples of 90 degrees.
500  */
501  angle90 = (int)(angle/90);
502  if (angle90 == angle/90) {
503  angle90 %= 4;
504  if (angle90 < 0) angle90 += 4; /* 0:0 deg, 1:90 deg, 2:180 deg, 3:270 deg */
505  } else {
506  angle90 = -1;
507  }
508 
509  if (is8bit) {
510  /* Call the 8-bit transformation routine to do the rotation */
511  if(angle90 >= 0) {
512  transformSurfaceY90(src, rz_dst, angle90, flipx, flipy);
513  } else {
514  transformSurfaceY(src, rz_dst, centerx, centery, (int)sangleinv, (int)cangleinv,
515  flipx, flipy);
516  }
517  } else {
518  /* Call the 32-bit transformation routine to do the rotation */
519  if (angle90 >= 0) {
520  transformSurfaceRGBA90(src, rz_dst, angle90, flipx, flipy);
521  } else {
522  _transformSurfaceRGBA(src, rz_dst, centerx, centery, (int)sangleinv, (int)cangleinv,
523  flipx, flipy, smooth);
524  }
525  }
526 
527  /* Unlock source surface */
528  if (SDL_MUSTLOCK(src)) {
530  }
531 
532  /* Return rotated surface */
533  return rz_dst;
534 }
SDL.h
SDL_UnlockSurface
#define SDL_UnlockSurface
Definition: SDL_dynapi_overrides.h:449
SDL_memset
#define SDL_memset
Definition: SDL_dynapi_overrides.h:386
Uint32
uint32_t Uint32
Definition: SDL_stdinc.h:203
tColorRGBA::r
Uint8 r
Definition: SDL_rotate.c:49
t1
GLuint GLfloat GLfloat GLfloat GLfloat GLfloat GLfloat GLfloat GLfloat GLfloat t1
Definition: SDL_opengl_glext.h:8583
SDL_Palette::ncolors
int ncolors
Definition: SDL_pixels.h:306
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_fabs
#define SDL_fabs
Definition: SDL_dynapi_overrides.h:430
SDL_ceil
#define SDL_ceil
Definition: SDL_dynapi_overrides.h:426
NULL
#define NULL
Definition: begin_code.h:167
width
GLint GLint GLsizei width
Definition: SDL_opengl.h:1572
tColorRGBA::a
Uint8 a
Definition: SDL_rotate.c:52
MAX
#define MAX(a, b)
Definition: SDL_rotate.c:65
transformSurfaceRGBA90
static void transformSurfaceRGBA90(SDL_Surface *src, SDL_Surface *dst, int angle, int flipx, int flipy)
Definition: SDL_rotate.c:197
computeSourceIncrements90
static void computeSourceIncrements90(SDL_Surface *src, int bpp, int angle, int flipx, int flipy, int *sincx, int *sincy, int *signx, int *signy)
Definition: SDL_rotate.c:154
tColorRGBA::b
Uint8 b
Definition: SDL_rotate.c:51
SDL_MUSTLOCK
#define SDL_MUSTLOCK(S)
Definition: SDL_surface.h:62
SDL_GetSurfaceBlendMode
#define SDL_GetSurfaceBlendMode
Definition: SDL_dynapi_overrides.h:460
dst
GLenum GLenum dst
Definition: SDL_opengl_glext.h:1737
GUARD_ROWS
#define GUARD_ROWS
Definition: SDL_rotate.c:77
SDL_BLENDMODE_MOD
@ SDL_BLENDMODE_MOD
Definition: SDL_blendmode.h:50
SDL_BLENDMODE_NONE
@ SDL_BLENDMODE_NONE
Definition: SDL_blendmode.h:42
SDL_FALSE
@ SDL_FALSE
Definition: SDL_stdinc.h:163
SDL_Palette::colors
SDL_Color * colors
Definition: SDL_pixels.h:307
x
GLint GLint GLint GLint GLint x
Definition: SDL_opengl.h:1574
height
GLint GLint GLsizei GLsizei height
Definition: SDL_opengl.h:1572
SDL_cos
#define SDL_cos
Definition: SDL_dynapi_overrides.h:428
_transformSurfaceRGBA
static void _transformSurfaceRGBA(SDL_Surface *src, SDL_Surface *dst, int cx, int cy, int isin, int icos, int flipx, int flipy, int smooth)
Definition: SDL_rotate.c:230
SDL_PixelFormat::palette
SDL_Palette * palette
Definition: SDL_pixels.h:318
SDL_rotate.h
SDL_SetColorKey
#define SDL_SetColorKey
Definition: SDL_dynapi_overrides.h:453
SDL_GetColorKey
#define SDL_GetColorKey
Definition: SDL_dynapi_overrides.h:454
key
GLuint64 key
Definition: gl2ext.h:2192
transformSurfaceY
static void transformSurfaceY(SDL_Surface *src, SDL_Surface *dst, int cx, int cy, int isin, int icos, int flipx, int flipy)
Definition: SDL_rotate.c:344
_colorkey
static Uint32 _colorkey(SDL_Surface *src)
Definition: SDL_rotate.c:83
tColorY::y
Uint8 y
Definition: SDL_rotate.c:59
SDL_BLENDMODE_BLEND
@ SDL_BLENDMODE_BLEND
Definition: SDL_blendmode.h:44
y
GLint GLint GLint GLint GLint GLint y
Definition: SDL_opengl.h:1574
SDL_LockSurface
#define SDL_LockSurface
Definition: SDL_dynapi_overrides.h:448
SDL_CreateRGBSurface
#define SDL_CreateRGBSurface
Definition: SDL_dynapi_overrides.h:444
SDL_Surface::h
int h
Definition: SDL_surface.h:74
transformSurfaceY90
static void transformSurfaceY90(SDL_Surface *src, SDL_Surface *dst, int angle, int flipx, int flipy)
Definition: SDL_rotate.c:203
src
GLenum src
Definition: SDL_opengl_glext.h:1737
SDL_TRUE
@ SDL_TRUE
Definition: SDL_stdinc.h:164
TRANSFORM_SURFACE_90
#define TRANSFORM_SURFACE_90(pixelType)
Definition: SDL_rotate.c:176
tColorRGBA
Definition: SDL_rotate.c:48
SDL_SetSurfaceBlendMode
#define SDL_SetSurfaceBlendMode
Definition: SDL_dynapi_overrides.h:459
tColorRGBA::g
Uint8 g
Definition: SDL_rotate.c:50
angle
GLfloat angle
Definition: SDL_opengl_glext.h:6097
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
tColorY
Definition: SDL_rotate.c:58
SDL_sin
#define SDL_sin
Definition: SDL_dynapi_overrides.h:435
SDL_BlendMode
SDL_BlendMode
The blend mode used in SDL_RenderCopy() and drawing operations.
Definition: SDL_blendmode.h:40
SDL_Surface::format
SDL_PixelFormat * format
Definition: SDL_surface.h:73
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_HasColorKey
#define SDL_HasColorKey
Definition: SDL_dynapi_overrides.h:699
Uint8
uint8_t Uint8
Definition: SDL_stdinc.h:179