Estructura SDL_PixelFormat

Una estructura que contiene información sobre un formato de pixel.

typedef struct SDL_PixelFormat
{
    Uint32 format;
    SDL_Palette *palette;
    Uint8 BitsPerPixel;
    Uint8 BytesPerPixel;
    Uint8 padding[2];
    Uint32 Rmask;
    Uint32 Gmask;
    Uint32 Bmask;
    Uint32 Amask;
    Uint8 Rloss;
    Uint8 Gloss;
    Uint8 Bloss;
    Uint8 Aloss;
    Uint8 Rshift;
    Uint8 Gshift;
    Uint8 Bshift;
    Uint8 Ashift;
    int refcount;
    struct SDL_PixelFormat *next;
} SDL_PixelFormat;

Miembros

format

Uno de los valores SDL_PixelFormatEnum.

palette

Una estructura SDL_Palette asociada con el formato de pixel, o NULL si el formato no tiene una paleta.

BitsPerPixel

Número de bits significativos en un valor de pixel, 8, 15, 16, 24 o 32.

BytesPerPixel

Número de bytes requeridos para contener un valor de pixel, por ejemplo: 1, 2, 3 o 4. Ver las observaciones para los tipos de datos relacionados.

Rmask

Una máscara que representa la posición del componente rojo del pixel.

GMask

Una máscara que representa la posición del componente verde del pixel.

BMask

Una máscara que representa la posición del componente azul del pixel.

AMask

Una máscara que representa la posición del componente alfa del pixel o 0 si el formato de pixel no contiene ninguna información alfa.

Rloss

(Para uso interno).

Gloss

(Para uso interno).

Bloss

(Para uso interno).

Aloss

(Para uso interno).

Rshift

(Para uso interno).

Gshift

(Para uso interno).

Bshift

(Para uso interno).

Ashift

(Para uso interno).

refcount

(Para uso interno).

next

(Para uso interno).

Observaciones

Todos los miembros de la estructura de formato de píxel son de sólo lectura.

Un formato de píxel tiene o bien una paleta o bien máscaras. Si se utiliza una paleta, Rmask, Gmask, Bmask y Amask serán 0.

Los tipos de datos utilizados para representar píxeles son los siguientes:

Un SDL_PixelFormat describe el formato de los datos de píxeles almacenados en el campo píxeles de una SDL_Surface. Cada superficie almacena un SDL_PixelFormat en el campo de formato.

Si se desea realizar modificaciones a nivel de píxel en una superficie, es esencial comprender cómo almacena SDL su información de color. Ver los ejemplos de código para más información.

Para obtener información sobre los espacios de color de píxeles modernos, consulte el siguiente artículo de Wikipedia: http://en.wikipedia.org/wiki/RGBA_color_space.

Ejemplos

Los formatos de píxeles de 8 bits son los más fáciles de entender. Como es un formato de 8 bits, tenemos 8 BitsPorPixel y 1 BytesPorPixel. Como BytesPerPixel es 1, todos los píxeles están representados por un Uint8 que contiene un índice en paleta->colores. Así, para determinar el color de un píxel en una superficie de 8 bits: leeremos el índice de color de surface->pixels y usamos ese índice para leer la estructura SDL_Color de surface->format->palette->colors. Así:

SDL_Surface *surface;
SDL_PixelFormat *fmt;
SDL_Color *color;
Uint8 index;
.
.
/* Create surface */
.
.
fmt=surface->format;

/* Check the bitdepth of the surface */
if(fmt->BitsPerPixel!=8){
  fprintf(stderr, "Not an 8-bit surface.\n");
  return(-1);
}

/* Lock the surface */
SDL_LockSurface(surface);

/* Get the topleft pixel */
index=*(Uint8 *)surface->pixels;
color=&fmt->palette->colors[index];

/* Unlock the surface */
SDL_UnlockSurface(surface);
printf("Pixel Color-> Red: %d, Green: %d, Blue: %d. Index: %d\n",
          color->r, color->g, color->b, index);
.
.

Los formatos de píxel superiores a 8 bits son una experiencia totalmente distinta. Se consideran formatos "TrueColor" y la información de color se almacena en los propios píxeles, no en una paleta. Los campos de máscara, desplazamiento y pérdida nos indican cómo se codifica la información de color. Los campos de máscara nos permiten aislar cada componente de color, los campos de desplazamiento nos indican el número de bits a la derecha de cada componente en el valor del píxel y los campos de pérdida nos indican el número de bits perdidos de cada componente al empaquetar componentes de color de 8 bits en un píxel.

/* Extracting color components from a 32-bit color value */
SDL_PixelFormat *fmt;
SDL_Surface *surface;
Uint32 temp, pixel;
Uint8 red, green, blue, alpha;
.
.
.
fmt = surface->format;
SDL_LockSurface(surface);
pixel = *((Uint32*)surface->pixels);
SDL_UnlockSurface(surface);

/* Get Red component */
temp = pixel & fmt->Rmask;  /* Isolate red component */
temp = temp >> fmt->Rshift; /* Shift it down to 8-bit */
temp = temp << fmt->Rloss;  /* Expand to a full 8-bit number */
red = (Uint8)temp;

/* Get Green component */
temp = pixel & fmt->Gmask;  /* Isolate green component */
temp = temp >> fmt->Gshift; /* Shift it down to 8-bit */
temp = temp << fmt->Gloss;  /* Expand to a full 8-bit number */
green = (Uint8)temp;

/* Get Blue component */
temp = pixel & fmt->Bmask;  /* Isolate blue component */
temp = temp >> fmt->Bshift; /* Shift it down to 8-bit */
temp = temp << fmt->Bloss;  /* Expand to a full 8-bit number */
blue = (Uint8)temp;

/* Get Alpha component */
temp = pixel & fmt->Amask;  /* Isolate alpha component */
temp = temp >> fmt->Ashift; /* Shift it down to 8-bit */
temp = temp << fmt->Aloss;  /* Expand to a full 8-bit number */
alpha = (Uint8)temp;

printf("Pixel Color -> R: %d,  G: %d,  B: %d,  A: %d\n", red, green, blue, alpha);
.
.
.