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