summaryrefslogtreecommitdiff
path: root/src/contrib/SDL-2.30.2/include/SDL_surface.h
diff options
context:
space:
mode:
Diffstat (limited to 'src/contrib/SDL-2.30.2/include/SDL_surface.h')
-rw-r--r--src/contrib/SDL-2.30.2/include/SDL_surface.h997
1 files changed, 997 insertions, 0 deletions
diff --git a/src/contrib/SDL-2.30.2/include/SDL_surface.h b/src/contrib/SDL-2.30.2/include/SDL_surface.h
new file mode 100644
index 0000000..ceeb86b
--- /dev/null
+++ b/src/contrib/SDL-2.30.2/include/SDL_surface.h
@@ -0,0 +1,997 @@
1/*
2 Simple DirectMedia Layer
3 Copyright (C) 1997-2024 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
22/**
23 * \file SDL_surface.h
24 *
25 * Header file for ::SDL_Surface definition and management functions.
26 */
27
28#ifndef SDL_surface_h_
29#define SDL_surface_h_
30
31#include "SDL_stdinc.h"
32#include "SDL_pixels.h"
33#include "SDL_rect.h"
34#include "SDL_blendmode.h"
35#include "SDL_rwops.h"
36
37#include "begin_code.h"
38/* Set up for C function definitions, even when using C++ */
39#ifdef __cplusplus
40extern "C" {
41#endif
42
43/**
44 * \name Surface flags
45 *
46 * These are the currently supported flags for the ::SDL_Surface.
47 *
48 * \internal
49 * Used internally (read-only).
50 */
51/* @{ */
52#define SDL_SWSURFACE 0 /**< Just here for compatibility */
53#define SDL_PREALLOC 0x00000001 /**< Surface uses preallocated memory */
54#define SDL_RLEACCEL 0x00000002 /**< Surface is RLE encoded */
55#define SDL_DONTFREE 0x00000004 /**< Surface is referenced internally */
56#define SDL_SIMD_ALIGNED 0x00000008 /**< Surface uses aligned memory */
57/* @} *//* Surface flags */
58
59/**
60 * Evaluates to true if the surface needs to be locked before access.
61 */
62#define SDL_MUSTLOCK(S) (((S)->flags & SDL_RLEACCEL) != 0)
63
64typedef struct SDL_BlitMap SDL_BlitMap; /* this is an opaque type. */
65
66/**
67 * \brief A collection of pixels used in software blitting.
68 *
69 * \note This structure should be treated as read-only, except for \c pixels,
70 * which, if not NULL, contains the raw pixel data for the surface.
71 */
72typedef struct SDL_Surface
73{
74 Uint32 flags; /**< Read-only */
75 SDL_PixelFormat *format; /**< Read-only */
76 int w, h; /**< Read-only */
77 int pitch; /**< Read-only */
78 void *pixels; /**< Read-write */
79
80 /** Application data associated with the surface */
81 void *userdata; /**< Read-write */
82
83 /** information needed for surfaces requiring locks */
84 int locked; /**< Read-only */
85
86 /** list of BlitMap that hold a reference to this surface */
87 void *list_blitmap; /**< Private */
88
89 /** clipping information */
90 SDL_Rect clip_rect; /**< Read-only */
91
92 /** info for fast blit mapping to other surfaces */
93 SDL_BlitMap *map; /**< Private */
94
95 /** Reference count -- used when freeing surface */
96 int refcount; /**< Read-mostly */
97} SDL_Surface;
98
99/**
100 * \brief The type of function used for surface blitting functions.
101 */
102typedef int (SDLCALL *SDL_blit) (struct SDL_Surface * src, SDL_Rect * srcrect,
103 struct SDL_Surface * dst, SDL_Rect * dstrect);
104
105/**
106 * \brief The formula used for converting between YUV and RGB
107 */
108typedef enum
109{
110 SDL_YUV_CONVERSION_JPEG, /**< Full range JPEG */
111 SDL_YUV_CONVERSION_BT601, /**< BT.601 (the default) */
112 SDL_YUV_CONVERSION_BT709, /**< BT.709 */
113 SDL_YUV_CONVERSION_AUTOMATIC /**< BT.601 for SD content, BT.709 for HD content */
114} SDL_YUV_CONVERSION_MODE;
115
116/**
117 * Allocate a new RGB surface.
118 *
119 * If `depth` is 4 or 8 bits, an empty palette is allocated for the surface.
120 * If `depth` is greater than 8 bits, the pixel format is set using the
121 * [RGBA]mask parameters.
122 *
123 * The [RGBA]mask parameters are the bitmasks used to extract that color from
124 * a pixel. For instance, `Rmask` being 0xFF000000 means the red data is
125 * stored in the most significant byte. Using zeros for the RGB masks sets a
126 * default value, based on the depth. For example:
127 *
128 * ```c++
129 * SDL_CreateRGBSurface(0,w,h,32,0,0,0,0);
130 * ```
131 *
132 * However, using zero for the Amask results in an Amask of 0.
133 *
134 * By default surfaces with an alpha mask are set up for blending as with:
135 *
136 * ```c++
137 * SDL_SetSurfaceBlendMode(surface, SDL_BLENDMODE_BLEND)
138 * ```
139 *
140 * You can change this by calling SDL_SetSurfaceBlendMode() and selecting a
141 * different `blendMode`.
142 *
143 * \param flags the flags are unused and should be set to 0
144 * \param width the width of the surface
145 * \param height the height of the surface
146 * \param depth the depth of the surface in bits
147 * \param Rmask the red mask for the pixels
148 * \param Gmask the green mask for the pixels
149 * \param Bmask the blue mask for the pixels
150 * \param Amask the alpha mask for the pixels
151 * \returns the new SDL_Surface structure that is created or NULL if it fails;
152 * call SDL_GetError() for more information.
153 *
154 * \since This function is available since SDL 2.0.0.
155 *
156 * \sa SDL_CreateRGBSurfaceFrom
157 * \sa SDL_CreateRGBSurfaceWithFormat
158 * \sa SDL_FreeSurface
159 */
160extern DECLSPEC SDL_Surface *SDLCALL SDL_CreateRGBSurface
161 (Uint32 flags, int width, int height, int depth,
162 Uint32 Rmask, Uint32 Gmask, Uint32 Bmask, Uint32 Amask);
163
164
165/* !!! FIXME for 2.1: why does this ask for depth? Format provides that. */
166
167/**
168 * Allocate a new RGB surface with a specific pixel format.
169 *
170 * This function operates mostly like SDL_CreateRGBSurface(), except instead
171 * of providing pixel color masks, you provide it with a predefined format
172 * from SDL_PixelFormatEnum.
173 *
174 * \param flags the flags are unused and should be set to 0
175 * \param width the width of the surface
176 * \param height the height of the surface
177 * \param depth the depth of the surface in bits
178 * \param format the SDL_PixelFormatEnum for the new surface's pixel format.
179 * \returns the new SDL_Surface structure that is created or NULL if it fails;
180 * call SDL_GetError() for more information.
181 *
182 * \since This function is available since SDL 2.0.5.
183 *
184 * \sa SDL_CreateRGBSurface
185 * \sa SDL_CreateRGBSurfaceFrom
186 * \sa SDL_FreeSurface
187 */
188extern DECLSPEC SDL_Surface *SDLCALL SDL_CreateRGBSurfaceWithFormat
189 (Uint32 flags, int width, int height, int depth, Uint32 format);
190
191/**
192 * Allocate a new RGB surface with existing pixel data.
193 *
194 * This function operates mostly like SDL_CreateRGBSurface(), except it does
195 * not allocate memory for the pixel data, instead the caller provides an
196 * existing buffer of data for the surface to use.
197 *
198 * No copy is made of the pixel data. Pixel data is not managed automatically;
199 * you must free the surface before you free the pixel data.
200 *
201 * \param pixels a pointer to existing pixel data
202 * \param width the width of the surface
203 * \param height the height of the surface
204 * \param depth the depth of the surface in bits
205 * \param pitch the pitch of the surface in bytes
206 * \param Rmask the red mask for the pixels
207 * \param Gmask the green mask for the pixels
208 * \param Bmask the blue mask for the pixels
209 * \param Amask the alpha mask for the pixels
210 * \returns the new SDL_Surface structure that is created or NULL if it fails;
211 * call SDL_GetError() for more information.
212 *
213 * \since This function is available since SDL 2.0.0.
214 *
215 * \sa SDL_CreateRGBSurface
216 * \sa SDL_CreateRGBSurfaceWithFormat
217 * \sa SDL_FreeSurface
218 */
219extern DECLSPEC SDL_Surface *SDLCALL SDL_CreateRGBSurfaceFrom(void *pixels,
220 int width,
221 int height,
222 int depth,
223 int pitch,
224 Uint32 Rmask,
225 Uint32 Gmask,
226 Uint32 Bmask,
227 Uint32 Amask);
228
229/* !!! FIXME for 2.1: why does this ask for depth? Format provides that. */
230
231/**
232 * Allocate a new RGB surface with with a specific pixel format and existing
233 * pixel data.
234 *
235 * This function operates mostly like SDL_CreateRGBSurfaceFrom(), except
236 * instead of providing pixel color masks, you provide it with a predefined
237 * format from SDL_PixelFormatEnum.
238 *
239 * No copy is made of the pixel data. Pixel data is not managed automatically;
240 * you must free the surface before you free the pixel data.
241 *
242 * \param pixels a pointer to existing pixel data
243 * \param width the width of the surface
244 * \param height the height of the surface
245 * \param depth the depth of the surface in bits
246 * \param pitch the pitch of the surface in bytes
247 * \param format the SDL_PixelFormatEnum for the new surface's pixel format.
248 * \returns the new SDL_Surface structure that is created or NULL if it fails;
249 * call SDL_GetError() for more information.
250 *
251 * \since This function is available since SDL 2.0.5.
252 *
253 * \sa SDL_CreateRGBSurfaceFrom
254 * \sa SDL_CreateRGBSurfaceWithFormat
255 * \sa SDL_FreeSurface
256 */
257extern DECLSPEC SDL_Surface *SDLCALL SDL_CreateRGBSurfaceWithFormatFrom
258 (void *pixels, int width, int height, int depth, int pitch, Uint32 format);
259
260/**
261 * Free an RGB surface.
262 *
263 * It is safe to pass NULL to this function.
264 *
265 * \param surface the SDL_Surface to free.
266 *
267 * \since This function is available since SDL 2.0.0.
268 *
269 * \sa SDL_CreateRGBSurface
270 * \sa SDL_CreateRGBSurfaceFrom
271 * \sa SDL_LoadBMP
272 * \sa SDL_LoadBMP_RW
273 */
274extern DECLSPEC void SDLCALL SDL_FreeSurface(SDL_Surface * surface);
275
276/**
277 * Set the palette used by a surface.
278 *
279 * A single palette can be shared with many surfaces.
280 *
281 * \param surface the SDL_Surface structure to update
282 * \param palette the SDL_Palette structure to use
283 * \returns 0 on success or a negative error code on failure; call
284 * SDL_GetError() for more information.
285 *
286 * \since This function is available since SDL 2.0.0.
287 */
288extern DECLSPEC int SDLCALL SDL_SetSurfacePalette(SDL_Surface * surface,
289 SDL_Palette * palette);
290
291/**
292 * Set up a surface for directly accessing the pixels.
293 *
294 * Between calls to SDL_LockSurface() / SDL_UnlockSurface(), you can write to
295 * and read from `surface->pixels`, using the pixel format stored in
296 * `surface->format`. Once you are done accessing the surface, you should use
297 * SDL_UnlockSurface() to release it.
298 *
299 * Not all surfaces require locking. If `SDL_MUSTLOCK(surface)` evaluates to
300 * 0, then you can read and write to the surface at any time, and the pixel
301 * format of the surface will not change.
302 *
303 * \param surface the SDL_Surface structure to be locked
304 * \returns 0 on success or a negative error code on failure; call
305 * SDL_GetError() for more information.
306 *
307 * \since This function is available since SDL 2.0.0.
308 *
309 * \sa SDL_MUSTLOCK
310 * \sa SDL_UnlockSurface
311 */
312extern DECLSPEC int SDLCALL SDL_LockSurface(SDL_Surface * surface);
313
314/**
315 * Release a surface after directly accessing the pixels.
316 *
317 * \param surface the SDL_Surface structure to be unlocked
318 *
319 * \since This function is available since SDL 2.0.0.
320 *
321 * \sa SDL_LockSurface
322 */
323extern DECLSPEC void SDLCALL SDL_UnlockSurface(SDL_Surface * surface);
324
325/**
326 * Load a BMP image from a seekable SDL data stream.
327 *
328 * The new surface should be freed with SDL_FreeSurface(). Not doing so will
329 * result in a memory leak.
330 *
331 * src is an open SDL_RWops buffer, typically loaded with SDL_RWFromFile.
332 * Alternitavely, you might also use the macro SDL_LoadBMP to load a bitmap
333 * from a file, convert it to an SDL_Surface and then close the file.
334 *
335 * \param src the data stream for the surface
336 * \param freesrc non-zero to close the stream after being read
337 * \returns a pointer to a new SDL_Surface structure or NULL if there was an
338 * error; call SDL_GetError() for more information.
339 *
340 * \since This function is available since SDL 2.0.0.
341 *
342 * \sa SDL_FreeSurface
343 * \sa SDL_RWFromFile
344 * \sa SDL_LoadBMP
345 * \sa SDL_SaveBMP_RW
346 */
347extern DECLSPEC SDL_Surface *SDLCALL SDL_LoadBMP_RW(SDL_RWops * src,
348 int freesrc);
349
350/**
351 * Load a surface from a file.
352 *
353 * Convenience macro.
354 */
355#define SDL_LoadBMP(file) SDL_LoadBMP_RW(SDL_RWFromFile(file, "rb"), 1)
356
357/**
358 * Save a surface to a seekable SDL data stream in BMP format.
359 *
360 * Surfaces with a 24-bit, 32-bit and paletted 8-bit format get saved in the
361 * BMP directly. Other RGB formats with 8-bit or higher get converted to a
362 * 24-bit surface or, if they have an alpha mask or a colorkey, to a 32-bit
363 * surface before they are saved. YUV and paletted 1-bit and 4-bit formats are
364 * not supported.
365 *
366 * \param surface the SDL_Surface structure containing the image to be saved
367 * \param dst a data stream to save to
368 * \param freedst non-zero to close the stream after being written
369 * \returns 0 on success or a negative error code on failure; call
370 * SDL_GetError() for more information.
371 *
372 * \since This function is available since SDL 2.0.0.
373 *
374 * \sa SDL_LoadBMP_RW
375 * \sa SDL_SaveBMP
376 */
377extern DECLSPEC int SDLCALL SDL_SaveBMP_RW
378 (SDL_Surface * surface, SDL_RWops * dst, int freedst);
379
380/**
381 * Save a surface to a file.
382 *
383 * Convenience macro.
384 */
385#define SDL_SaveBMP(surface, file) \
386 SDL_SaveBMP_RW(surface, SDL_RWFromFile(file, "wb"), 1)
387
388/**
389 * Set the RLE acceleration hint for a surface.
390 *
391 * If RLE is enabled, color key and alpha blending blits are much faster, but
392 * the surface must be locked before directly accessing the pixels.
393 *
394 * \param surface the SDL_Surface structure to optimize
395 * \param flag 0 to disable, non-zero to enable RLE acceleration
396 * \returns 0 on success or a negative error code on failure; call
397 * SDL_GetError() for more information.
398 *
399 * \since This function is available since SDL 2.0.0.
400 *
401 * \sa SDL_BlitSurface
402 * \sa SDL_LockSurface
403 * \sa SDL_UnlockSurface
404 */
405extern DECLSPEC int SDLCALL SDL_SetSurfaceRLE(SDL_Surface * surface,
406 int flag);
407
408/**
409 * Returns whether the surface is RLE enabled
410 *
411 * It is safe to pass a NULL `surface` here; it will return SDL_FALSE.
412 *
413 * \param surface the SDL_Surface structure to query
414 * \returns SDL_TRUE if the surface is RLE enabled, SDL_FALSE otherwise.
415 *
416 * \since This function is available since SDL 2.0.14.
417 *
418 * \sa SDL_SetSurfaceRLE
419 */
420extern DECLSPEC SDL_bool SDLCALL SDL_HasSurfaceRLE(SDL_Surface * surface);
421
422/**
423 * Set the color key (transparent pixel) in a surface.
424 *
425 * The color key defines a pixel value that will be treated as transparent in
426 * a blit. For example, one can use this to specify that cyan pixels should be
427 * considered transparent, and therefore not rendered.
428 *
429 * It is a pixel of the format used by the surface, as generated by
430 * SDL_MapRGB().
431 *
432 * RLE acceleration can substantially speed up blitting of images with large
433 * horizontal runs of transparent pixels. See SDL_SetSurfaceRLE() for details.
434 *
435 * \param surface the SDL_Surface structure to update
436 * \param flag SDL_TRUE to enable color key, SDL_FALSE to disable color key
437 * \param key the transparent pixel
438 * \returns 0 on success or a negative error code on failure; call
439 * SDL_GetError() for more information.
440 *
441 * \since This function is available since SDL 2.0.0.
442 *
443 * \sa SDL_BlitSurface
444 * \sa SDL_GetColorKey
445 */
446extern DECLSPEC int SDLCALL SDL_SetColorKey(SDL_Surface * surface,
447 int flag, Uint32 key);
448
449/**
450 * Returns whether the surface has a color key
451 *
452 * It is safe to pass a NULL `surface` here; it will return SDL_FALSE.
453 *
454 * \param surface the SDL_Surface structure to query
455 * \return SDL_TRUE if the surface has a color key, SDL_FALSE otherwise.
456 *
457 * \since This function is available since SDL 2.0.9.
458 *
459 * \sa SDL_SetColorKey
460 * \sa SDL_GetColorKey
461 */
462extern DECLSPEC SDL_bool SDLCALL SDL_HasColorKey(SDL_Surface * surface);
463
464/**
465 * Get the color key (transparent pixel) for a surface.
466 *
467 * The color key is a pixel of the format used by the surface, as generated by
468 * SDL_MapRGB().
469 *
470 * If the surface doesn't have color key enabled this function returns -1.
471 *
472 * \param surface the SDL_Surface structure to query
473 * \param key a pointer filled in with the transparent pixel
474 * \returns 0 on success or a negative error code on failure; call
475 * SDL_GetError() for more information.
476 *
477 * \since This function is available since SDL 2.0.0.
478 *
479 * \sa SDL_BlitSurface
480 * \sa SDL_SetColorKey
481 */
482extern DECLSPEC int SDLCALL SDL_GetColorKey(SDL_Surface * surface,
483 Uint32 * key);
484
485/**
486 * Set an additional color value multiplied into blit operations.
487 *
488 * When this surface is blitted, during the blit operation each source color
489 * channel is modulated by the appropriate color value according to the
490 * following formula:
491 *
492 * `srcC = srcC * (color / 255)`
493 *
494 * \param surface the SDL_Surface structure to update
495 * \param r the red color value multiplied into blit operations
496 * \param g the green color value multiplied into blit operations
497 * \param b the blue color value multiplied into blit operations
498 * \returns 0 on success or a negative error code on failure; call
499 * SDL_GetError() for more information.
500 *
501 * \since This function is available since SDL 2.0.0.
502 *
503 * \sa SDL_GetSurfaceColorMod
504 * \sa SDL_SetSurfaceAlphaMod
505 */
506extern DECLSPEC int SDLCALL SDL_SetSurfaceColorMod(SDL_Surface * surface,
507 Uint8 r, Uint8 g, Uint8 b);
508
509
510/**
511 * Get the additional color value multiplied into blit operations.
512 *
513 * \param surface the SDL_Surface structure to query
514 * \param r a pointer filled in with the current red color value
515 * \param g a pointer filled in with the current green color value
516 * \param b a pointer filled in with the current blue color value
517 * \returns 0 on success or a negative error code on failure; call
518 * SDL_GetError() for more information.
519 *
520 * \since This function is available since SDL 2.0.0.
521 *
522 * \sa SDL_GetSurfaceAlphaMod
523 * \sa SDL_SetSurfaceColorMod
524 */
525extern DECLSPEC int SDLCALL SDL_GetSurfaceColorMod(SDL_Surface * surface,
526 Uint8 * r, Uint8 * g,
527 Uint8 * b);
528
529/**
530 * Set an additional alpha value used in blit operations.
531 *
532 * When this surface is blitted, during the blit operation the source alpha
533 * value is modulated by this alpha value according to the following formula:
534 *
535 * `srcA = srcA * (alpha / 255)`
536 *
537 * \param surface the SDL_Surface structure to update
538 * \param alpha the alpha value multiplied into blit operations
539 * \returns 0 on success or a negative error code on failure; call
540 * SDL_GetError() for more information.
541 *
542 * \since This function is available since SDL 2.0.0.
543 *
544 * \sa SDL_GetSurfaceAlphaMod
545 * \sa SDL_SetSurfaceColorMod
546 */
547extern DECLSPEC int SDLCALL SDL_SetSurfaceAlphaMod(SDL_Surface * surface,
548 Uint8 alpha);
549
550/**
551 * Get the additional alpha value used in blit operations.
552 *
553 * \param surface the SDL_Surface structure to query
554 * \param alpha a pointer filled in with the current alpha value
555 * \returns 0 on success or a negative error code on failure; call
556 * SDL_GetError() for more information.
557 *
558 * \since This function is available since SDL 2.0.0.
559 *
560 * \sa SDL_GetSurfaceColorMod
561 * \sa SDL_SetSurfaceAlphaMod
562 */
563extern DECLSPEC int SDLCALL SDL_GetSurfaceAlphaMod(SDL_Surface * surface,
564 Uint8 * alpha);
565
566/**
567 * Set the blend mode used for blit operations.
568 *
569 * To copy a surface to another surface (or texture) without blending with the
570 * existing data, the blendmode of the SOURCE surface should be set to
571 * `SDL_BLENDMODE_NONE`.
572 *
573 * \param surface the SDL_Surface structure to update
574 * \param blendMode the SDL_BlendMode to use for blit blending
575 * \returns 0 on success or a negative error code on failure; call
576 * SDL_GetError() for more information.
577 *
578 * \since This function is available since SDL 2.0.0.
579 *
580 * \sa SDL_GetSurfaceBlendMode
581 */
582extern DECLSPEC int SDLCALL SDL_SetSurfaceBlendMode(SDL_Surface * surface,
583 SDL_BlendMode blendMode);
584
585/**
586 * Get the blend mode used for blit operations.
587 *
588 * \param surface the SDL_Surface structure to query
589 * \param blendMode a pointer filled in with the current SDL_BlendMode
590 * \returns 0 on success or a negative error code on failure; call
591 * SDL_GetError() for more information.
592 *
593 * \since This function is available since SDL 2.0.0.
594 *
595 * \sa SDL_SetSurfaceBlendMode
596 */
597extern DECLSPEC int SDLCALL SDL_GetSurfaceBlendMode(SDL_Surface * surface,
598 SDL_BlendMode *blendMode);
599
600/**
601 * Set the clipping rectangle for a surface.
602 *
603 * When `surface` is the destination of a blit, only the area within the clip
604 * rectangle is drawn into.
605 *
606 * Note that blits are automatically clipped to the edges of the source and
607 * destination surfaces.
608 *
609 * \param surface the SDL_Surface structure to be clipped
610 * \param rect the SDL_Rect structure representing the clipping rectangle, or
611 * NULL to disable clipping
612 * \returns SDL_TRUE if the rectangle intersects the surface, otherwise
613 * SDL_FALSE and blits will be completely clipped.
614 *
615 * \since This function is available since SDL 2.0.0.
616 *
617 * \sa SDL_BlitSurface
618 * \sa SDL_GetClipRect
619 */
620extern DECLSPEC SDL_bool SDLCALL SDL_SetClipRect(SDL_Surface * surface,
621 const SDL_Rect * rect);
622
623/**
624 * Get the clipping rectangle for a surface.
625 *
626 * When `surface` is the destination of a blit, only the area within the clip
627 * rectangle is drawn into.
628 *
629 * \param surface the SDL_Surface structure representing the surface to be
630 * clipped
631 * \param rect an SDL_Rect structure filled in with the clipping rectangle for
632 * the surface
633 *
634 * \since This function is available since SDL 2.0.0.
635 *
636 * \sa SDL_BlitSurface
637 * \sa SDL_SetClipRect
638 */
639extern DECLSPEC void SDLCALL SDL_GetClipRect(SDL_Surface * surface,
640 SDL_Rect * rect);
641
642/*
643 * Creates a new surface identical to the existing surface.
644 *
645 * The returned surface should be freed with SDL_FreeSurface().
646 *
647 * \param surface the surface to duplicate.
648 * \returns a copy of the surface, or NULL on failure; call SDL_GetError() for
649 * more information.
650 */
651extern DECLSPEC SDL_Surface *SDLCALL SDL_DuplicateSurface(SDL_Surface * surface);
652
653/**
654 * Copy an existing surface to a new surface of the specified format.
655 *
656 * This function is used to optimize images for faster *repeat* blitting. This
657 * is accomplished by converting the original and storing the result as a new
658 * surface. The new, optimized surface can then be used as the source for
659 * future blits, making them faster.
660 *
661 * \param src the existing SDL_Surface structure to convert
662 * \param fmt the SDL_PixelFormat structure that the new surface is optimized
663 * for
664 * \param flags the flags are unused and should be set to 0; this is a
665 * leftover from SDL 1.2's API
666 * \returns the new SDL_Surface structure that is created or NULL if it fails;
667 * call SDL_GetError() for more information.
668 *
669 * \since This function is available since SDL 2.0.0.
670 *
671 * \sa SDL_AllocFormat
672 * \sa SDL_ConvertSurfaceFormat
673 * \sa SDL_CreateRGBSurface
674 */
675extern DECLSPEC SDL_Surface *SDLCALL SDL_ConvertSurface
676 (SDL_Surface * src, const SDL_PixelFormat * fmt, Uint32 flags);
677
678/**
679 * Copy an existing surface to a new surface of the specified format enum.
680 *
681 * This function operates just like SDL_ConvertSurface(), but accepts an
682 * SDL_PixelFormatEnum value instead of an SDL_PixelFormat structure. As such,
683 * it might be easier to call but it doesn't have access to palette
684 * information for the destination surface, in case that would be important.
685 *
686 * \param src the existing SDL_Surface structure to convert
687 * \param pixel_format the SDL_PixelFormatEnum that the new surface is
688 * optimized for
689 * \param flags the flags are unused and should be set to 0; this is a
690 * leftover from SDL 1.2's API
691 * \returns the new SDL_Surface structure that is created or NULL if it fails;
692 * call SDL_GetError() for more information.
693 *
694 * \since This function is available since SDL 2.0.0.
695 *
696 * \sa SDL_AllocFormat
697 * \sa SDL_ConvertSurface
698 * \sa SDL_CreateRGBSurface
699 */
700extern DECLSPEC SDL_Surface *SDLCALL SDL_ConvertSurfaceFormat
701 (SDL_Surface * src, Uint32 pixel_format, Uint32 flags);
702
703/**
704 * Copy a block of pixels of one format to another format.
705 *
706 * \param width the width of the block to copy, in pixels
707 * \param height the height of the block to copy, in pixels
708 * \param src_format an SDL_PixelFormatEnum value of the `src` pixels format
709 * \param src a pointer to the source pixels
710 * \param src_pitch the pitch of the source pixels, in bytes
711 * \param dst_format an SDL_PixelFormatEnum value of the `dst` pixels format
712 * \param dst a pointer to be filled in with new pixel data
713 * \param dst_pitch the pitch of the destination pixels, in bytes
714 * \returns 0 on success or a negative error code on failure; call
715 * SDL_GetError() for more information.
716 *
717 * \since This function is available since SDL 2.0.0.
718 */
719extern DECLSPEC int SDLCALL SDL_ConvertPixels(int width, int height,
720 Uint32 src_format,
721 const void * src, int src_pitch,
722 Uint32 dst_format,
723 void * dst, int dst_pitch);
724
725/**
726 * Premultiply the alpha on a block of pixels.
727 *
728 * This is safe to use with src == dst, but not for other overlapping areas.
729 *
730 * This function is currently only implemented for SDL_PIXELFORMAT_ARGB8888.
731 *
732 * \param width the width of the block to convert, in pixels
733 * \param height the height of the block to convert, in pixels
734 * \param src_format an SDL_PixelFormatEnum value of the `src` pixels format
735 * \param src a pointer to the source pixels
736 * \param src_pitch the pitch of the source pixels, in bytes
737 * \param dst_format an SDL_PixelFormatEnum value of the `dst` pixels format
738 * \param dst a pointer to be filled in with premultiplied pixel data
739 * \param dst_pitch the pitch of the destination pixels, in bytes
740 * \returns 0 on success or a negative error code on failure; call
741 * SDL_GetError() for more information.
742 *
743 * \since This function is available since SDL 2.0.18.
744 */
745extern DECLSPEC int SDLCALL SDL_PremultiplyAlpha(int width, int height,
746 Uint32 src_format,
747 const void * src, int src_pitch,
748 Uint32 dst_format,
749 void * dst, int dst_pitch);
750
751/**
752 * Perform a fast fill of a rectangle with a specific color.
753 *
754 * `color` should be a pixel of the format used by the surface, and can be
755 * generated by SDL_MapRGB() or SDL_MapRGBA(). If the color value contains an
756 * alpha component then the destination is simply filled with that alpha
757 * information, no blending takes place.
758 *
759 * If there is a clip rectangle set on the destination (set via
760 * SDL_SetClipRect()), then this function will fill based on the intersection
761 * of the clip rectangle and `rect`.
762 *
763 * \param dst the SDL_Surface structure that is the drawing target
764 * \param rect the SDL_Rect structure representing the rectangle to fill, or
765 * NULL to fill the entire surface
766 * \param color the color to fill with
767 * \returns 0 on success or a negative error code on failure; call
768 * SDL_GetError() for more information.
769 *
770 * \since This function is available since SDL 2.0.0.
771 *
772 * \sa SDL_FillRects
773 */
774extern DECLSPEC int SDLCALL SDL_FillRect
775 (SDL_Surface * dst, const SDL_Rect * rect, Uint32 color);
776
777/**
778 * Perform a fast fill of a set of rectangles with a specific color.
779 *
780 * `color` should be a pixel of the format used by the surface, and can be
781 * generated by SDL_MapRGB() or SDL_MapRGBA(). If the color value contains an
782 * alpha component then the destination is simply filled with that alpha
783 * information, no blending takes place.
784 *
785 * If there is a clip rectangle set on the destination (set via
786 * SDL_SetClipRect()), then this function will fill based on the intersection
787 * of the clip rectangle and `rect`.
788 *
789 * \param dst the SDL_Surface structure that is the drawing target
790 * \param rects an array of SDL_Rects representing the rectangles to fill.
791 * \param count the number of rectangles in the array
792 * \param color the color to fill with
793 * \returns 0 on success or a negative error code on failure; call
794 * SDL_GetError() for more information.
795 *
796 * \since This function is available since SDL 2.0.0.
797 *
798 * \sa SDL_FillRect
799 */
800extern DECLSPEC int SDLCALL SDL_FillRects
801 (SDL_Surface * dst, const SDL_Rect * rects, int count, Uint32 color);
802
803/* !!! FIXME: merge this documentation with the wiki */
804/**
805 * Performs a fast blit from the source surface to the destination surface.
806 *
807 * This assumes that the source and destination rectangles are
808 * the same size. If either \c srcrect or \c dstrect are NULL, the entire
809 * surface (\c src or \c dst) is copied. The final blit rectangles are saved
810 * in \c srcrect and \c dstrect after all clipping is performed.
811 *
812 * \returns 0 if the blit is successful, otherwise it returns -1.
813 *
814 * The blit function should not be called on a locked surface.
815 *
816 * The blit semantics for surfaces with and without blending and colorkey
817 * are defined as follows:
818 * \verbatim
819 RGBA->RGB:
820 Source surface blend mode set to SDL_BLENDMODE_BLEND:
821 alpha-blend (using the source alpha-channel and per-surface alpha)
822 SDL_SRCCOLORKEY ignored.
823 Source surface blend mode set to SDL_BLENDMODE_NONE:
824 copy RGB.
825 if SDL_SRCCOLORKEY set, only copy the pixels matching the
826 RGB values of the source color key, ignoring alpha in the
827 comparison.
828
829 RGB->RGBA:
830 Source surface blend mode set to SDL_BLENDMODE_BLEND:
831 alpha-blend (using the source per-surface alpha)
832 Source surface blend mode set to SDL_BLENDMODE_NONE:
833 copy RGB, set destination alpha to source per-surface alpha value.
834 both:
835 if SDL_SRCCOLORKEY set, only copy the pixels matching the
836 source color key.
837
838 RGBA->RGBA:
839 Source surface blend mode set to SDL_BLENDMODE_BLEND:
840 alpha-blend (using the source alpha-channel and per-surface alpha)
841 SDL_SRCCOLORKEY ignored.
842 Source surface blend mode set to SDL_BLENDMODE_NONE:
843 copy all of RGBA to the destination.
844 if SDL_SRCCOLORKEY set, only copy the pixels matching the
845 RGB values of the source color key, ignoring alpha in the
846 comparison.
847
848 RGB->RGB:
849 Source surface blend mode set to SDL_BLENDMODE_BLEND:
850 alpha-blend (using the source per-surface alpha)
851 Source surface blend mode set to SDL_BLENDMODE_NONE:
852 copy RGB.
853 both:
854 if SDL_SRCCOLORKEY set, only copy the pixels matching the
855 source color key.
856 \endverbatim
857 *
858 * You should call SDL_BlitSurface() unless you know exactly how SDL
859 * blitting works internally and how to use the other blit functions.
860 */
861#define SDL_BlitSurface SDL_UpperBlit
862
863/**
864 * Perform a fast blit from the source surface to the destination surface.
865 *
866 * SDL_UpperBlit() has been replaced by SDL_BlitSurface(), which is merely a
867 * macro for this function with a less confusing name.
868 *
869 * \since This function is available since SDL 2.0.0.
870 *
871 * \sa SDL_BlitSurface
872 */
873extern DECLSPEC int SDLCALL SDL_UpperBlit
874 (SDL_Surface * src, const SDL_Rect * srcrect,
875 SDL_Surface * dst, SDL_Rect * dstrect);
876
877/**
878 * Perform low-level surface blitting only.
879 *
880 * This is a semi-private blit function and it performs low-level surface
881 * blitting, assuming the input rectangles have already been clipped.
882 *
883 * Unless you know what you're doing, you should be using SDL_BlitSurface()
884 * instead.
885 *
886 * \param src the SDL_Surface structure to be copied from
887 * \param srcrect the SDL_Rect structure representing the rectangle to be
888 * copied, or NULL to copy the entire surface
889 * \param dst the SDL_Surface structure that is the blit target
890 * \param dstrect the SDL_Rect structure representing the rectangle that is
891 * copied into
892 * \returns 0 on success or a negative error code on failure; call
893 * SDL_GetError() for more information.
894 *
895 * \since This function is available since SDL 2.0.0.
896 *
897 * \sa SDL_BlitSurface
898 */
899extern DECLSPEC int SDLCALL SDL_LowerBlit
900 (SDL_Surface * src, SDL_Rect * srcrect,
901 SDL_Surface * dst, SDL_Rect * dstrect);
902
903
904/**
905 * Perform a fast, low quality, stretch blit between two surfaces of the same
906 * format.
907 *
908 * Please use SDL_BlitScaled() instead.
909 *
910 * \since This function is available since SDL 2.0.0.
911 */
912extern DECLSPEC int SDLCALL SDL_SoftStretch(SDL_Surface * src,
913 const SDL_Rect * srcrect,
914 SDL_Surface * dst,
915 const SDL_Rect * dstrect);
916
917/**
918 * Perform bilinear scaling between two surfaces of the same format, 32BPP.
919 *
920 * \since This function is available since SDL 2.0.16.
921 */
922extern DECLSPEC int SDLCALL SDL_SoftStretchLinear(SDL_Surface * src,
923 const SDL_Rect * srcrect,
924 SDL_Surface * dst,
925 const SDL_Rect * dstrect);
926
927
928#define SDL_BlitScaled SDL_UpperBlitScaled
929
930/**
931 * Perform a scaled surface copy to a destination surface.
932 *
933 * SDL_UpperBlitScaled() has been replaced by SDL_BlitScaled(), which is
934 * merely a macro for this function with a less confusing name.
935 *
936 * \since This function is available since SDL 2.0.0.
937 *
938 * \sa SDL_BlitScaled
939 */
940extern DECLSPEC int SDLCALL SDL_UpperBlitScaled
941 (SDL_Surface * src, const SDL_Rect * srcrect,
942 SDL_Surface * dst, SDL_Rect * dstrect);
943
944/**
945 * Perform low-level surface scaled blitting only.
946 *
947 * This is a semi-private function and it performs low-level surface blitting,
948 * assuming the input rectangles have already been clipped.
949 *
950 * \param src the SDL_Surface structure to be copied from
951 * \param srcrect the SDL_Rect structure representing the rectangle to be
952 * copied
953 * \param dst the SDL_Surface structure that is the blit target
954 * \param dstrect the SDL_Rect structure representing the rectangle that is
955 * copied into
956 * \returns 0 on success or a negative error code on failure; call
957 * SDL_GetError() for more information.
958 *
959 * \since This function is available since SDL 2.0.0.
960 *
961 * \sa SDL_BlitScaled
962 */
963extern DECLSPEC int SDLCALL SDL_LowerBlitScaled
964 (SDL_Surface * src, SDL_Rect * srcrect,
965 SDL_Surface * dst, SDL_Rect * dstrect);
966
967/**
968 * Set the YUV conversion mode
969 *
970 * \since This function is available since SDL 2.0.8.
971 */
972extern DECLSPEC void SDLCALL SDL_SetYUVConversionMode(SDL_YUV_CONVERSION_MODE mode);
973
974/**
975 * Get the YUV conversion mode
976 *
977 * \since This function is available since SDL 2.0.8.
978 */
979extern DECLSPEC SDL_YUV_CONVERSION_MODE SDLCALL SDL_GetYUVConversionMode(void);
980
981/**
982 * Get the YUV conversion mode, returning the correct mode for the resolution
983 * when the current conversion mode is SDL_YUV_CONVERSION_AUTOMATIC
984 *
985 * \since This function is available since SDL 2.0.8.
986 */
987extern DECLSPEC SDL_YUV_CONVERSION_MODE SDLCALL SDL_GetYUVConversionModeForResolution(int width, int height);
988
989/* Ends C function definitions when using C++ */
990#ifdef __cplusplus
991}
992#endif
993#include "close_code.h"
994
995#endif /* SDL_surface_h_ */
996
997/* vi: set ts=4 sw=4 expandtab: */
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-22 21:32:45 +0000