This repository has been archived by the owner. It is now read-only.
Permalink
Cannot retrieve contributors at this time
| /* | |
| SDL - Simple DirectMedia Layer | |
| Copyright (C) 1997-2010 Sam Lantinga | |
| 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 | |
| */ | |
| /** | |
| * \file SDL_pixels.h | |
| * | |
| * Header for the enumerated pixel format definitions. | |
| */ | |
| #ifndef _SDL_pixels_h | |
| #define _SDL_pixels_h | |
| #include "begin_code.h" | |
| /* Set up for C function definitions, even when using C++ */ | |
| #ifdef __cplusplus | |
| /* *INDENT-OFF* */ | |
| extern "C" { | |
| /* *INDENT-ON* */ | |
| #endif | |
| /** | |
| * \name Transparency definitions | |
| * | |
| * These define alpha as the opacity of a surface. | |
| */ | |
| /*@{*/ | |
| #define SDL_ALPHA_OPAQUE 255 | |
| #define SDL_ALPHA_TRANSPARENT 0 | |
| /*@}*/ | |
| /** Pixel type. */ | |
| enum | |
| { | |
| SDL_PIXELTYPE_UNKNOWN, | |
| SDL_PIXELTYPE_INDEX1, | |
| SDL_PIXELTYPE_INDEX4, | |
| SDL_PIXELTYPE_INDEX8, | |
| SDL_PIXELTYPE_PACKED8, | |
| SDL_PIXELTYPE_PACKED16, | |
| SDL_PIXELTYPE_PACKED32, | |
| SDL_PIXELTYPE_ARRAYU8, | |
| SDL_PIXELTYPE_ARRAYU16, | |
| SDL_PIXELTYPE_ARRAYU32, | |
| SDL_PIXELTYPE_ARRAYF16, | |
| SDL_PIXELTYPE_ARRAYF32 | |
| }; | |
| /** Bitmap pixel order, high bit -> low bit. */ | |
| enum | |
| { | |
| SDL_BITMAPORDER_NONE, | |
| SDL_BITMAPORDER_4321, | |
| SDL_BITMAPORDER_1234 | |
| }; | |
| /** Packed component order, high bit -> low bit. */ | |
| enum | |
| { | |
| SDL_PACKEDORDER_NONE, | |
| SDL_PACKEDORDER_XRGB, | |
| SDL_PACKEDORDER_RGBX, | |
| SDL_PACKEDORDER_ARGB, | |
| SDL_PACKEDORDER_RGBA, | |
| SDL_PACKEDORDER_XBGR, | |
| SDL_PACKEDORDER_BGRX, | |
| SDL_PACKEDORDER_ABGR, | |
| SDL_PACKEDORDER_BGRA | |
| }; | |
| /** Array component order, low byte -> high byte. */ | |
| enum | |
| { | |
| SDL_ARRAYORDER_NONE, | |
| SDL_ARRAYORDER_RGB, | |
| SDL_ARRAYORDER_RGBA, | |
| SDL_ARRAYORDER_ARGB, | |
| SDL_ARRAYORDER_BGR, | |
| SDL_ARRAYORDER_BGRA, | |
| SDL_ARRAYORDER_ABGR | |
| }; | |
| /** Packed component layout. */ | |
| enum | |
| { | |
| SDL_PACKEDLAYOUT_NONE, | |
| SDL_PACKEDLAYOUT_332, | |
| SDL_PACKEDLAYOUT_4444, | |
| SDL_PACKEDLAYOUT_1555, | |
| SDL_PACKEDLAYOUT_5551, | |
| SDL_PACKEDLAYOUT_565, | |
| SDL_PACKEDLAYOUT_8888, | |
| SDL_PACKEDLAYOUT_2101010, | |
| SDL_PACKEDLAYOUT_1010102 | |
| }; | |
| #define SDL_DEFINE_PIXELFOURCC(A, B, C, D) \ | |
| ((A) | ((B) << 8) | ((C) << 16) | ((D) << 24)) | |
| #define SDL_DEFINE_PIXELFORMAT(type, order, layout, bits, bytes) \ | |
| ((1 << 31) | ((type) << 24) | ((order) << 20) | ((layout) << 16) | \ | |
| ((bits) << 8) | ((bytes) << 0)) | |
| #define SDL_PIXELTYPE(X) (((X) >> 24) & 0x0F) | |
| #define SDL_PIXELORDER(X) (((X) >> 20) & 0x0F) | |
| #define SDL_PIXELLAYOUT(X) (((X) >> 16) & 0x0F) | |
| #define SDL_BITSPERPIXEL(X) (((X) >> 8) & 0xFF) | |
| #define SDL_BYTESPERPIXEL(X) (((X) >> 0) & 0xFF) | |
| #define SDL_ISPIXELFORMAT_INDEXED(format) \ | |
| ((SDL_PIXELTYPE(format) == SDL_PIXELTYPE_INDEX1) || \ | |
| (SDL_PIXELTYPE(format) == SDL_PIXELTYPE_INDEX4) || \ | |
| (SDL_PIXELTYPE(format) == SDL_PIXELTYPE_INDEX8)) | |
| #define SDL_ISPIXELFORMAT_ALPHA(format) \ | |
| ((SDL_PIXELORDER(format) == SDL_PACKEDORDER_ARGB) || \ | |
| (SDL_PIXELORDER(format) == SDL_PACKEDORDER_RGBA) || \ | |
| (SDL_PIXELORDER(format) == SDL_PACKEDORDER_ABGR) || \ | |
| (SDL_PIXELORDER(format) == SDL_PACKEDORDER_BGRA)) | |
| #define SDL_ISPIXELFORMAT_FOURCC(format) \ | |
| ((format) && !((format) & 0x80000000)) | |
| enum | |
| { | |
| SDL_PIXELFORMAT_UNKNOWN, | |
| SDL_PIXELFORMAT_INDEX1LSB = | |
| SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_INDEX1, SDL_BITMAPORDER_1234, 0, | |
| 1, 0), | |
| SDL_PIXELFORMAT_INDEX1MSB = | |
| SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_INDEX1, SDL_BITMAPORDER_4321, 0, | |
| 1, 0), | |
| SDL_PIXELFORMAT_INDEX4LSB = | |
| SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_INDEX4, SDL_BITMAPORDER_1234, 0, | |
| 4, 0), | |
| SDL_PIXELFORMAT_INDEX4MSB = | |
| SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_INDEX4, SDL_BITMAPORDER_4321, 0, | |
| 4, 0), | |
| SDL_PIXELFORMAT_INDEX8 = | |
| SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_INDEX8, 0, 0, 8, 1), | |
| SDL_PIXELFORMAT_RGB332 = | |
| SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED8, SDL_PACKEDORDER_XRGB, | |
| SDL_PACKEDLAYOUT_332, 8, 1), | |
| SDL_PIXELFORMAT_RGB444 = | |
| SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED16, SDL_PACKEDORDER_XRGB, | |
| SDL_PACKEDLAYOUT_4444, 12, 2), | |
| SDL_PIXELFORMAT_RGB555 = | |
| SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED16, SDL_PACKEDORDER_XRGB, | |
| SDL_PACKEDLAYOUT_1555, 15, 2), | |
| SDL_PIXELFORMAT_BGR555 = | |
| SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED16, SDL_PACKEDORDER_XBGR, | |
| SDL_PACKEDLAYOUT_1555, 15, 2), | |
| SDL_PIXELFORMAT_ARGB4444 = | |
| SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED16, SDL_PACKEDORDER_ARGB, | |
| SDL_PACKEDLAYOUT_4444, 16, 2), | |
| SDL_PIXELFORMAT_ABGR4444 = | |
| SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED16, SDL_PACKEDORDER_ABGR, | |
| SDL_PACKEDLAYOUT_4444, 16, 2), | |
| SDL_PIXELFORMAT_ARGB1555 = | |
| SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED16, SDL_PACKEDORDER_ARGB, | |
| SDL_PACKEDLAYOUT_1555, 16, 2), | |
| SDL_PIXELFORMAT_ABGR1555 = | |
| SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED16, SDL_PACKEDORDER_ABGR, | |
| SDL_PACKEDLAYOUT_1555, 16, 2), | |
| SDL_PIXELFORMAT_RGB565 = | |
| SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED16, SDL_PACKEDORDER_XRGB, | |
| SDL_PACKEDLAYOUT_565, 16, 2), | |
| SDL_PIXELFORMAT_BGR565 = | |
| SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED16, SDL_PACKEDORDER_XBGR, | |
| SDL_PACKEDLAYOUT_565, 16, 2), | |
| SDL_PIXELFORMAT_RGB24 = | |
| SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_ARRAYU8, SDL_ARRAYORDER_RGB, 0, | |
| 24, 3), | |
| SDL_PIXELFORMAT_BGR24 = | |
| SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_ARRAYU8, SDL_ARRAYORDER_BGR, 0, | |
| 24, 3), | |
| SDL_PIXELFORMAT_RGB888 = | |
| SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED32, SDL_PACKEDORDER_XRGB, | |
| SDL_PACKEDLAYOUT_8888, 24, 4), | |
| SDL_PIXELFORMAT_BGR888 = | |
| SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED32, SDL_PACKEDORDER_XBGR, | |
| SDL_PACKEDLAYOUT_8888, 24, 4), | |
| SDL_PIXELFORMAT_ARGB8888 = | |
| SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED32, SDL_PACKEDORDER_ARGB, | |
| SDL_PACKEDLAYOUT_8888, 32, 4), | |
| SDL_PIXELFORMAT_RGBA8888 = | |
| SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED32, SDL_PACKEDORDER_RGBA, | |
| SDL_PACKEDLAYOUT_8888, 32, 4), | |
| SDL_PIXELFORMAT_ABGR8888 = | |
| SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED32, SDL_PACKEDORDER_ABGR, | |
| SDL_PACKEDLAYOUT_8888, 32, 4), | |
| SDL_PIXELFORMAT_BGRA8888 = | |
| SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED32, SDL_PACKEDORDER_BGRA, | |
| SDL_PACKEDLAYOUT_8888, 32, 4), | |
| SDL_PIXELFORMAT_ARGB2101010 = | |
| SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED32, SDL_PACKEDORDER_ARGB, | |
| SDL_PACKEDLAYOUT_2101010, 32, 4), | |
| SDL_PIXELFORMAT_YV12 = /**< Planar mode: Y + V + U (3 planes) */ | |
| SDL_DEFINE_PIXELFOURCC('Y', 'V', '1', '2'), | |
| SDL_PIXELFORMAT_IYUV = /**< Planar mode: Y + U + V (3 planes) */ | |
| SDL_DEFINE_PIXELFOURCC('I', 'Y', 'U', 'V'), | |
| SDL_PIXELFORMAT_YUY2 = /**< Packed mode: Y0+U0+Y1+V0 (1 plane) */ | |
| SDL_DEFINE_PIXELFOURCC('Y', 'U', 'Y', '2'), | |
| SDL_PIXELFORMAT_UYVY = /**< Packed mode: U0+Y0+V0+Y1 (1 plane) */ | |
| SDL_DEFINE_PIXELFOURCC('U', 'Y', 'V', 'Y'), | |
| SDL_PIXELFORMAT_YVYU = /**< Packed mode: Y0+V0+Y1+U0 (1 plane) */ | |
| SDL_DEFINE_PIXELFOURCC('Y', 'V', 'Y', 'U') | |
| }; | |
| typedef struct SDL_Color | |
| { | |
| Uint8 r; | |
| Uint8 g; | |
| Uint8 b; | |
| Uint8 unused; | |
| } SDL_Color; | |
| #define SDL_Colour SDL_Color | |
| typedef struct SDL_Palette SDL_Palette; | |
| typedef int (*SDL_PaletteChangedFunc) (void *userdata, SDL_Palette * palette); | |
| typedef struct SDL_PaletteWatch SDL_PaletteWatch; | |
| struct SDL_Palette | |
| { | |
| int ncolors; | |
| SDL_Color *colors; | |
| int refcount; | |
| SDL_PaletteWatch *watch; | |
| }; | |
| /** | |
| * \note Everything in the pixel format structure is read-only. | |
| */ | |
| typedef struct SDL_PixelFormat | |
| { | |
| SDL_Palette *palette; | |
| Uint8 BitsPerPixel; | |
| Uint8 BytesPerPixel; | |
| Uint8 Rloss; | |
| Uint8 Gloss; | |
| Uint8 Bloss; | |
| Uint8 Aloss; | |
| Uint8 Rshift; | |
| Uint8 Gshift; | |
| Uint8 Bshift; | |
| Uint8 Ashift; | |
| Uint32 Rmask; | |
| Uint32 Gmask; | |
| Uint32 Bmask; | |
| Uint32 Amask; | |
| } SDL_PixelFormat; | |
| /** | |
| * \brief Convert one of the enumerated pixel formats to a bpp and RGBA masks. | |
| * | |
| * \return SDL_TRUE, or SDL_FALSE if the conversion wasn't possible. | |
| * | |
| * \sa SDL_MasksToPixelFormatEnum() | |
| */ | |
| extern DECLSPEC SDL_bool SDLCALL SDL_PixelFormatEnumToMasks(Uint32 format, | |
| int *bpp, | |
| Uint32 * Rmask, | |
| Uint32 * Gmask, | |
| Uint32 * Bmask, | |
| Uint32 * Amask); | |
| /** | |
| * \brief Convert a bpp and RGBA masks to an enumerated pixel format. | |
| * | |
| * \return The pixel format, or ::SDL_PIXELFORMAT_UNKNOWN if the conversion | |
| * wasn't possible. | |
| * | |
| * \sa SDL_PixelFormatEnumToMasks() | |
| */ | |
| extern DECLSPEC Uint32 SDLCALL SDL_MasksToPixelFormatEnum(int bpp, | |
| Uint32 Rmask, | |
| Uint32 Gmask, | |
| Uint32 Bmask, | |
| Uint32 Amask); | |
| /** | |
| * \brief Create a palette structure with the specified number of color | |
| * entries. | |
| * | |
| * \return A new palette, or NULL if there wasn't enough memory. | |
| * | |
| * \note The palette entries are initialized to white. | |
| * | |
| * \sa SDL_FreePalette() | |
| */ | |
| extern DECLSPEC SDL_Palette *SDLCALL SDL_AllocPalette(int ncolors); | |
| /** | |
| * \brief Add a callback function which is called when the palette changes. | |
| * | |
| * \sa SDL_DelPaletteWatch() | |
| */ | |
| extern DECLSPEC int SDLCALL SDL_AddPaletteWatch(SDL_Palette * palette, | |
| SDL_PaletteChangedFunc | |
| callback, void *userdata); | |
| /** | |
| * \brief Remove a callback function previously added with | |
| * SDL_AddPaletteWatch(). | |
| * | |
| * \sa SDL_AddPaletteWatch() | |
| */ | |
| extern DECLSPEC void SDLCALL SDL_DelPaletteWatch(SDL_Palette * palette, | |
| SDL_PaletteChangedFunc | |
| callback, void *userdata); | |
| /** | |
| * \brief Set a range of colors in a palette. | |
| * | |
| * \param palette The palette to modify. | |
| * \param colors An array of colors to copy into the palette. | |
| * \param firstcolor The index of the first palette entry to modify. | |
| * \param ncolors The number of entries to modify. | |
| * | |
| * \return 0 on success, or -1 if not all of the colors could be set. | |
| */ | |
| extern DECLSPEC int SDLCALL SDL_SetPaletteColors(SDL_Palette * palette, | |
| const SDL_Color * colors, | |
| int firstcolor, int ncolors); | |
| /** | |
| * \brief Free a palette created with SDL_AllocPalette(). | |
| * | |
| * \sa SDL_AllocPalette() | |
| */ | |
| extern DECLSPEC void SDLCALL SDL_FreePalette(SDL_Palette * palette); | |
| /** | |
| * \brief Maps an RGB triple to an opaque pixel value for a given pixel format. | |
| * | |
| * \sa SDL_MapRGBA | |
| */ | |
| extern DECLSPEC Uint32 SDLCALL SDL_MapRGB(const SDL_PixelFormat * format, | |
| Uint8 r, Uint8 g, Uint8 b); | |
| /** | |
| * \brief Maps an RGBA quadruple to a pixel value for a given pixel format. | |
| * | |
| * \sa SDL_MapRGB | |
| */ | |
| extern DECLSPEC Uint32 SDLCALL SDL_MapRGBA(const SDL_PixelFormat * format, | |
| Uint8 r, Uint8 g, Uint8 b, | |
| Uint8 a); | |
| /** | |
| * \brief Get the RGB components from a pixel of the specified format. | |
| * | |
| * \sa SDL_GetRGBA | |
| */ | |
| extern DECLSPEC void SDLCALL SDL_GetRGB(Uint32 pixel, | |
| const SDL_PixelFormat * format, | |
| Uint8 * r, Uint8 * g, Uint8 * b); | |
| /** | |
| * \brief Get the RGBA components from a pixel of the specified format. | |
| * | |
| * \sa SDL_GetRGB | |
| */ | |
| extern DECLSPEC void SDLCALL SDL_GetRGBA(Uint32 pixel, | |
| const SDL_PixelFormat * format, | |
| Uint8 * r, Uint8 * g, Uint8 * b, | |
| Uint8 * a); | |
| /* Ends C function definitions when using C++ */ | |
| #ifdef __cplusplus | |
| /* *INDENT-OFF* */ | |
| } | |
| /* *INDENT-ON* */ | |
| #endif | |
| #include "close_code.h" | |
| #endif /* _SDL_pixels_h */ | |
| /* vi: set ts=4 sw=4 expandtab: */ |