This repository has been archived by the owner on Feb 11, 2021. It is now read-only.
/
SDL_surface.h
479 lines (429 loc) · 16.8 KB
1
2
/*
SDL - Simple DirectMedia Layer
3
Copyright (C) 1997-2010 Sam Lantinga
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Sam Lantinga
slouken@libsdl.org
*/
/**
24
25
26
* \file SDL_surface.h
*
* Header file for ::SDL_surface definition and management functions.
27
28
29
30
31
32
33
34
*/
#ifndef _SDL_surface_h
#define _SDL_surface_h
#include "SDL_stdinc.h"
#include "SDL_pixels.h"
#include "SDL_rect.h"
35
#include "SDL_blendmode.h"
36
37
38
39
40
41
42
43
44
45
#include "SDL_rwops.h"
#include "begin_code.h"
/* Set up for C function definitions, even when using C++ */
#ifdef __cplusplus
/* *INDENT-OFF* */
extern "C" {
/* *INDENT-ON* */
#endif
46
47
48
49
50
51
52
/**
* \name Surface flags
*
* These are the currently supported flags for the ::SDL_surface.
*
* \internal
* Used internally (read-only).
53
54
55
56
*/
/*@{*/
#define SDL_PREALLOC 0x00000001 /**< Surface uses preallocated memory */
#define SDL_RLEACCEL 0x00000002 /**< Surface is RLE encoded */
57
/*@}*//*Surface flags*/
58
59
60
61
/**
* Evaluates to true if the surface needs to be locked before access.
*/
62
63
64
#define SDL_MUSTLOCK(S) (((S)->flags & SDL_RLEACCEL) != 0)
/**
65
* \brief A collection of pixels used in software blitting.
66
*
67
* \note This structure should be treated as read-only, except for \c pixels,
68
69
70
71
72
73
74
75
76
77
* which, if not NULL, contains the raw pixel data for the surface.
*/
typedef struct SDL_Surface
{
Uint32 flags; /**< Read-only */
SDL_PixelFormat *format; /**< Read-only */
int w, h; /**< Read-only */
int pitch; /**< Read-only */
void *pixels; /**< Read-write */
78
/** Application data associated with the surface */
79
80
void *userdata; /**< Read-write */
81
/** information needed for surfaces requiring locks */
82
83
84
int locked; /**< Read-only */
void *lock_data; /**< Read-only */
85
/** clipping information */
86
87
SDL_Rect clip_rect; /**< Read-only */
88
/** info for fast blit mapping to other surfaces */
89
90
struct SDL_BlitMap *map; /**< Private */
91
/** format version, bumped at every change to invalidate blit maps */
92
int format_version; /**< Private */
93
94
/** Reference count -- used when freeing surface */
95
96
97
98
int refcount; /**< Read-mostly */
} SDL_Surface;
/**
99
* \brief The type of function used for surface blitting functions.
100
101
102
103
*/
typedef int (*SDL_blit) (struct SDL_Surface * src, SDL_Rect * srcrect,
struct SDL_Surface * dst, SDL_Rect * dstrect);
104
/**
105
* Allocate and free an RGB surface.
106
107
108
109
110
111
112
113
*
* If the depth is 4 or 8 bits, an empty palette is allocated for the surface.
* If the depth is greater than 8 bits, the pixel format is set using the
* flags '[RGB]mask'.
*
* If the function runs out of memory, it will return NULL.
*
* \param flags The \c flags are obsolete and should be set to 0.
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
*/
extern DECLSPEC SDL_Surface *SDLCALL SDL_CreateRGBSurface
(Uint32 flags, int width, int height, int depth,
Uint32 Rmask, Uint32 Gmask, Uint32 Bmask, Uint32 Amask);
extern DECLSPEC SDL_Surface *SDLCALL SDL_CreateRGBSurfaceFrom(void *pixels,
int width,
int height,
int depth,
int pitch,
Uint32 Rmask,
Uint32 Gmask,
Uint32 Bmask,
Uint32 Amask);
extern DECLSPEC void SDLCALL SDL_FreeSurface(SDL_Surface * surface);
/**
130
131
132
133
134
* \brief Set the palette used by a surface.
*
* \return 0, or -1 if the surface format doesn't use a palette.
*
* \note A single palette can be shared with many surfaces.
135
136
137
138
*/
extern DECLSPEC int SDLCALL SDL_SetSurfacePalette(SDL_Surface * surface,
SDL_Palette * palette);
139
/**
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
* \brief Sets up a surface for directly accessing the pixels.
*
* Between calls to SDL_LockSurface() / SDL_UnlockSurface(), you can write
* to and read from \c surface->pixels, using the pixel format stored in
* \c surface->format. Once you are done accessing the surface, you should
* use SDL_UnlockSurface() to release it.
*
* Not all surfaces require locking. If SDL_MUSTLOCK(surface) evaluates
* to 0, then you can read and write to the surface at any time, and the
* pixel format of the surface will not change.
*
* No operating system or library calls should be made between lock/unlock
* pairs, as critical system locks may be held during this time.
*
* SDL_LockSurface() returns 0, or -1 if the surface couldn't be locked.
*
* \sa SDL_UnlockSurface()
157
158
*/
extern DECLSPEC int SDLCALL SDL_LockSurface(SDL_Surface * surface);
159
/** \sa SDL_LockSurface() */
160
161
extern DECLSPEC void SDLCALL SDL_UnlockSurface(SDL_Surface * surface);
162
/**
163
* Load a surface from a seekable SDL data stream (memory or file).
164
*
165
* If \c freesrc is non-zero, the stream will be closed after being read.
166
167
168
169
*
* The new surface should be freed with SDL_FreeSurface().
*
* \return the new surface, or NULL if there was an error.
170
171
172
173
*/
extern DECLSPEC SDL_Surface *SDLCALL SDL_LoadBMP_RW(SDL_RWops * src,
int freesrc);
174
175
176
177
178
/**
* Load a surface from a file.
*
* Convenience macro.
*/
179
180
#define SDL_LoadBMP(file) SDL_LoadBMP_RW(SDL_RWFromFile(file, "rb"), 1)
181
/**
182
* Save a surface to a seekable SDL data stream (memory or file).
183
*
184
* If \c freedst is non-zero, the stream will be closed after being written.
185
186
*
* \return 0 if successful or -1 if there was an error.
187
188
189
190
*/
extern DECLSPEC int SDLCALL SDL_SaveBMP_RW
(SDL_Surface * surface, SDL_RWops * dst, int freedst);
191
192
193
194
195
/**
* Save a surface to a file.
*
* Convenience macro.
*/
196
197
198
#define SDL_SaveBMP(surface, file) \
SDL_SaveBMP_RW(surface, SDL_RWFromFile(file, "wb"), 1)
199
/**
200
201
202
203
204
205
* \brief Sets the RLE acceleration hint for a surface.
*
* \return 0 on success, or -1 if the surface is not valid
*
* \note If RLE is enabled, colorkey and alpha blending blits are much faster,
* but the surface must be locked before directly accessing the pixels.
206
207
208
209
*/
extern DECLSPEC int SDLCALL SDL_SetSurfaceRLE(SDL_Surface * surface,
int flag);
210
/**
211
212
213
214
215
216
217
* \brief Sets the color key (transparent pixel) in a blittable surface.
*
* \param surface The surface to update
* \param flag Non-zero to enable colorkey and 0 to disable colorkey
* \param key The transparent pixel in the native surface format
*
* \return 0 on success, or -1 if the surface is not valid
218
219
*/
extern DECLSPEC int SDLCALL SDL_SetColorKey(SDL_Surface * surface,
220
int flag, Uint32 key);
221
222
/**
223
* \brief Gets the color key (transparent pixel) in a blittable surface.
224
225
226
227
228
229
230
*
* \param surface The surface to update
* \param key A pointer filled in with the transparent pixel in the native
* surface format
*
* \return 0 on success, or -1 if the surface is not valid or colorkey is not
* enabled.
231
232
233
234
*/
extern DECLSPEC int SDLCALL SDL_GetColorKey(SDL_Surface * surface,
Uint32 * key);
235
/**
236
237
238
* \brief Set an additional color value used in blit operations.
*
* \param surface The surface to update.
239
240
241
* \param r The red color value multiplied into blit operations.
* \param g The green color value multiplied into blit operations.
* \param b The blue color value multiplied into blit operations.
242
243
244
245
*
* \return 0 on success, or -1 if the surface is not valid.
*
* \sa SDL_GetSurfaceColorMod()
246
247
248
249
250
251
*/
extern DECLSPEC int SDLCALL SDL_SetSurfaceColorMod(SDL_Surface * surface,
Uint8 r, Uint8 g, Uint8 b);
/**
252
253
254
* \brief Get the additional color value used in blit operations.
*
* \param surface The surface to query.
255
256
257
* \param r A pointer filled in with the current red color value.
* \param g A pointer filled in with the current green color value.
* \param b A pointer filled in with the current blue color value.
258
259
260
261
*
* \return 0 on success, or -1 if the surface is not valid.
*
* \sa SDL_SetSurfaceColorMod()
262
263
264
265
266
267
*/
extern DECLSPEC int SDLCALL SDL_GetSurfaceColorMod(SDL_Surface * surface,
Uint8 * r, Uint8 * g,
Uint8 * b);
/**
268
269
270
* \brief Set an additional alpha value used in blit operations.
*
* \param surface The surface to update.
271
* \param alpha The alpha value multiplied into blit operations.
272
273
274
275
*
* \return 0 on success, or -1 if the surface is not valid.
*
* \sa SDL_GetSurfaceAlphaMod()
276
277
278
279
280
*/
extern DECLSPEC int SDLCALL SDL_SetSurfaceAlphaMod(SDL_Surface * surface,
Uint8 alpha);
/**
281
282
283
* \brief Get the additional alpha value used in blit operations.
*
* \param surface The surface to query.
284
* \param alpha A pointer filled in with the current alpha value.
285
286
287
288
*
* \return 0 on success, or -1 if the surface is not valid.
*
* \sa SDL_SetSurfaceAlphaMod()
289
290
291
292
293
*/
extern DECLSPEC int SDLCALL SDL_GetSurfaceAlphaMod(SDL_Surface * surface,
Uint8 * alpha);
/**
294
295
296
297
298
299
300
301
* \brief Set the blend mode used for blit operations.
*
* \param surface The surface to update.
* \param blendMode ::SDL_BlendMode to use for blit blending.
*
* \return 0 on success, or -1 if the parameters are not valid.
*
* \sa SDL_GetSurfaceBlendMode()
302
303
*/
extern DECLSPEC int SDLCALL SDL_SetSurfaceBlendMode(SDL_Surface * surface,
304
SDL_BlendMode blendMode);
305
306
/**
307
308
309
310
311
312
313
314
* \brief Get the blend mode used for blit operations.
*
* \param surface The surface to query.
* \param blendMode A pointer filled in with the current blend mode.
*
* \return 0 on success, or -1 if the surface is not valid.
*
* \sa SDL_SetSurfaceBlendMode()
315
316
*/
extern DECLSPEC int SDLCALL SDL_GetSurfaceBlendMode(SDL_Surface * surface,
317
SDL_BlendMode *blendMode);
318
319
/**
320
321
322
323
324
325
326
327
328
329
330
* Sets the clipping rectangle for the destination surface in a blit.
*
* If the clip rectangle is NULL, clipping will be disabled.
*
* If the clip rectangle doesn't intersect the surface, the function will
* return SDL_FALSE and blits will be completely clipped. Otherwise the
* function returns SDL_TRUE and blits to the surface will be clipped to
* the intersection of the surface area and the clipping rectangle.
*
* Note that blits are automatically clipped to the edges of the source
* and destination surfaces.
331
332
333
334
*/
extern DECLSPEC SDL_bool SDLCALL SDL_SetClipRect(SDL_Surface * surface,
const SDL_Rect * rect);
335
/**
336
337
338
339
* Gets the clipping rectangle for the destination surface in a blit.
*
* \c rect must be a pointer to a valid rectangle which will be filled
* with the correct values.
340
341
342
343
*/
extern DECLSPEC void SDLCALL SDL_GetClipRect(SDL_Surface * surface,
SDL_Rect * rect);
344
/**
345
346
347
348
349
350
351
352
* Creates a new surface of the specified format, and then copies and maps
* the given surface to it so the blit of the converted surface will be as
* fast as possible. If this function fails, it returns NULL.
*
* The \c flags parameter is passed to SDL_CreateRGBSurface() and has those
* semantics. You can also pass ::SDL_RLEACCEL in the flags parameter and
* SDL will try to RLE accelerate colorkey and alpha blits in the resulting
* surface.
353
354
355
356
*/
extern DECLSPEC SDL_Surface *SDLCALL SDL_ConvertSurface
(SDL_Surface * src, SDL_PixelFormat * fmt, Uint32 flags);
357
358
359
360
361
362
363
364
365
/**
* \brief Copy a block of pixels of one format to another format
*/
extern DECLSPEC int SDLCALL SDL_ConvertPixels(int width, int height,
Uint32 src_format,
const void * src, int src_pitch,
Uint32 dst_format,
void * dst, int dst_pitch);
366
/**
367
368
* Performs a fast fill of the given rectangle with \c color.
*
369
* If \c rect is NULL, the whole surface will be filled with \c color.
370
371
372
373
374
*
* The color should be a pixel of the format used by the surface, and
* can be generated by the SDL_MapRGB() function.
*
* \return 0 on success, or -1 on error.
375
376
*/
extern DECLSPEC int SDLCALL SDL_FillRect
377
378
379
(SDL_Surface * dst, const SDL_Rect * rect, Uint32 color);
extern DECLSPEC int SDLCALL SDL_FillRects
(SDL_Surface * dst, const SDL_Rect ** rects, int count, Uint32 color);
380
381
/**
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
* Performs a fast blit from the source surface to the destination surface.
*
* This assumes that the source and destination rectangles are
* the same size. If either \c srcrect or \c dstrect are NULL, the entire
* surface (\c src or \c dst) is copied. The final blit rectangles are saved
* in \c srcrect and \c dstrect after all clipping is performed.
*
* \return If the blit is successful, it returns 0, otherwise it returns -1.
*
* The blit function should not be called on a locked surface.
*
* The blit semantics for surfaces with and without alpha and colorkey
* are defined as follows:
* \verbatim
RGBA->RGB:
SDL_SRCALPHA set:
alpha-blend (using alpha-channel).
SDL_SRCCOLORKEY ignored.
SDL_SRCALPHA not set:
copy RGB.
if SDL_SRCCOLORKEY set, only copy the pixels matching the
RGB values of the source colour key, ignoring alpha in the
comparison.
RGB->RGBA:
SDL_SRCALPHA set:
alpha-blend (using the source per-surface alpha value);
set destination alpha to opaque.
SDL_SRCALPHA not set:
copy RGB, set destination alpha to source per-surface alpha value.
both:
if SDL_SRCCOLORKEY set, only copy the pixels matching the
source colour key.
RGBA->RGBA:
SDL_SRCALPHA set:
alpha-blend (using the source alpha channel) the RGB values;
leave destination alpha untouched. [Note: is this correct?]
SDL_SRCCOLORKEY ignored.
SDL_SRCALPHA not set:
copy all of RGBA to the destination.
if SDL_SRCCOLORKEY set, only copy the pixels matching the
RGB values of the source colour key, ignoring alpha in the
comparison.
RGB->RGB:
SDL_SRCALPHA set:
alpha-blend (using the source per-surface alpha value).
SDL_SRCALPHA not set:
copy RGB.
both:
if SDL_SRCCOLORKEY set, only copy the pixels matching the
source colour key.
\endverbatim
*
* You should call SDL_BlitSurface() unless you know exactly how SDL
* blitting works internally and how to use the other blit functions.
439
440
441
*/
#define SDL_BlitSurface SDL_UpperBlit
442
443
/**
* This is the public blit function, SDL_BlitSurface(), and it performs
444
445
* rectangle validation and clipping before passing it to SDL_LowerBlit()
*/
446
extern DECLSPEC int SDLCALL SDL_UpperBlit
447
(SDL_Surface * src, const SDL_Rect * srcrect,
448
SDL_Surface * dst, SDL_Rect * dstrect);
449
450
451
/**
* This is a semi-private blit function and it performs low-level surface
452
453
* blitting only.
*/
454
455
456
457
458
extern DECLSPEC int SDLCALL SDL_LowerBlit
(SDL_Surface * src, SDL_Rect * srcrect,
SDL_Surface * dst, SDL_Rect * dstrect);
/**
459
460
461
462
* \brief Perform a fast, low quality, stretch blit between two surfaces of the
* same pixel format.
*
* \note This function uses a static buffer, and is not thread-safe.
463
464
*/
extern DECLSPEC int SDLCALL SDL_SoftStretch(SDL_Surface * src,
465
const SDL_Rect * srcrect,
466
SDL_Surface * dst,
467
const SDL_Rect * dstrect);
468
469
470
471
472
473
474
475
476
477
478
479
/* Ends C function definitions when using C++ */
#ifdef __cplusplus
/* *INDENT-OFF* */
}
/* *INDENT-ON* */
#endif
#include "close_code.h"
#endif /* _SDL_surface_h */
/* vi: set ts=4 sw=4 expandtab: */