En los modos de vídeo truecolor, los componentes rojo, verde y azul de cada
pixel son empaquetados directamente en el valor del color, en vez de ser un
índice a una tabla de colores. En los modos de 15 bits hay 5 bits para cada
color, en modos de 16 bits hay 5 bits para rojo y azul y seis para verde, y
los modos de 24 y 32 bits usan ambos 8 bits para cada color (los pixels de
32 bits simplemente tienen un byte extra para alinear los datos). El mapa de
estos componentes puede variar entre ordenadores, pero generalmente será RGB
o BGR. ¡Ya que el mapa no es conocido hasta que seleccione el modo de vídeo
que vaya a usar, debe llamar set_gfx_mode() antes de usar cualquiera de las
siguientes rutinas!
int makecol8(int r, int g, int b);
int makecol15(int r, int g, int b);
int makecol16(int r, int g, int b);
int makecol24(int r, int g, int b);
int makecol32(int r, int g, int b);
Estas rutinas convierten los colores desde un formato independiente del
hardware (rojo, verde y azul que van de 0 a 255) a varios formatos de
pixel dependientes del hardware. Convertir entre formatos de 15, 16, 24 o
32 bits sólo requiere algunos desplazamientos de bits, por lo que es
eficiente. Convertir hacia un color de 8 bits requiere buscar la paleta
para encontrar el color más parecido, algo que es muy lento a no ser que
haya creado un mapa RGB (mire abajo).
Relacionado con:
makecol,
makecol_depth,
makecol15_dither,
rgb_map,
bestfit_color,
set_color_depth.
int makeacol32(int r, int g, int b, int a);
Convierte un color RGBA en un formato de pixel de pantalla de 32 bits, que
incluye un valor alfa (de transparencia). No hay versiones de esta rutina
para otras profundidades de color, porque sólamente el formato de 32 bits
tiene espacio suficiente para guardar un canal alfa útil. Debería usar
colores en formato RGBA sólamente como entrada para draw_trans_sprite()
o draw_trans_rle_sprite() después de llamar a set_alpha_blender(), en vez
de dibujarlos directamente en la pantalla.
Relacionado con:
makeacol,
set_alpha_blender,
set_write_alpha_blender.
int makecol(int r, int g, int b);
Convierte colores desde un formato independiente del hardware (rojo,
verde y azul que van de 0 a 255) al formato de pixel requerido por el
modo de vídeo actual, llamando a las funciones previas makecol de 8, 15,
16, 24, o 32 bits según convenga.
Relacionado con:
makeacol,
makecol8,
makecol_depth,
makecol15_dither,
rgb_map,
set_color_depth.
int makecol_depth(int color_depth, int r, int g, int b);
Convierte colores desde un formato independiente del hardware (rojo,
verde y azul que van de 0 a 255) al formato de pixel requerido por la
profundidad de color especificada.
Relacionado con:
makeacol,
makecol,
makecol8,
makecol15_dither,
rgb_map,
set_color_depth.
int makeacol(int r, int g, int b, int a);
int makeacol_depth(int color_depth, int r, int g, int b, int a);
Convierte colores RGBA en un formato de pixel dependiente de la pantalla.
Si está en un modo inferior al de 32 bits, esto es lo mismo que llamar a
makecol() o makecol_depth(), pero al usar esta rutine es posible crear
valores de color de 32 bits que contienen un canal alpha verdadero de 8
bits junto con los componentes rogo, verde y azul. Sólo debería usar
colores en formato RGBA como dato de entrada para draw_trans_sprite(), o
draw_trans_rle_sprite() tras haber llamado a set_alpha_blender(), en vez
de dibujarlos directamente en la pantalla.
Relacionado con:
makecol,
makecol_depth,
set_alpha_blender,
set_write_alpha_blender.
int makecol15_dither(int r, int g, int b, int x, int y);
int makecol16_dither(int r, int g, int b, int x, int y);
Dados dos valores y coordenadas de pixel, calcula una valor RGB
difuminado de 15 o 16 bits. Esto puede producir mejores resultados al
reducir imágenes de truecolor a hicolor. Aparte de llamar estas funciones
diréctamente, el difuminado hicolor puede ser activado automáticamente al
cargar gráficos llamando la función set_color_conversion(), por ejemplo
set_color_conversion(COLORCONV_REDUCE_TRUE_TO_HI | COLORCONV_DITHER).
Relacionado con:
makecol,
makecol8,
set_color_conversion.
int getr8(int c);
int getg8(int c);
int getb8(int c);
int getr15(int c);
int getg15(int c);
int getb15(int c);
int getr16(int c);
int getg16(int c);
int getb16(int c);
int getr24(int c);
int getg24(int c);
int getb24(int c);
int getr32(int c);
int getg32(int c);
int getb32(int c);
Dado un color en un formato dependiente del hardware, estas funciones
extraen uno de los componentes rojo, verde o azul (de 0 a 255).
Relacionado con:
getr,
getr_depth,
makecol,
set_color_depth.
int geta32(int c);
Dado un color en un formato de píxel en 32 bits, esta función extrae el
componente alfa (de 0 a 255).
Relacionado con:
getr8.
int getr(int c);
int getg(int c);
int getb(int c);
int geta(int c);
Dado un color en el formato usado por el modo de vídeo actual, estas
funciones extraen uno de los componentes rojo, verde, azul o alfa (de 0 a
255), llamando a las funciones previas get de 8, 15, 16, 24 o 32 bits
según convenga. La parte alfa sólo tiene sentido para píxels de 32 bits.
Relacionado con:
getr8,
getr_depth,
makecol,
set_color_depth.
int getr_depth(int color_depth, int c);
int getg_depth(int color_depth, int c);
int getb_depth(int color_depth, int c);
int geta_depth(int color_depth, int c);
Dado un color en el formato usado por la profundidad de color
especificada, estas funciones extraen un componente rojo, verde, azul o
alfa (de 0 a 255). La parte alfa sólo tiene sentido para píxels de 32
bits.
Relacionado con:
getr,
getr8,
geta32,
makecol,
set_color_depth.
extern int palette_color[256];
Tabla de mapa de la paleta que convierte un color (0-255) en el formato
de pixel que está siendo usado por el modo de vídeo. En un modo de 256
colores esto simplemente apunta al índice del array. En modos truecolor
mira el valor especificado en la paleta actual, y lo convierte a ese
valor RGB en el formato de pixel empaquetado apropiado.
Relacionado con:
set_palette,
makecol,
set_color_depth.
#define MASK_COLOR_8 0
#define MASK_COLOR_15 (5.5.5 pink)
#define MASK_COLOR_16 (5.6.5 pink)
#define MASK_COLOR_24 (8.8.8 pink)
#define MASK_COLOR_32 (8.8.8 pink)
Constantes que representan los colores usados para enmascarar los pixels
transparentes de los sprites para cada profundidad de color. En
resoluciones de 256 colores es cero, y en modos truecolor es rosa fucsia
(rojo y azul al máximo, verde a cero).
Relacionado con:
bitmap_mask_color,
makecol,
draw_sprite,
masked_blit.
Volver al Indice