static void init_colors (void)
{
int i;
if (need_dither) {
setup_dither (bitdepth, get_color);
} else {
int rw = 5, gw = 5, bw = 5;
colors_allocated = 0;
if (currprefs.color_mode == 2) gw = 6;
switch (gfxvidinfo.pixbytes) {
case 4:
alloc_colors64k (8, 8, 8, 16, 8, 0, 0, 0, 0, 0);
break;
case 2:
alloc_colors64k (rw, gw, bw, gw+bw, bw, 0, 0, 0, 0, 0);
break;
case 1:
alloc_colors256 (get_color);
break;
default:
abort();
}
}
}
static int32_t init_colors (void)
{
if (gfxvidinfo.pixbytes > 1) {
int32_t red_bits = bitsInMask(Rmask);
int32_t green_bits = bitsInMask(Gmask);
int32_t blue_bits = bitsInMask(Bmask);
int32_t red_shift = maskShift(Rmask);
int32_t green_shift = maskShift(Gmask);
int32_t blue_shift = maskShift(Bmask);
if (Amask == 0) {
alloc_colors64k (red_bits, green_bits, blue_bits,
red_shift, green_shift, blue_shift,
0, 0, 0, 0);
} else {
int32_t alpha_shift = maskShift(Amask);
int32_t alpha_bits = bitsInMask(Amask);
alloc_colors64k (red_bits, green_bits, blue_bits,
red_shift, green_shift, blue_shift,
alpha_bits, alpha_shift, /* alpha = */ 0xffffffff, 0);
}
} else {
DEBUG_LOG ("init_colors: only 256 colors\n");
return 0;
}
return 1;
}
static int init_colors (void)
{
write_log("init_colors\n");
alloc_colors64k(g_red_bits, g_green_bits, g_blue_bits, g_red_shift,
g_green_shift, g_blue_shift, 0, 0, 0, 0);
return 1;
}
static void init_colors (void)
{
int i;
if (need_dither) {
setup_dither (bitdepth, get_color);
} else {
int rw = 5, gw = 5, bw = 5;
colors_allocated = 0;
if (currprefs.color_mode == 2) gw = 6;
switch (gfxvidinfo.pixbytes) {
case 4:
alloc_colors64k (8, 8, 8, 16, 8, 0);
break;
case 2:
alloc_colors64k (rw, gw, bw, gw+bw, bw, 0);
break;
case 1:
alloc_colors256 (get_color);
break;
default:
abort();
}
}
switch (gfxvidinfo.pixbytes) {
case 2:
for (i = 0; i < 4096; i++)
xcolors[i] = xcolors[i] * 0x00010001;
gfxvidinfo.can_double = 1;
break;
case 1:
for (i = 0; i < 4096; i++)
xcolors[i] = xcolors[i] * 0x01010101;
gfxvidinfo.can_double = 1;
break;
default:
gfxvidinfo.can_double = 0;
break;
}
}
static int init_colors (void)
{
if (visualInfo.VI_CLASS == TrueColor) {
red_bits = bitsInMask (visualInfo.red_mask);
green_bits = bitsInMask (visualInfo.green_mask);
blue_bits = bitsInMask (visualInfo.blue_mask);
red_shift = maskShift (visualInfo.red_mask);
green_shift = maskShift (visualInfo.green_mask);
blue_shift = maskShift (visualInfo.blue_mask);
}
if (need_dither) {
if (bitdepth == 1)
setup_greydither (1, get_color);
else
setup_dither (bitdepth, get_color);
} else {
if (bitdepth != 8 && bitdepth != 12 && bitdepth != 15
&& bitdepth != 16 && bitdepth != 24) {
write_log ("Unsupported bit depth (%d)\n", bitdepth);
return 0;
}
switch (visualInfo.VI_CLASS) {
case TrueColor:
alloc_colors64k (red_bits, green_bits, blue_bits, red_shift,
green_shift, blue_shift, 0, 0, 0,
inverse_byte_order);
XParseColor (display, cmap, "#000000", &black);
if (! XAllocColor (display, cmap, &black))
write_log ("Whoops??\n");
XParseColor (display, cmap, "#ffffff", &white);
if (! XAllocColor (display, cmap, &white))
write_log ("Whoops??\n");
break;
case GrayScale:
case PseudoColor:
alloc_colors256 (get_color);
break;
default:
write_log ("Unsupported visual class (%d)\n", visualInfo.VI_CLASS);
return 0;
}
}
return 1;
}
static int init_colors(void)
{
int red_bits, green_bits, blue_bits;
int red_shift, green_shift, blue_shift;
/* Truecolor: */
red_bits = bits_in_mask(prSDLScreen->format->Rmask);
green_bits = bits_in_mask(prSDLScreen->format->Gmask);
blue_bits = bits_in_mask(prSDLScreen->format->Bmask);
red_shift = mask_shift(prSDLScreen->format->Rmask);
green_shift = mask_shift(prSDLScreen->format->Gmask);
blue_shift = mask_shift(prSDLScreen->format->Bmask);
alloc_colors64k(red_bits, green_bits, blue_bits, red_shift, green_shift, blue_shift);
notice_new_xcolors();
return 1;
}
static int init_colors (void)
{
int i;
int red_bits, green_bits, blue_bits;
int red_shift, green_shift, blue_shift;
/* Truecolor: */
red_bits = bitsInMask(prSDLScreen->format->Rmask);
green_bits = bitsInMask(prSDLScreen->format->Gmask);
blue_bits = bitsInMask(prSDLScreen->format->Bmask);
red_shift = maskShift(prSDLScreen->format->Rmask);
green_shift = maskShift(prSDLScreen->format->Gmask);
blue_shift = maskShift(prSDLScreen->format->Bmask);
alloc_colors64k (red_bits, green_bits, blue_bits, red_shift, green_shift, blue_shift, 0);
notice_new_xcolors();
for (i = 0; i < 4096; i++)
xcolors[i] = xcolors[i] * 0x00010001;
return 1;
}
static int init_colors (void)
{
int i;
#ifdef DEBUG_GFX
dbg("Function: init_colors");
#endif
/* Truecolor: */
red_bits = bitsInMask(prSDLScreen->format->Rmask);
green_bits = bitsInMask(prSDLScreen->format->Gmask);
blue_bits = bitsInMask(prSDLScreen->format->Bmask);
red_shift = maskShift(prSDLScreen->format->Rmask);
green_shift = maskShift(prSDLScreen->format->Gmask);
blue_shift = maskShift(prSDLScreen->format->Bmask);
alloc_colors64k (red_bits, green_bits, blue_bits, red_shift, green_shift, blue_shift);
for (i = 0; i < 4096; i++)
xcolors[i] = xcolors[i] * 0x00010001;
return 1;
}
static int viewport_setup(void) {
intptr_t width, height, format, rowbytes, pixbytes;
intptr_t rb = 0, gb = 0, bb = 0, ab = 0;
intptr_t rs = 0, gs = 0, bs = 0, as = 0;
printf("creating bitmap\n");
bitmap = glgfx_bitmap_create(glgfx_bitmap_attr_width, bm_width,
glgfx_bitmap_attr_height, bm_height,
glgfx_bitmap_attr_format, bm_format,
glgfx_tag_end);
if (bitmap == NULL) {
return 0;
}
printf("created bitmap %d %d format %08lx\n", bm_width, bm_height, bm_format);
uint32_t* buffer;
if ((buffer = glgfx_bitmap_lock(bitmap, false, true, glgfx_tag_end)) != NULL) {
int x, y;
for (y = 0; y < bm_height; y += 1) {
for (x = 0; x < bm_width; x += 1) {
buffer[x+y*bm_width] = glgfx_pixel_create_a8b8g8r8(y*255/bm_height, 0, x*255/bm_width, 128);
}
}
if (glgfx_bitmap_unlock(bitmap, glgfx_tag_end)) {
printf("updated bitmap\n");
}
}
glgfx_bitmap_getattr(bitmap, glgfx_bitmap_attr_width, &width);
glgfx_bitmap_getattr(bitmap, glgfx_bitmap_attr_height, &height);
glgfx_bitmap_getattr(bitmap, glgfx_bitmap_attr_format, &format);
glgfx_bitmap_getattr(bitmap, glgfx_bitmap_attr_bytesperrow, &rowbytes);
glgfx_pixel_getattr(format, glgfx_pixel_attr_bytesperpixel, &pixbytes);
glgfx_pixel_getattr(format, glgfx_pixel_attr_redbits, &rb);
glgfx_pixel_getattr(format, glgfx_pixel_attr_greenbits, &gb);
glgfx_pixel_getattr(format, glgfx_pixel_attr_bluebits, &bb);
glgfx_pixel_getattr(format, glgfx_pixel_attr_alphabits, &ab);
glgfx_pixel_getattr(format, glgfx_pixel_attr_redshift, &rs);
glgfx_pixel_getattr(format, glgfx_pixel_attr_greenshift, &gs);
glgfx_pixel_getattr(format, glgfx_pixel_attr_blueshift, &bs);
glgfx_pixel_getattr(format, glgfx_pixel_attr_alphashift, &as);
alloc_colors64k(rb, gb, bb, rs, gs, bs, ab, as, ((1 << ab) - 1), 0 /* byte swap? */ );
// Set up callback functions
gfxvidinfo.flush_line = _flush_line;
gfxvidinfo.flush_block = _flush_block;
gfxvidinfo.flush_screen = _flush_screen;
gfxvidinfo.flush_clear_screen = _flush_clear_screen;
gfxvidinfo.lockscr = _lockscr;
gfxvidinfo.unlockscr = _unlockscr;
#ifdef PICASSO96
if (!screen_is_picasso) {
#endif
gfxvidinfo.width = width;
gfxvidinfo.height = height;
gfxvidinfo.pixbytes = pixbytes;
gfxvidinfo.rowbytes = rowbytes;
gfxvidinfo.bufmem = NULL;
gfxvidinfo.emergmem = malloc(rowbytes);
gfxvidinfo.maxblocklines = height;
// gfxvidinfo.maxblocklines = 0;
gfxvidinfo.linemem = NULL;
reset_drawing ();
#ifdef PICASSO96
}
else {
picasso_has_invalid_lines = 0;
picasso_invalid_start = height + 1;
picasso_invalid_stop = -1;
picasso_vidinfo.width = width;
picasso_vidinfo.height = height;
picasso_vidinfo.depth = rb + gb + bb + ab;
picasso_vidinfo.pixbytes = pixbytes;
picasso_vidinfo.rowbytes = rowbytes;
picasso_vidinfo.extra_mem = 1;
p96_buffer = malloc(width*height*pixbytes);
p96_bytes_per_row = width*pixbytes;
memset (picasso_invalid_lines, 0, sizeof picasso_invalid_lines);
}
#endif
if (fullscreen) {
rasinfo = glgfx_viewport_addbitmap(viewport, bitmap,
glgfx_rasinfo_attr_x, 0,
glgfx_rasinfo_attr_y, 0,
glgfx_rasinfo_attr_width, real_width,
glgfx_rasinfo_attr_height, real_height,
glgfx_tag_end);
}
else {
rasinfo = glgfx_viewport_addbitmap(viewport, bitmap,
glgfx_rasinfo_attr_x, (real_width - bm_width) / 2,
glgfx_rasinfo_attr_y, (real_height - bm_height) / 2,
glgfx_rasinfo_attr_width, width,
glgfx_rasinfo_attr_height, height,
glgfx_tag_end);
}
if (rasinfo == NULL) {
return 0;
}
inputdevice_release_all_keys();
reset_hotkeys();
printf("viewport_setup -> 1\n");
return 1;
}
