UINT32 segaorun_state::screen_update_shangon(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect) { // start the sprites drawing m_sprites->draw_async(cliprect); // reset priorities screen.priority().fill(0, cliprect); // draw the low priority road layer m_segaic16road->segaic16_road_draw(0, bitmap, cliprect, SEGAIC16_ROAD_BACKGROUND); // draw background m_segaic16vid->segaic16_tilemap_draw(screen, bitmap, cliprect, 0, SEGAIC16_TILEMAP_BACKGROUND, 0, 0x01); m_segaic16vid->segaic16_tilemap_draw(screen, bitmap, cliprect, 0, SEGAIC16_TILEMAP_BACKGROUND, 1, 0x02); // draw foreground m_segaic16vid->segaic16_tilemap_draw(screen, bitmap, cliprect, 0, SEGAIC16_TILEMAP_FOREGROUND, 0, 0x02); m_segaic16vid->segaic16_tilemap_draw(screen, bitmap, cliprect, 0, SEGAIC16_TILEMAP_FOREGROUND, 1, 0x04); // draw the high priority road m_segaic16road->segaic16_road_draw(0, bitmap, cliprect, SEGAIC16_ROAD_FOREGROUND); // text layer // note that we inflate the priority of the text layer to prevent sprites // from drawing over the high scores m_segaic16vid->segaic16_tilemap_draw(screen, bitmap, cliprect, 0, SEGAIC16_TILEMAP_TEXT, 0, 0x08); m_segaic16vid->segaic16_tilemap_draw(screen, bitmap, cliprect, 0, SEGAIC16_TILEMAP_TEXT, 1, 0x08); // mix in sprites bitmap_ind16 &sprites = m_sprites->bitmap(); for (const sparse_dirty_rect *rect = m_sprites->first_dirty_rect(cliprect); rect != NULL; rect = rect->next()) for (int y = rect->min_y; y <= rect->max_y; y++) { UINT16 *dest = &bitmap.pix(y); UINT16 *src = &sprites.pix(y); UINT8 *pri = &screen.priority().pix(y); for (int x = rect->min_x; x <= rect->max_x; x++) { // only process written pixels UINT16 pix = src[x]; if (pix != 0xffff) { // compare sprite priority against tilemap priority int priority = (pix >> 10) & 3; if ((1 << priority) > pri[x]) { // if the color is set to maximum, shadow pixels underneath us if ((pix & 0x03f0) == 0x03f0) dest[x] += (m_paletteram[dest[x]] & 0x8000) ? m_palette_entries*2 : m_palette_entries; // otherwise, just add in sprite palette base else dest[x] = 0x400 | (pix & 0x3ff); } } } }
UINT32 segaybd_state::screen_update(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect) { // if no drawing is happening, fill with black and get out if (!m_segaic16vid->segaic16_display_enable) { bitmap.fill(m_palette->black_pen(), cliprect); return 0; } // start the sprites drawing rectangle yboard_clip(0, 511, 0, 511); m_ysprites->bitmap().fill(0xffff); m_ysprites->draw_async(yboard_clip); m_bsprites->draw_async(cliprect); // apply rotation m_segaic16vid->segaic16_rotate_draw(0, bitmap, cliprect, screen.priority(), m_ysprites->bitmap()); // mix in 16B sprites bitmap_ind16 &sprites = m_bsprites->bitmap(); for (const sparse_dirty_rect *rect = m_bsprites->first_dirty_rect(cliprect); rect != NULL; rect = rect->next()) for (int y = rect->min_y; y <= rect->max_y; y++) { UINT16 *dest = &bitmap.pix(y); UINT16 *src = &sprites.pix(y); UINT8 *pri = &screen.priority().pix(y); for (int x = rect->min_x; x <= rect->max_x; x++) { // only process written pixels UINT16 pix = src[x]; if (pix != 0xffff) { // compare sprite priority against tilemap priority int priority = (pix >> 11) & 0x1e; if (priority < pri[x]) { // if the color is set to maximum, shadow pixels underneath us if ((pix & 0xf) == 0xe) dest[x] += (m_paletteram[dest[x]] & 0x8000) ? m_palette_entries*2 : m_palette_entries; // otherwise, just add in sprite palette base else dest[x] = 0x800 | (pix & 0x7ff); } } } }
void segas18_state::draw_vdp(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect, int priority) { bitmap_ind8 &priority_bitmap = screen.priority(); for (int y = cliprect.min_y; y <= cliprect.max_y; y++) { // UINT16 *src = vdp->m_render_line; // can't use this because we're not in RGB32, which we'll need to be if there are palette effects // UINT16 *src2 = vdp->m_render_line_raw; UINT16 *dst = &bitmap.pix(y); UINT8 *pri = &priority_bitmap.pix(y); for (int x = cliprect.min_x; x <= cliprect.max_x; x++) { if (m_vdp->m_render_line_raw[x] & 0x100) { int pix = m_vdp->m_render_line_raw[x] & 0x3f; if (pix & 0xf) { switch (pix & 0xc0) { case 0x00: dst[x] = pix + 0x2000; /* 0x2040 - would be shadow? */ break; case 0x40: case 0x80: dst[x] = pix + 0x2000; break; case 0xc0: dst[x] = pix + 0x2000; /* 0x2080 - would be higlight? */ break; } pri[x] |= priority; } } } } }
uint32_t segas16a_state::screen_update(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect) { // if no drawing is happening, fill with black and get out if (!m_segaic16vid->m_display_enable) { bitmap.fill(m_palette->black_pen(), cliprect); return 0; } // start the sprites drawing m_sprites->draw_async(cliprect); // reset priorities screen.priority().fill(0, cliprect); // draw background opaquely first, not setting any priorities m_segaic16vid->tilemap_draw( screen, bitmap, cliprect, 0, segaic16_video_device::TILEMAP_BACKGROUND, 0 | TILEMAP_DRAW_OPAQUE, 0x00); m_segaic16vid->tilemap_draw( screen, bitmap, cliprect, 0, segaic16_video_device::TILEMAP_BACKGROUND, 1 | TILEMAP_DRAW_OPAQUE, 0x00); // draw background again, just to set the priorities on non-transparent pixels bitmap_ind16 dummy_bitmap; m_segaic16vid->tilemap_draw( screen, dummy_bitmap, cliprect, 0, segaic16_video_device::TILEMAP_BACKGROUND, 0, 0x01); m_segaic16vid->tilemap_draw( screen, dummy_bitmap, cliprect, 0, segaic16_video_device::TILEMAP_BACKGROUND, 1, 0x02); // draw foreground m_segaic16vid->tilemap_draw( screen, bitmap, cliprect, 0, segaic16_video_device::TILEMAP_FOREGROUND, 0, 0x02); m_segaic16vid->tilemap_draw( screen, bitmap, cliprect, 0, segaic16_video_device::TILEMAP_FOREGROUND, 1, 0x04); // text layer m_segaic16vid->tilemap_draw( screen, bitmap, cliprect, 0, segaic16_video_device::TILEMAP_TEXT, 0, 0x04); m_segaic16vid->tilemap_draw( screen, bitmap, cliprect, 0, segaic16_video_device::TILEMAP_TEXT, 1, 0x08); // mix in sprites bitmap_ind16 &sprites = m_sprites->bitmap(); for (const sparse_dirty_rect *rect = m_sprites->first_dirty_rect(cliprect); rect != nullptr; rect = rect->next()) for (int y = rect->min_y; y <= rect->max_y; y++) { uint16_t *dest = &bitmap.pix(y); uint16_t *src = &sprites.pix(y); uint8_t *pri = &screen.priority().pix(y); for (int x = rect->min_x; x <= rect->max_x; x++) { // only process written pixels uint16_t pix = src[x]; if (pix != 0xffff) { // compare sprite priority against tilemap priority int priority = pix >> 10; if ((1 << priority) > pri[x]) { // if color bits are all 1, this triggers shadow/hilight if ((pix & 0x3f0) == 0x3f0) dest[x] += m_palette_entries; // otherwise, just add in sprite palette base else dest[x] = 0x400 | (pix & 0x3ff); } } } }
UINT32 segaxbd_state::screen_update(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect) { // if no drawing is happening, fill with black and get out if (!m_segaic16vid->segaic16_display_enable) { bitmap.fill(get_black_pen(machine()), cliprect); return 0; } // start the sprites drawing m_sprites->draw_async(cliprect); // reset priorities screen.priority().fill(0, cliprect); // draw the low priority road layer m_segaic16road->segaic16_road_draw(0, bitmap, cliprect, SEGAIC16_ROAD_BACKGROUND); if (m_road_priority == 0) m_segaic16road->segaic16_road_draw(0, bitmap, cliprect, SEGAIC16_ROAD_FOREGROUND); // draw background m_segaic16vid->segaic16_tilemap_draw(screen, bitmap, cliprect, 0, SEGAIC16_TILEMAP_BACKGROUND, 0, 0x01); m_segaic16vid->segaic16_tilemap_draw(screen, bitmap, cliprect, 0, SEGAIC16_TILEMAP_BACKGROUND, 1, 0x02); // draw foreground m_segaic16vid->segaic16_tilemap_draw(screen, bitmap, cliprect, 0, SEGAIC16_TILEMAP_FOREGROUND, 0, 0x02); m_segaic16vid->segaic16_tilemap_draw(screen, bitmap, cliprect, 0, SEGAIC16_TILEMAP_FOREGROUND, 1, 0x04); // draw the high priority road if (m_road_priority == 1) m_segaic16road->segaic16_road_draw(0, bitmap, cliprect, SEGAIC16_ROAD_FOREGROUND); // text layer m_segaic16vid->segaic16_tilemap_draw(screen, bitmap, cliprect, 0, SEGAIC16_TILEMAP_TEXT, 0, 0x04); m_segaic16vid->segaic16_tilemap_draw(screen, bitmap, cliprect, 0, SEGAIC16_TILEMAP_TEXT, 1, 0x08); // mix in sprites bitmap_ind16 &sprites = m_sprites->bitmap(); for (const sparse_dirty_rect *rect = m_sprites->first_dirty_rect(cliprect); rect != NULL; rect = rect->next()) for (int y = rect->min_y; y <= rect->max_y; y++) { UINT16 *dest = &bitmap.pix(y); UINT16 *src = &sprites.pix(y); UINT8 *pri = &screen.priority().pix(y); for (int x = rect->min_x; x <= rect->max_x; x++) { // only process written pixels UINT16 pix = src[x]; if (pix != 0xffff) { // compare sprite priority against tilemap priority int priority = (pix >> 12) & 3; if ((1 << priority) > pri[x]) { // if the shadow flag is set, this triggers shadow/hilight for pen 0xa if ((pix & 0x400f) == 0x400a) dest[x] += (m_paletteram[dest[x]] & 0x8000) ? m_palette_entries*2 : m_palette_entries; // otherwise, just add in sprite palette base else dest[x] = pix & 0xfff; } } } }
UINT32 segas18_state::screen_update(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect) { /* Current understanding of VDP mixing: mixing = 0x00: astorm: layer = 0, pri = 0x00 or 0x01 lghost: layer = 0, pri = 0x00 or 0x01 mixing = 0x01: ddcrew: layer = 0, pri = 0x00 or 0x01 or 0x02 mixing = 0x02: never seen mixing = 0x03: ddcrew: layer = 1, pri = 0x00 or 0x01 or 0x02 mixing = 0x04: astorm: layer = 2 or 3, pri = 0x00 or 0x01 or 0x02 mwalk: layer = 2 or 3, pri = 0x00 or 0x01 or 0x02 mixing = 0x05: ddcrew: layer = 2, pri = 0x04 wwally: layer = 2, pri = 0x04 mixing = 0x06: never seen mixing = 0x07: cltchitr: layer = 1 or 2 or 3, pri = 0x02 or 0x04 or 0x08 mwalk: layer = 3, pri = 0x04 or 0x08 */ int vdplayer = (m_vdp_mixing >> 1) & 3; int vdppri = (m_vdp_mixing & 1) ? (1 << vdplayer) : 0; // if no drawing is happening, fill with black and get out if (!m_segaic16vid->m_display_enable) { bitmap.fill(m_palette->black_pen(), cliprect); return 0; } // start the sprites drawing m_sprites->draw_async(cliprect); // reset priorities screen.priority().fill(0, cliprect); // draw background opaquely first, not setting any priorities m_segaic16vid->tilemap_draw( screen, bitmap, cliprect, 0, SEGAIC16_TILEMAP_BACKGROUND, 0 | TILEMAP_DRAW_OPAQUE, 0x00); m_segaic16vid->tilemap_draw( screen, bitmap, cliprect, 0, SEGAIC16_TILEMAP_BACKGROUND, 1 | TILEMAP_DRAW_OPAQUE, 0x00); if (m_vdp_enable && vdplayer == 0) draw_vdp(screen, bitmap, cliprect, vdppri); // draw background again to draw non-transparent pixels over the VDP and set the priority m_segaic16vid->tilemap_draw( screen, bitmap, cliprect, 0, SEGAIC16_TILEMAP_BACKGROUND, 0, 0x01); m_segaic16vid->tilemap_draw( screen, bitmap, cliprect, 0, SEGAIC16_TILEMAP_BACKGROUND, 1, 0x02); if (m_vdp_enable && vdplayer == 1) draw_vdp(screen, bitmap, cliprect, vdppri); // draw foreground m_segaic16vid->tilemap_draw( screen, bitmap, cliprect, 0, SEGAIC16_TILEMAP_FOREGROUND, 0, 0x02); m_segaic16vid->tilemap_draw( screen, bitmap, cliprect, 0, SEGAIC16_TILEMAP_FOREGROUND, 1, 0x04); if (m_vdp_enable && vdplayer == 2) draw_vdp(screen, bitmap, cliprect, vdppri); // text layer m_segaic16vid->tilemap_draw( screen, bitmap, cliprect, 0, SEGAIC16_TILEMAP_TEXT, 0, 0x04); m_segaic16vid->tilemap_draw( screen, bitmap, cliprect, 0, SEGAIC16_TILEMAP_TEXT, 1, 0x08); if (m_vdp_enable && vdplayer == 3) draw_vdp(screen, bitmap, cliprect, vdppri); // mix in sprites bitmap_ind16 &sprites = m_sprites->bitmap(); for (const sparse_dirty_rect *rect = m_sprites->first_dirty_rect(cliprect); rect != NULL; rect = rect->next()) { for (int y = rect->min_y; y <= rect->max_y; y++) { UINT16 *dest = &bitmap.pix(y); UINT16 *src = &sprites.pix(y); UINT8 *pri = &screen.priority().pix(y); for (int x = rect->min_x; x <= rect->max_x; x++) { // only process written pixels UINT16 pix = src[x]; if (pix != 0xffff) { // compare sprite priority against tilemap priority int priority = (pix >> 10) & 3; if ((1 << priority) > pri[x]) { // if the color is set to maximum, shadow pixels underneath us if ((pix & 0x03f0) == 0x03f0) dest[x] += (m_paletteram[dest[x]] & 0x8000) ? m_palette_entries*2 : m_palette_entries; // otherwise, just add in sprite palette base else dest[x] = 0x400 | (pix & 0x3ff); } } } } }
UINT32 segaybd_state::screen_update(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect) { // if no drawing is happening, fill with black and get out if (!m_segaic16vid->m_display_enable) { bitmap.fill(m_palette->black_pen(), cliprect); return 0; } // start the sprites drawing rectangle yboard_clip(0, 511, 0, 511); m_ysprites->bitmap().fill(0xffff); m_ysprites->draw_async(yboard_clip); m_bsprites->draw_async(cliprect); // apply rotation m_segaic16vid->rotate_draw(0, bitmap, cliprect, screen.priority(), m_ysprites->bitmap()); // mix in 16B sprites bitmap_ind16 &sprites = m_bsprites->bitmap(); for (const sparse_dirty_rect *rect = m_bsprites->first_dirty_rect(cliprect); rect != nullptr; rect = rect->next()) for (int y = rect->min_y; y <= rect->max_y; y++) { UINT16 *dest = &bitmap.pix(y); UINT16 *src = &sprites.pix(y); UINT8 *pri = &screen.priority().pix(y); for (int x = rect->min_x; x <= rect->max_x; x++) { // only process written pixels UINT16 pix = src[x]; if (pix != 0xffff) { // the 16b priority bits are stored like this // int colpri = ((data[4] & 0xff) << 4) | (((data[1] >> 9) & 0xf) << 12); // so PPPPppppppppcccc (P = priority p = palette c = colour data) // for Y board the (((data[1] >> 9) & 0xf) << 12) bit is the part we care about // the format of the screen.priority() buffer (populated in rotate_draw) is // ccc----- Sprite color // ---rrrr- Sprite priority // -------1 'was Indirected color data' before rotate_draw, forced to 1 when filling pri buffer // compare sprite priority against tilemap priority int priority = (pix >> 11) & 0x1e; if (priority < (pri[x] & 0x1f)) { // if the color is set to maximum, shadow pixels underneath us if ((pix & 0xf) == 0xe) dest[x] += (m_paletteram[dest[x]] & 0x8000) ? m_palette_entries*2 : m_palette_entries; // otherwise, just add in sprite palette base else dest[x] = 0x800 | (pix & 0x7ff); } } } }
UINT32 segas16b_state::screen_update(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect) { // if no drawing is happening, fill with black and get out if (!m_segaic16vid->segaic16_display_enable) { bitmap.fill(m_palette->black_pen(), cliprect); return 0; } // start the sprites drawing m_sprites->draw_async(cliprect); // reset priorities screen.priority().fill(0, cliprect); // draw background opaquely first, not setting any priorities m_segaic16vid->segaic16_tilemap_draw(screen, bitmap, cliprect, 0, SEGAIC16_TILEMAP_BACKGROUND, 0 | TILEMAP_DRAW_OPAQUE, 0x00); m_segaic16vid->segaic16_tilemap_draw(screen, bitmap, cliprect, 0, SEGAIC16_TILEMAP_BACKGROUND, 1 | TILEMAP_DRAW_OPAQUE, 0x00); // draw background again, just to set the priorities on non-transparent pixels bitmap_ind16 dummy_bitmap; m_segaic16vid->segaic16_tilemap_draw(screen, dummy_bitmap, cliprect, 0, SEGAIC16_TILEMAP_BACKGROUND, 0, 0x01); m_segaic16vid->segaic16_tilemap_draw(screen, dummy_bitmap, cliprect, 0, SEGAIC16_TILEMAP_BACKGROUND, 1, 0x02); // draw foreground m_segaic16vid->segaic16_tilemap_draw(screen, bitmap, cliprect, 0, SEGAIC16_TILEMAP_FOREGROUND, 0, 0x02); m_segaic16vid->segaic16_tilemap_draw(screen, bitmap, cliprect, 0, SEGAIC16_TILEMAP_FOREGROUND, 1, 0x04); // text layer m_segaic16vid->segaic16_tilemap_draw(screen, bitmap, cliprect, 0, SEGAIC16_TILEMAP_TEXT, 0, 0x04); m_segaic16vid->segaic16_tilemap_draw(screen, bitmap, cliprect, 0, SEGAIC16_TILEMAP_TEXT, 1, 0x08); // mix in sprites bitmap_ind16 &sprites = m_sprites->bitmap(); for (const sparse_dirty_rect *rect = m_sprites->first_dirty_rect(cliprect); rect != NULL; rect = rect->next()) for (int y = rect->min_y; y <= rect->max_y; y++) { UINT16 *dest = &bitmap.pix(y); UINT16 *src = &sprites.pix(y); UINT8 *pri = &screen.priority().pix(y); for (int x = rect->min_x; x <= rect->max_x; x++) { // only process written pixels UINT16 pix = src[x]; if (pix != 0xffff) { // compare sprite priority against tilemap priority int priority = (pix >> 10) & 3; if ((1 << priority) > pri[x]) { // if the color is set to maximum, shadow pixels underneath us if ((pix & 0x03f0) == 0x03f0) dest[x] += (m_paletteram[dest[x]] & 0x8000) ? m_palette_entries*2 : m_palette_entries; // otherwise, just add in sprite palette base else dest[x] = 0x400 | (pix & 0x3ff); } } } }
UINT32 segahang_state::screen_update(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect) { // if no drawing is happening, fill with black and get out if (!m_segaic16vid->segaic16_display_enable) { bitmap.fill(get_black_pen(machine()), cliprect); return 0; } // start the sprites drawing m_sprites->draw_async(cliprect); // reset priorities screen.priority().fill(0, cliprect); // draw the low priority road layer m_segaic16road->segaic16_road_draw(0, bitmap, cliprect, SEGAIC16_ROAD_BACKGROUND); // draw background m_segaic16vid->segaic16_tilemap_draw(screen, bitmap, cliprect, 0, SEGAIC16_TILEMAP_BACKGROUND, 0, 0x01); m_segaic16vid->segaic16_tilemap_draw(screen, bitmap, cliprect, 0, SEGAIC16_TILEMAP_BACKGROUND, 1, 0x02); // draw foreground m_segaic16vid->segaic16_tilemap_draw(screen, bitmap, cliprect, 0, SEGAIC16_TILEMAP_FOREGROUND, 0, 0x02); m_segaic16vid->segaic16_tilemap_draw(screen, bitmap, cliprect, 0, SEGAIC16_TILEMAP_FOREGROUND, 1, 0x04); // draw the high priority road m_segaic16road->segaic16_road_draw(0, bitmap, cliprect, SEGAIC16_ROAD_FOREGROUND); // text layer // note that we inflate the priority of the text layer to prevent sprites // from drawing over the high scores m_segaic16vid->segaic16_tilemap_draw(screen, bitmap, cliprect, 0, SEGAIC16_TILEMAP_TEXT, 0, 0x08); m_segaic16vid->segaic16_tilemap_draw(screen, bitmap, cliprect, 0, SEGAIC16_TILEMAP_TEXT, 1, 0x08); // mix in sprites bitmap_ind16 &sprites = m_sprites->bitmap(); for (const sparse_dirty_rect *rect = m_sprites->first_dirty_rect(cliprect); rect != NULL; rect = rect->next()) for (int y = rect->min_y; y <= rect->max_y; y++) { UINT16 *dest = &bitmap.pix(y); UINT16 *src = &sprites.pix(y); UINT8 *pri = &screen.priority().pix(y); // hangon mixing if (!m_sharrier_video) { for (int x = rect->min_x; x <= rect->max_x; x++) { // only process written pixels UINT16 pix = src[x]; if (pix != 0xffff) { // compare sprite priority against tilemap priority int priority = pix >> 10; if ((1 << priority) > pri[x]) { // if color bits are all 1, this triggers shadow/hilight if ((pix & 0x3f0) == 0x3f0) dest[x] += m_shadow ? m_palette_entries*2 : m_palette_entries; // otherwise, just add in sprite palette base else dest[x] = 0x400 | (pix & 0x3ff); } } } } // sharrier mixing else { for (int x = rect->min_x; x <= rect->max_x; x++)