diff --git a/scripts/src/machine.lua b/scripts/src/machine.lua index c49347b1a9695..638c6986b569c 100644 --- a/scripts/src/machine.lua +++ b/scripts/src/machine.lua @@ -3470,6 +3470,8 @@ if (MACHINES["SPG2XX"]~=null) then MAME_DIR .. "src/devices/machine/generalplus_gpl951xx_soc.h", MAME_DIR .. "src/devices/machine/spg_renderer.cpp", MAME_DIR .. "src/devices/machine/spg_renderer.h", + MAME_DIR .. "src/devices/machine/gpl_renderer.cpp", + MAME_DIR .. "src/devices/machine/gpl_renderer.h", } end diff --git a/src/devices/machine/generalplus_gpl162xx_soc_video.cpp b/src/devices/machine/generalplus_gpl162xx_soc_video.cpp index 63c3ee907ac03..137b6755fd277 100644 --- a/src/devices/machine/generalplus_gpl162xx_soc_video.cpp +++ b/src/devices/machine/generalplus_gpl162xx_soc_video.cpp @@ -315,7 +315,8 @@ void gcm394_base_video_device::device_reset() m_page3_addr_lsb = 0; m_page3_addr_msb = 0; - m_renderer->set_video_spaces(m_cpuspace, m_cs_space, m_csbase); + m_renderer->set_video_spaces(m_cpuspace); + m_renderer->set_cs_video_spaces(m_cs_space, m_csbase); } uint32_t gcm394_base_video_device::screen_update(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect) @@ -398,12 +399,12 @@ uint32_t gcm394_base_video_device::screen_update(screen_device &screen, bitmap_r for (int i = 0; i < 4; i++) { - m_renderer->draw_page(true, true, m_703a_palettebank, cliprect, scanline, i, m_page0_addr_msb, m_page0_addr_lsb, m_tmap0_scroll, m_tmap0_regs, mem, m_paletteram, m_rowscroll, 0); - m_renderer->draw_page(true, true, m_703a_palettebank, cliprect, scanline, i, m_page1_addr_msb, m_page1_addr_lsb, m_tmap1_scroll, m_tmap1_regs, mem, m_paletteram, m_rowscroll, 1); - m_renderer->draw_page(true, true, m_703a_palettebank, cliprect, scanline, i, m_page2_addr_msb, m_page2_addr_lsb, m_tmap2_scroll, m_tmap2_regs, mem, m_paletteram, m_rowscroll, 2); - m_renderer->draw_page(true, true, m_703a_palettebank, cliprect, scanline, i, m_page3_addr_msb, m_page3_addr_lsb, m_tmap3_scroll, m_tmap3_regs, mem, m_paletteram, m_rowscroll, 3); + m_renderer->draw_page(true, m_703a_palettebank, cliprect, scanline, i, m_page0_addr_msb, m_page0_addr_lsb, m_tmap0_scroll, m_tmap0_regs, mem, m_paletteram, m_rowscroll, 0); + m_renderer->draw_page(true, m_703a_palettebank, cliprect, scanline, i, m_page1_addr_msb, m_page1_addr_lsb, m_tmap1_scroll, m_tmap1_regs, mem, m_paletteram, m_rowscroll, 1); + m_renderer->draw_page(true, m_703a_palettebank, cliprect, scanline, i, m_page2_addr_msb, m_page2_addr_lsb, m_tmap2_scroll, m_tmap2_regs, mem, m_paletteram, m_rowscroll, 2); + m_renderer->draw_page(true, m_703a_palettebank, cliprect, scanline, i, m_page3_addr_msb, m_page3_addr_lsb, m_tmap3_scroll, m_tmap3_regs, mem, m_paletteram, m_rowscroll, 3); - m_renderer->draw_sprites(true, m_use_legacy_mode ? 2 : 1, m_703a_palettebank, highres, cliprect, scanline, i, sprites_addr, mem, m_paletteram, m_spriteram, -1); + m_renderer->draw_sprites(true, m_use_legacy_mode ? 2 : 1, m_703a_palettebank, highres, cliprect, scanline, i, sprites_addr, mem, m_paletteram, m_spriteram); } m_renderer->apply_saturation_and_fade(bitmap, cliprect, scanline); @@ -749,7 +750,7 @@ void gcm394_base_video_device::sprite_7042_extra_w(uint16_t data) // B = blend mode (0 = use 702a for blending, 1 = use individual sprite blending) // C = co-ordinate mode // E = sprite enable - + //popmessage("extra modes %04x\n", data); } @@ -1156,7 +1157,7 @@ void gcm394_base_video_device::device_add_mconfig(machine_config &config) PALETTE(config, m_palette).set_format(palette_device::xRGB_555, 256*0x10); GFXDECODE(config, m_gfxdecode, m_palette, gfx); - SPG_RENDERER(config, m_renderer, 0); + GPL_RENDERER(config, m_renderer, 0); } diff --git a/src/devices/machine/generalplus_gpl162xx_soc_video.h b/src/devices/machine/generalplus_gpl162xx_soc_video.h index fc60a9c84e901..6fdbae76f1d58 100644 --- a/src/devices/machine/generalplus_gpl162xx_soc_video.h +++ b/src/devices/machine/generalplus_gpl162xx_soc_video.h @@ -11,7 +11,7 @@ #pragma once -#include "spg_renderer.h" +#include "gpl_renderer.h" #include "cpu/unsp/unsp.h" #include "screen.h" #include "emupal.h" @@ -232,7 +232,7 @@ class gcm394_base_video_device : public device_t, public device_video_interface bool m_use_legacy_mode; // could be related to the 'unused' bits in the palete bank select being set, but uncertain bool m_disallow_resolution_control; - required_device m_renderer; + required_device m_renderer; address_space* m_cpuspace; address_space* m_cs_space; diff --git a/src/devices/machine/gpl_renderer.cpp b/src/devices/machine/gpl_renderer.cpp new file mode 100644 index 0000000000000..9612fde91f299 --- /dev/null +++ b/src/devices/machine/gpl_renderer.cpp @@ -0,0 +1,772 @@ +// license:BSD-3-Clause +// copyright-holders:David Haywood, Ryan Holtz + +// GPL162xx (and related) chips have a rendering engine that is similar in some ways to SPG2xx +// but different enough to keep as a separate implementation + +#include "emu.h" +#include "gpl_renderer.h" + +DEFINE_DEVICE_TYPE(GPL_RENDERER, gpl_renderer_device, "gpl_renderer", "GeneralPlus video rendering") + +gpl_renderer_device::gpl_renderer_device(const machine_config &mconfig, device_type type, const char *tag, device_t *owner, uint32_t clock) : + device_t(mconfig, type, tag, owner, clock), + m_space_read_cb(*this, 0) +{ +} + +gpl_renderer_device::gpl_renderer_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock) : + gpl_renderer_device(mconfig, GPL_RENDERER, tag, owner, clock) +{ +} + +void gpl_renderer_device::device_start() +{ + for (uint8_t i = 0; i < 32; i++) + { + m_rgb5_to_rgb8[i] = (i << 3) | (i >> 2); + } + for (uint16_t i = 0; i < 0x8000; i++) + { + m_rgb555_to_rgb888[i] = (m_rgb5_to_rgb8[(i >> 10) & 0x1f] << 16) | + (m_rgb5_to_rgb8[(i >> 5) & 0x1f] << 8) | + (m_rgb5_to_rgb8[(i >> 0) & 0x1f] << 0); + + m_rgb555_to_rgb888_current[i] = 0x0000; + } + + save_item(NAME(m_video_regs_1c)); + save_item(NAME(m_video_regs_1d)); + save_item(NAME(m_video_regs_1e)); + + save_item(NAME(m_video_regs_2a)); + + save_item(NAME(m_video_regs_30)); + save_item(NAME(m_video_regs_3c)); + + save_item(NAME(m_video_regs_42)); + + save_item(NAME(m_ycmp_table)); + + save_item(NAME(m_rgb555_to_rgb888_current)); + save_item(NAME(m_brightness_or_saturation_dirty)); + + // new GPL features + save_item(NAME(m_video_regs_7f)); +} + +void gpl_renderer_device::device_reset() +{ + m_video_regs_1c = 0x0000; + m_video_regs_1d = 0x0000; + m_video_regs_1e = 0x0000; + + m_video_regs_2a = 0x0000; + + m_video_regs_30 = 0x0000; + m_video_regs_3c = 0x0020; + + m_video_regs_42 = 0x0001; + + for (int i = 0; i < 480; i++) + { + m_ycmp_table[i] = 0xffffffff; + } + + m_brightness_or_saturation_dirty = true; + + // new GPL features + m_video_regs_7f = 0x0000; +} + + +// this builds up a line table for the vcmp effect, this is not correct when step is used +// untested on GPL renderer, rarely used even on SPG +void gpl_renderer_device::update_vcmp_table() +{ + int currentline = 0; + + int step = m_video_regs_1e & 0xff; + if (step & 0x80) + step = step - 0x100; + + int current_inc_value = (m_video_regs_1c<<4); + + int counter = 0; + + for (int i = 0; i < 480; i++) + { + if (i < m_video_regs_1d) + { + m_ycmp_table[i] = 0xffffffff; + } + else + { + if ((currentline >= 0) && (currentline < 256)) + { + m_ycmp_table[i] = currentline; + } + + counter += current_inc_value; + + while (counter >= (0x20<<4)) + { + currentline++; + current_inc_value += step; + + counter -= (0x20<<4); + } + } + } +} + +// Perform a lerp between a and b +inline uint8_t gpl_renderer_device::mix_channel(uint8_t bottom, uint8_t top, uint8_t alpha) +{ + return ((0x20 - alpha) * bottom + alpha * top) >> 5; +} + +template +void gpl_renderer_device::draw_tilestrip(bool read_from_csspace, uint32_t screenwidth, uint32_t drawwidthmask, const rectangle &cliprect, uint32_t tile_h, uint32_t tile_w, uint32_t tilegfxdata_addr, uint32_t tile, uint32_t tile_scanline, int drawx, bool flip_y, uint32_t palette_offset, const uint32_t nc_bpp, const uint32_t bits_per_row, const uint32_t words_per_tile, address_space &spc, uint16_t *paletteram, uint8_t blendlevel) +{ + const uint32_t yflipmask = flip_y ? tile_h - 1 : 0; + uint32_t m = tilegfxdata_addr + words_per_tile * tile + bits_per_row * (tile_scanline ^ yflipmask); + uint32_t bits = 0; + uint32_t nbits = 0; + + for (int32_t x = FlipX ? (tile_w - 1) : 0; FlipX ? x >= 0 : x < tile_w; FlipX ? x-- : x++) + { + int realdrawpos = (drawx + x) & drawwidthmask; + + bits <<= nc_bpp; + + if (nbits < nc_bpp) + { + if (!read_from_csspace) + { + uint16_t b = spc.read_word(m++ & 0x3fffff); + b = (b << 8) | (b >> 8); + bits |= b << (nc_bpp - nbits); + nbits += 16; + } + else + { + uint16_t b; + const int addr = m & 0x7ffffff; + if (addr < m_csbase) + { + b = m_cpuspace->read_word(addr); + } + else + { + b = m_cs_space->read_word(addr - m_csbase); + } + m++; + b = (b << 8) | (b >> 8); + bits |= b << (nc_bpp - nbits); + nbits += 16; + } + } + nbits -= nc_bpp; + + uint32_t pal = palette_offset + (bits >> 16); + bits &= 0xffff; + + + if (realdrawpos >= 0 && realdrawpos < screenwidth) + { + uint16_t rgb = paletteram[pal]; + + if (!(rgb & 0x8000)) + { + if (Blend && !(m_linebuf[realdrawpos] & 0x8000)) + { + + m_linebuf[realdrawpos] = (mix_channel((uint8_t)(m_linebuf[realdrawpos] >> 10) & 0x1f, (rgb >> 10) & 0x1f, blendlevel) << 10) | + (mix_channel((uint8_t)(m_linebuf[realdrawpos] >> 5) & 0x1f, (rgb >> 5) & 0x1f, blendlevel) << 5) | + (mix_channel((uint8_t)(m_linebuf[realdrawpos] >> 0) & 0x1f, (rgb >> 0) & 0x1f, blendlevel) << 0); + } + else + { + m_linebuf[realdrawpos] = rgb; + } + } + } + } +} + +void gpl_renderer_device::draw_tilestrip(bool read_from_csspace, uint32_t screenwidth, uint32_t drawwidthmask, bool blend, bool flip_x, const rectangle &cliprect, uint32_t tile_h, uint32_t tile_w, uint32_t tilegfxdata_addr, uint32_t tile, uint32_t tile_scanline, int drawx, bool flip_y, uint32_t palette_offset, const uint32_t nc_bpp, const uint32_t bits_per_row, const uint32_t words_per_tile, address_space &spc, uint16_t *paletteram, uint8_t blendlevel) +{ + if (blend) + { + if (flip_x) + { + draw_tilestrip(read_from_csspace, screenwidth, drawwidthmask, cliprect, tile_h, tile_w, tilegfxdata_addr, tile, tile_scanline, drawx, flip_y, palette_offset, nc_bpp, bits_per_row, words_per_tile, spc, paletteram, blendlevel); + } + else + { + draw_tilestrip(read_from_csspace, screenwidth, drawwidthmask, cliprect, tile_h, tile_w, tilegfxdata_addr, tile, tile_scanline, drawx, flip_y, palette_offset, nc_bpp, bits_per_row, words_per_tile, spc, paletteram, blendlevel); + } + } + else + { + if (flip_x) + { + draw_tilestrip(read_from_csspace, screenwidth, drawwidthmask, cliprect, tile_h, tile_w, tilegfxdata_addr, tile, tile_scanline, drawx, flip_y, palette_offset, nc_bpp, bits_per_row, words_per_tile, spc, paletteram, blendlevel); + } + else + { + draw_tilestrip(read_from_csspace, screenwidth, drawwidthmask, cliprect, tile_h, tile_w, tilegfxdata_addr, tile, tile_scanline, drawx, flip_y, palette_offset, nc_bpp, bits_per_row, words_per_tile, spc, paletteram, blendlevel); + } + } +} + +void gpl_renderer_device::draw_linemap(const rectangle &cliprect, uint32_t scanline, int priority, uint32_t tilegfxdata_addr, uint16_t *scrollregs, uint16_t *tilemapregs, address_space &spc, uint16_t *paletteram) +{ + uint32_t ctrl = tilemapregs[1]; + + if (0) + { + if (ctrl & 0x0010) + popmessage("bitmap mode %08x with rowscroll\n", tilegfxdata_addr); + else + popmessage("bitmap mode %08x\n", tilegfxdata_addr); + } + + // note, in interlace modes it appears every other line is unused? (480 entry table, but with blank values) + // and furthermore the rowscroll and rowzoom tables only have 240 entries, not enough for every line + // the end of the rowscroll table (entries 240-255) contain something else, maybe garbage data as it's offscreen, maybe not + uint32_t tilemap = tilemapregs[2]; + uint32_t palette_map = tilemapregs[3]; + + uint32_t linebase = spc.read_word(tilemap + scanline); // every other word is unused, but there are only enough entries for 240 lines then, sometimes to do with interlace mode? + uint16_t palette = spc.read_word(palette_map + (scanline / 2)); + + if (scanline & 1) + palette >>= 8; + else + palette &= 0xff; + + if (!linebase) + return; + + linebase = linebase | (palette << 16); + + int upperpalselect = 0; + if (tilegfxdata_addr & 0x80000000) + upperpalselect = 1; + + tilegfxdata_addr &= 0x7ffffff; + + // this logic works for jak_s500 and the test modes to get the correct base, doesn't seem to work for jak_car2 ingame, maybe data is copied to wrong place? + int gfxbase = (tilegfxdata_addr & 0x7ffffff) + (linebase & 0x7ffffff); + + for (int i = 0; i < 160; i++) // will have to be 320 for jak_car2 ingame, jak_s500 lines are wider than screen, and zoomed + { + uint16_t pix; + const int addr = gfxbase & 0x7ffffff; + if (addr < m_csbase) + { + pix = m_cpuspace->read_word(addr); + } + else + { + pix = m_cs_space->read_word(addr - m_csbase); + } + gfxbase++; + + int xx; + uint16_t pal; + + if ((scanline >= 0) && (scanline < 480)) + { + xx = i * 2; + + pal = (pix & 0xff) | 0x100; + + if (upperpalselect) + pal |= 0x200; + + if (xx >= 0 && xx <= cliprect.max_x) + { + uint16_t rgb = paletteram[pal]; + + if (!(rgb & 0x8000)) + { + m_linebuf[xx] = rgb; + } + } + + xx = (i * 2) + 1; + pal = (pix >> 8) | 0x100; + + if (upperpalselect) + pal |= 0x200; + + if (xx >= 0 && xx <= cliprect.max_x) + { + uint16_t rgb = paletteram[pal]; + + if (!(rgb & 0x8000)) + { + m_linebuf[xx] = rgb; + } + } + } + } +} + +void gpl_renderer_device::draw_sprite(bool read_from_csspace, int extended_sprites_mode, uint32_t palbank, bool highres, const rectangle &cliprect, uint32_t scanline, int priority, uint32_t spritegfxdata_addr, uint32_t base_addr, address_space &spc, uint16_t *paletteram, uint16_t *spriteram) +{ + uint32_t tilegfxdata_addr = spritegfxdata_addr; + uint32_t tile = spriteram[base_addr + 0]; + int16_t x = spriteram[base_addr + 1]; + int16_t y = spriteram[base_addr + 2]; + uint16_t attr = spriteram[base_addr + 3]; + + if (!tile) + { + return; + } + + if (((attr & 0x3000) >> 12) != priority) + { + return; + } + + uint32_t screenwidth; + uint32_t screenheight; + uint32_t xmask; + uint32_t ymask; + + screenwidth = 320; + screenheight = 256; + xmask = 0x1ff; + ymask = 0x1ff; + + // TODO: higher mask values might apply all the time on GPL + if (highres) + { + screenwidth = 640; + screenheight = 512; + xmask = 0x3ff; + ymask = 0x3ff; + } + + const uint32_t tile_h = 8 << ((attr & 0x00c0) >> 6); + const uint32_t tile_w = 8 << ((attr & 0x0030) >> 4); + + // TODO: only applies in QVGA mode, not VGA mode + if (!(m_video_regs_42 & 0x0002)) + { + x = ((screenwidth/2) + x) - tile_w / 2; + y = ((screenheight/2) - y) - (tile_h / 2); + } + + x &= xmask; + y &= ymask; + + int firstline = y; + int lastline = y + (tile_h - 1); + lastline &= ymask; + + const bool blend = (attr & 0x4000) ? true : false; + bool flip_x = (attr & 0x0004) ? true : false; + bool flip_y = (attr & 0x0008) ? true : false; + const uint8_t bpp = attr & 0x0003; + const uint32_t nc_bpp = ((bpp)+1) << 1; + const uint32_t bits_per_row = nc_bpp * tile_w / 16; + + // Max blend level (3) should result in 100% opacity on the sprite, per docs + // Min blend level (0) should result in 25% opacity on the sprite, per docs + static const uint8_t s_blend_levels[4] = { 0x08, 0x10, 0x18, 0x20 }; + uint8_t blendlevel = s_blend_levels[m_video_regs_2a & 3]; + + uint32_t words_per_tile = bits_per_row * tile_h; + + // 7400 format on GPL162xx is + // + // 7400 - NNNN NNNN NNNN NNNN (N = sprite tile number/address) + // 7401 - AAAA AAXX XXXX XXXX (A = Angle or Y1[5:0], X = Xpos/X0[9:0]) + // 7402 - ZZZZ ZZYY YYYY YYYY (Z = Zoom, or Y2[5:0], Y = Ypos/Y0[9:0]) + // 7403 - pbDD PPPP VVHH FFCC (p = Palette Bank, b = blend, D = depth, P = palette, V = vertical size, H = horizontal size, F = flip, C = colour) + if (m_video_regs_7f & 0x0200) // 'virtual 3D' sprite mode (GPAC800 / GPL16250 only) has 4 extra entries per sprite + { + // 2nd sprite bank is... + // + // 7400 - MMBB BBBB NNNN NNNN - M = Mosaic, B = blend level, N = sprite/tile number/adddress) Attribute 1 of sprite 0 + // 7401 - YYYY YYXX XXXX XXXX - Y = Y3[5:0] X = X1[9:0] X1 of sprite 0 + // 7402 - YYyy yyXX XXXX XXXX - Y = Y3[7:6] y = Y1[9:6] X = X2[9:0] X2 of sprite 0 + // 7403 - YYyy yyXX XXXX XXXX - Y = Y3[9:8] y = Y2[9:6] X = X3[9:0] X3 of sprite 0 + // 7404 - Attribute 1 of sprite 1 + // .... + // + // Normally Zoom/Rotate functions are disabled in this mode, as the attributes are use for co-ordinate data + // but setting Flip to 0x3 causes them to be used (ignoring flip) instead of the extra co-ordinates + flip_x = false; + flip_y = false; + + tile |= (spriteram[(base_addr)+0x400] & 0x00ff) << 16; + blendlevel = ((spriteram[(base_addr)+0x400] & 0x3f00) >> 8); + } + else // regular extended mode, just 1 extra entry per sprite + { + // 2nd sprite bank is... + // 7400 - MMBB BBBB NNNN NNNN - M = Mosaic, B = blend level, N = sprite/tile number/adddress) Attribute 1 of sprite 0 + // .... + + // before or after the 0 tile check? + tile |= (spriteram[(base_addr / 4) + 0x400] & 0x00ff) << 16; + blendlevel = ((spriteram[(base_addr / 4) + 0x400] & 0x3f00) >> 8); + } + + blendlevel >>= 1; // hack, drawing code expects 5 bits, not 6 + + // good for gormiti, smartfp, wrlshunt, paccon, jak_totm, jak_s500, jak_gtg + if (m_video_regs_42 & 0x0010) // direct addressing mode + { + // paccon and smartfp use this mode + words_per_tile = 8; + } + else + { + // extended address bits only used in direct mode, jak_prr and other GPAC500 games rely on this + tile &= 0xffff; + } + + uint32_t palette_offset = (attr & 0x0f00) >> 4; + + // TODO: tkmag220 / myac220 don't set this bit and expect all sprite palettes to be from the same bank as background palettes + // beijuehh (extended_sprites_mode == 2) appears to disagree with that logic, it has this set, but expects palettes and sprites + // from the first bank but also needs the attr & 0x8000 check below for the 'pause' graphics so isn't ignoring the 'extended' + // capabilities entirely. + if ((palbank & 1) && (extended_sprites_mode != 2)) + palette_offset |= 0x100; + + // many other gpl16250 sets have this bit set when they want the upper 256 colours on a per-sprite basis, seems like an extended feature + if (attr & 0x8000) + palette_offset |= 0x200; + + // the Circuit Racing game in PDC100 needs this or some graphics have bad colours at the edges when turning as it leaves stray lower bits set + palette_offset >>= nc_bpp; + palette_offset <<= nc_bpp; + + if (firstline < lastline) + { + int scanx = scanline - firstline; + + if ((scanx >= 0) && (scanline <= lastline)) + { + draw_tilestrip(read_from_csspace, screenwidth, xmask, blend, flip_x, cliprect, tile_h, tile_w, tilegfxdata_addr, tile, scanx, x, flip_y, palette_offset, nc_bpp, bits_per_row, words_per_tile, spc, paletteram, blendlevel); + } + } + else + { + // clipped from top + int tempfirstline = firstline - (screenheight<<1); + int templastline = lastline; + int scanx = scanline - tempfirstline; + + if ((scanx >= 0) && (scanline <= templastline)) + { + draw_tilestrip(read_from_csspace, screenwidth, xmask, blend, flip_x, cliprect, tile_h, tile_w, tilegfxdata_addr, tile, scanx, x, flip_y, palette_offset, nc_bpp, bits_per_row, words_per_tile, spc, paletteram, blendlevel); + } + // clipped against the bottom + tempfirstline = firstline; + templastline = lastline + (screenheight<<1); + scanx = scanline - tempfirstline; + + if ((scanx >= 0) && (scanline <= templastline)) + { + draw_tilestrip(read_from_csspace, screenwidth, xmask, blend, flip_x, cliprect, tile_h, tile_w, tilegfxdata_addr, tile, scanx, x, flip_y, palette_offset, nc_bpp, bits_per_row, words_per_tile, spc, paletteram, blendlevel); + } + } +} + +void gpl_renderer_device::draw_sprites(bool read_from_csspace, int extended_sprites_mode, uint32_t palbank, bool highres, const rectangle &cliprect, uint32_t scanline, int priority, uint32_t spritegfxdata_addr, address_space &spc, uint16_t *paletteram, uint16_t *spriteram) +{ + if (!(m_video_regs_42 & 0x0001)) + return; + + // sprite count / limit appears to be a GPL only feature + int sprlimit = (m_video_regs_42 & 0xff00) >> 8; + if (sprlimit == 0) + sprlimit = 0x100; + + for (uint32_t n = 0; n < sprlimit; n++) + { + draw_sprite(read_from_csspace, extended_sprites_mode, palbank, highres, cliprect, scanline, priority, spritegfxdata_addr, 4 * n, spc, paletteram, spriteram); + } +} + +void gpl_renderer_device::new_line(const rectangle &cliprect) +{ + update_palette_lookup(); + + for (int x = cliprect.min_x; x <= cliprect.max_x; x++) + { + m_linebuf[x] = 0x0000; // non-transparent (paccon blends against the back colour at least) + } +} + +void gpl_renderer_device::draw_page(bool read_from_csspace, uint32_t palbank, const rectangle &cliprect, uint32_t scanline, int priority, uint16_t tilegfxdata_addr_msb, uint16_t tilegfxdata_addr, uint16_t *scrollregs, uint16_t *tilemapregs, address_space &spc, uint16_t *paletteram, uint16_t *scrollram, uint32_t which) +{ + const uint32_t attr = tilemapregs[0]; + const uint32_t ctrl = tilemapregs[1]; + + if (!(ctrl & 0x0008)) + { + return; + } + + if (((attr & 0x3000) >> 12) != priority) + { + return; + } + + // graphic data segments/bases + uint32_t tilegfxdata_addr_full; + + if (m_video_regs_7f & 0x0040) // FREE == 1 + { + tilegfxdata_addr_full = ((tilegfxdata_addr_msb & 0x07ff) << 16) | tilegfxdata_addr; + } + else // FREE == 0 (default / legacy) + { + tilegfxdata_addr_full = tilegfxdata_addr * 0x40; + } + + if (ctrl & 0x0001) // Bitmap / Linemap mode! (basically screen width tile mode) + { + draw_linemap(cliprect, scanline, priority, tilegfxdata_addr_full, scrollregs, tilemapregs, spc, paletteram); + return; + } + + uint32_t logical_scanline = scanline; + + if (ctrl & 0x0040) // 'vertical compression feature' (later models only?) + { + // used by senspeed + //if (m_video_regs_1e != 0x0000) + // popmessage("vertical compression mode with non-0 step amount %04x offset %04x step %04x\n", m_video_regs_1c, m_video_regs_1d, m_video_regs_1e); + + logical_scanline = m_ycmp_table[scanline]; + if (logical_scanline == 0xffffffff) + return; + } + + uint32_t total_width, y_mask, screenwidth; + + // TODO: both bits control overall tilemap size (NOT tied to screen resolution!) + if (attr & 0x8000) + { + total_width = 1024; + y_mask = 0x200; + screenwidth = 640; + } + else + { + total_width = 512; + y_mask = 0x100; + screenwidth = 320; + } + + if (attr & 0x4000) + { + y_mask <<= 1; // double height tilemap? + } + + const uint32_t drawwidthmask = total_width - 1; + y_mask--; // turn into actual mask + + const uint32_t xscroll = scrollregs[0]; + const uint32_t yscroll = scrollregs[1]; + const uint32_t tilemap_rambase = tilemapregs[2]; + const uint32_t exattributemap_rambase = tilemapregs[3]; + const int tile_width = (attr & 0x0030) >> 4; + const uint32_t tile_h = 8 << ((attr & 0x00c0) >> 6); + const uint32_t tile_w = 8 << (tile_width); + const uint32_t tile_count_x = total_width / tile_w; // tilemaps are 512 or 1024 wide depending on screen mode? + const uint32_t bitmap_y = (logical_scanline + yscroll) & y_mask; // tilemaps are 256 or 512 high depending on screen mode? + const uint32_t y0 = bitmap_y / tile_h; + const uint32_t tile_scanline = bitmap_y % tile_h; + const uint8_t bpp = attr & 0x0003; + const uint32_t nc_bpp = ((bpp)+1) << 1; + const uint32_t bits_per_row = nc_bpp * tile_w / 16; + const bool row_scroll = (ctrl & 0x0010); + + // Max blend level (3) should result in 100% opacity, per docs + // Min blend level (0) should result in 25% opacity, per docs + static const uint8_t s_blend_levels[4] = { 0x08, 0x10, 0x18, 0x20 }; + uint8_t blendlevel = s_blend_levels[m_video_regs_2a & 3]; + + // good for gormiti, smartfp, wrlshunt, paccon, jak_totm, jak_s500, jak_gtg + uint32_t words_per_tile; + + if (m_video_regs_7f & 0x0004) // TX_DIRECT + words_per_tile = 8; + else + words_per_tile = bits_per_row * tile_h; + + int realxscroll = xscroll; + + // the logic seems to be different on GPL16250 compared to SPG2xx + // see Galaxian in paccon and Crazy Moto in myac220, is this mode be selected or did behavior just change? + if (row_scroll) + realxscroll += (int16_t)scrollram[logical_scanline & 0xff]; + + const int upperscrollbits = (realxscroll >> (tile_width + 3)); + const int endpos = (screenwidth + tile_w) / tile_w; + + for (uint32_t x0 = 0; x0 < endpos; x0++) + { + bool blend; + bool flip_x; + bool flip_y; + uint32_t tile; + uint32_t palette_offset; + + // get tile info + const int realx0 = (x0 + upperscrollbits) & (tile_count_x - 1); + uint32_t tile_address = realx0 + (tile_count_x * y0); + + tile = (ctrl & 0x0004) ? spc.read_word(tilemap_rambase) : spc.read_word(tilemap_rambase + tile_address); + + // TODO: no skipping in direct modes? + if (!tile) + { + if (m_video_regs_7f & 0x0002) + { + // Galaga in paccon won't render '0' characters in the scoring table if you skip empty tiles, so maybe GPL16250 doesn't skip? - extra tile bits from extended read make no difference + + // probably not based on register m_video_regs_7f, but paccon galaga needs no skip, jak_gtg and jak_hmhsm needs to skip + //49 0100 1001 no skip (paccon galaga) + //4b 0100 1011 skip (paccon pacman) + //53 0101 0011 skip (jak_gtg, jak_hmhsm) + continue; + } + } + + uint32_t tileattr = attr; + uint32_t tilectrl = ctrl; + + if (m_video_regs_7f & 0x0004) // TX_DIRECT + { + uint16_t exattribute = (tilectrl & 0x0004) ? spc.read_word(exattributemap_rambase) : spc.read_word(exattributemap_rambase + tile_address / 2); + if (realx0 & 1) + exattribute >>= 8; + else + exattribute &= 0x00ff; + + // when TX_DIRECT is used the attributes become extra addressing bits (smartfp) + tile |= (exattribute & 0xff) << 16; + //blendlevel = 0x1f; // hack + } + else + { + if ((tilectrl & 2) == 0) + { + // -(1) bld(1) flip(2) pal(4) + uint16_t exattribute = (tilectrl & 0x0004) ? spc.read_word(exattributemap_rambase) : spc.read_word(exattributemap_rambase + tile_address / 2); + if (realx0 & 1) + exattribute >>= 8; + else + exattribute &= 0x00ff; + + tileattr &= ~0x000c; + tileattr |= (exattribute >> 2) & 0x000c; // flip + + tileattr &= ~0x0f00; + tileattr |= (exattribute << 8) & 0x0f00; // palette + + tilectrl &= ~0x0100; + tilectrl |= (exattribute << 2) & 0x0100; // blend + } + } + + blend = (tilectrl & 0x0100) ? true : false; + flip_x = (tileattr & 0x0004) ? true : false; + flip_y = (tileattr & 0x0008) ? true : false; + + palette_offset = (tileattr & 0x0f00) >> 4; + // got tile info + + // TODO, some GPL models use 2 bits here, others only use this + if (tilegfxdata_addr_msb & 0x8000) + palette_offset |= 0x200; + + palette_offset >>= nc_bpp; + palette_offset <<= nc_bpp; + + const int drawx = (x0 * tile_w) - (realxscroll & (tile_w - 1)); + draw_tilestrip(read_from_csspace, screenwidth, drawwidthmask, blend, flip_x, cliprect, tile_h, tile_w, tilegfxdata_addr_full, tile, tile_scanline, drawx, flip_y, palette_offset, nc_bpp, bits_per_row, words_per_tile, spc, paletteram, blendlevel); + } +} + +void gpl_renderer_device::apply_saturation_and_fade(bitmap_rgb32 &bitmap, const rectangle &cliprect, int scanline) +{ + uint32_t* src = &bitmap.pix(scanline, cliprect.min_x); + + for (int x = cliprect.min_x; x <= cliprect.max_x; x++) + { + uint16_t px = (m_linebuf[x] & 0x8000) ? 0x0 : m_linebuf[x]; + *src = m_rgb555_to_rgb888_current[px]; + src++; + } +} + + +void gpl_renderer_device::update_palette_lookup() +{ + if (!m_brightness_or_saturation_dirty) + return; + + static const float s_u8_to_float = 1.0f / 255.0f; + static const float s_gray_r = 0.299f; + static const float s_gray_g = 0.587f; + static const float s_gray_b = 0.114f; + const float sat_adjust = (0xff - (m_video_regs_3c & 0x00ff)) / (float)(0xff - 0x20); + + const uint16_t fade_offset = m_video_regs_30; + + for (uint16_t i = 0; i < 0x8000; i++) + { + uint32_t src = m_rgb555_to_rgb888[i]; + + if ((m_video_regs_3c & 0x00ff) != 0x0020) // apply saturation + { + const uint32_t src_rgb = src; + const float src_r = (uint8_t)(src_rgb >> 16) * s_u8_to_float; + const float src_g = (uint8_t)(src_rgb >> 8) * s_u8_to_float; + const float src_b = (uint8_t)(src_rgb >> 0) * s_u8_to_float; + const float luma = src_r * s_gray_r + src_g * s_gray_g + src_b * s_gray_b; + const float adjusted_r = luma + (src_r - luma) * sat_adjust; + const float adjusted_g = luma + (src_g - luma) * sat_adjust; + const float adjusted_b = luma + (src_b - luma) * sat_adjust; + const int integer_r = (int)floor(adjusted_r * 255.0f); + const int integer_g = (int)floor(adjusted_g * 255.0f); + const int integer_b = (int)floor(adjusted_b * 255.0f); + src = (integer_r > 255 ? 0xff0000 : (integer_r < 0 ? 0 : ((uint8_t)integer_r << 16))) | + (integer_g > 255 ? 0x00ff00 : (integer_g < 0 ? 0 : ((uint8_t)integer_g << 8))) | + (integer_b > 255 ? 0x0000ff : (integer_b < 0 ? 0 : (uint8_t)integer_b)); + } + + if (fade_offset != 0) // apply fade + { + const uint32_t src_rgb = src; + const uint8_t src_r = (src_rgb >> 16) & 0xff; + const uint8_t src_g = (src_rgb >> 8) & 0xff; + const uint8_t src_b = (src_rgb >> 0) & 0xff; + const uint8_t r = src_r - fade_offset; + const uint8_t g = src_g - fade_offset; + const uint8_t b = src_b - fade_offset; + src = (r > src_r ? 0 : (r << 16)) | + (g > src_g ? 0 : (g << 8)) | + (b > src_b ? 0 : (b << 0)); + } + + m_rgb555_to_rgb888_current[i] = src; + } + + m_brightness_or_saturation_dirty = false; +} diff --git a/src/devices/machine/gpl_renderer.h b/src/devices/machine/gpl_renderer.h new file mode 100644 index 0000000000000..260e965f86ebf --- /dev/null +++ b/src/devices/machine/gpl_renderer.h @@ -0,0 +1,108 @@ +// license:BSD-3-Clause +// copyright-holders:David Haywood, Ryan Holtz + +#ifndef MAME_MACHINE_GPL_RENDERER_H +#define MAME_MACHINE_GPL_RENDERER_H + +#pragma once + +#include "screen.h" + +class gpl_renderer_device : public device_t +{ +public: + gpl_renderer_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock); + + void draw_sprites(bool read_from_csspace, int extended_sprites_mode, uint32_t palbank, bool highres, const rectangle &cliprect, uint32_t scanline, int priority, uint32_t spritegfxdata_addr, address_space &spc, uint16_t *paletteram, uint16_t *spriteram); + void draw_page(bool read_from_csspace, uint32_t palbank, const rectangle &cliprect, uint32_t scanline, int priority, uint16_t tilegfxdata_addr_msb, uint16_t tilegfxdata_addr, uint16_t *scrollregs, uint16_t *tilemapregs, address_space &spc, uint16_t *paletteram, uint16_t *scrollram, uint32_t which); + void new_line(const rectangle &cliprect); + + void apply_saturation_and_fade(bitmap_rgb32 &bitmap, const rectangle &cliprect, int scanline); + + void set_video_reg_1c(uint16_t val) { m_video_regs_1c = val; update_vcmp_table(); } + void set_video_reg_1d(uint16_t val) { m_video_regs_1d = val; update_vcmp_table(); } + void set_video_reg_1e(uint16_t val) { m_video_regs_1e = val; update_vcmp_table(); } + void set_video_reg_2a(uint16_t val) { m_video_regs_2a = val; } + void set_video_reg_30(uint16_t val) + { + if (m_video_regs_30 != val) + m_brightness_or_saturation_dirty = true; + + m_video_regs_30 = val; + } + void set_video_reg_3c(uint16_t val) + { + if (m_video_regs_3c != val) + m_brightness_or_saturation_dirty = true; + + m_video_regs_3c = val; + } + + uint16_t get_video_reg_1c(void) { return m_video_regs_1c; } + uint16_t get_video_reg_1d(void) { return m_video_regs_1d; } + uint16_t get_video_reg_1e(void) { return m_video_regs_1e; } + uint16_t get_video_reg_2a(void) { return m_video_regs_2a; } + uint16_t get_video_reg_30(void) { return m_video_regs_30; } + uint16_t get_video_reg_3c(void) { return m_video_regs_3c; } + + void set_video_reg_42(uint16_t val) { m_video_regs_42 = val; } + uint16_t get_video_reg_42(void) { return m_video_regs_42; } + + void set_video_reg_7f(uint16_t val) { m_video_regs_7f = val; } + uint16_t get_video_reg_7f(void) { return m_video_regs_7f; } + + auto space_read_callback() { return m_space_read_cb.bind(); } + void set_video_spaces(address_space *cpuspace) { m_cpuspace = cpuspace; } + void set_cs_video_spaces(address_space *cs_space, uint32_t csbase) { m_cs_space = cs_space; m_csbase = csbase; } + +protected: + gpl_renderer_device(const machine_config &mconfig, device_type type, const char *tag, device_t *owner, uint32_t clock); + + virtual void device_start() override ATTR_COLD; + virtual void device_reset() override ATTR_COLD; + +private: + template + inline void draw_tilestrip(bool read_from_csspace, uint32_t screenwidth, uint32_t drawwidthmask, const rectangle &cliprect, uint32_t tile_h, uint32_t tile_w, uint32_t tilegfxdata_addr, uint32_t tile, uint32_t tile_scanline, int drawx, bool flip_y, uint32_t palette_offset, const uint32_t nc_bpp, const uint32_t bits_per_row, const uint32_t words_per_tile, address_space &spc, uint16_t *palette, uint8_t blendlevel); + inline void draw_tilestrip(bool read_from_csspace, uint32_t screenwidth, uint32_t drawwidthmask, bool blend, bool flip_x, const rectangle &cliprect, uint32_t tile_h, uint32_t tile_w, uint32_t tilegfxdata_addr, uint32_t tile, uint32_t tile_scanline, int drawx, bool flip_y, uint32_t palette_offset, const uint32_t nc_bpp, const uint32_t bits_per_row, const uint32_t words_per_tile, address_space &spc, uint16_t *paletteram, uint8_t blendlevel); + inline void draw_sprite(bool read_from_csspace, int extended_sprites_mode, uint32_t palbank, bool highres, const rectangle &cliprect, uint32_t scanline, int priority, uint32_t spritegfxdata_addr, uint32_t base_addr, address_space &spc, uint16_t *paletteram, uint16_t *spriteram); + virtual void draw_linemap(const rectangle &cliprect, uint32_t scanline, int priority, uint32_t tilegfxdata_addr, uint16_t *scrollregs, uint16_t *tilemapregs, address_space &spc, uint16_t *paletteram); + inline uint8_t mix_channel(uint8_t a, uint8_t b, uint8_t alpha); + void update_vcmp_table(); + void update_palette_lookup(void); + + uint8_t m_rgb5_to_rgb8[32]; + uint32_t m_rgb555_to_rgb888[0x8000]; + uint32_t m_rgb555_to_rgb888_current[0x8000]; + + // for vcmp + uint16_t m_video_regs_1c; + uint16_t m_video_regs_1d; + uint16_t m_video_regs_1e; + + uint16_t m_video_regs_2a; + + uint16_t m_video_regs_30; + uint16_t m_video_regs_3c; + + uint16_t m_video_regs_42; + + uint16_t m_video_regs_7f; // new on GPL renderer + + uint32_t m_ycmp_table[480]; + + devcb_read16 m_space_read_cb; + address_space *m_cpuspace; + + bool m_brightness_or_saturation_dirty; + uint16_t m_linebuf[640]; + + // config + address_space *m_cs_space; + uint32_t m_csbase; +}; + +DECLARE_DEVICE_TYPE(GPL_RENDERER, gpl_renderer_device) + + +#endif // MAME_MACHINE_GPL_RENDERER_H diff --git a/src/devices/machine/spg2xx_video.cpp b/src/devices/machine/spg2xx_video.cpp index 0b522ee7b3644..7ae2c2d6b37a1 100644 --- a/src/devices/machine/spg2xx_video.cpp +++ b/src/devices/machine/spg2xx_video.cpp @@ -110,11 +110,11 @@ uint32_t spg2xx_video_device::screen_update(screen_device &screen, bitmap_rgb32 for (int i = 0; i < 4; i++) { - m_renderer->draw_page(false, false, 0, cliprect, scanline, i, 0, page1_addr, page1_scroll, page1_regs, mem, m_paletteram, m_scrollram, 0); - m_renderer->draw_page(false, false, 0, cliprect, scanline, i, 0, page2_addr, page2_scroll, page2_regs, mem, m_paletteram, m_scrollram, 1); - m_renderer->draw_sprites(false, 0, 0, false, cliprect, scanline, i, sprite_addr, mem, m_paletteram, m_spriteram, m_sprlimit_read_cb()); + m_renderer->draw_page(cliprect, scanline, i, page1_addr, page1_scroll, page1_regs, mem, m_paletteram, m_scrollram, 0); + m_renderer->draw_page(cliprect, scanline, i, page2_addr, page2_scroll, page2_regs, mem, m_paletteram, m_scrollram, 1); + m_renderer->draw_sprites(cliprect, scanline, i, sprite_addr, mem, m_paletteram, m_spriteram, m_sprlimit_read_cb()); } - + m_renderer->apply_saturation_and_fade(bitmap, cliprect, scanline); } diff --git a/src/devices/machine/spg_renderer.cpp b/src/devices/machine/spg_renderer.cpp index ad4689cfca063..22ab986438181 100644 --- a/src/devices/machine/spg_renderer.cpp +++ b/src/devices/machine/spg_renderer.cpp @@ -43,8 +43,6 @@ void spg_renderer_device::device_start() save_item(NAME(m_video_regs_42)); - save_item(NAME(m_video_regs_7f)); - save_item(NAME(m_ycmp_table)); save_item(NAME(m_rgb555_to_rgb888_current)); @@ -64,8 +62,6 @@ void spg_renderer_device::device_reset() m_video_regs_42 = 0x0001; - m_video_regs_7f = 0x0000; - for (int i = 0; i < 480; i++) { m_ycmp_table[i] = 0xffffffff; @@ -81,8 +77,8 @@ inline uint8_t spg_renderer_device::mix_channel(uint8_t bottom, uint8_t top, uin return ((0x20 - alpha) * bottom + alpha * top) >> 5; } -template -void spg_renderer_device::draw_tilestrip(bool read_from_csspace, uint32_t screenwidth, uint32_t drawwidthmask, const rectangle& cliprect, uint32_t tile_h, uint32_t tile_w, uint32_t tilegfxdata_addr, uint32_t tile, uint32_t tile_scanline, int drawx, bool flip_y, uint32_t palette_offset, const uint32_t nc_bpp, const uint32_t bits_per_row, const uint32_t words_per_tile, address_space &spc, uint16_t* paletteram, uint8_t blendlevel) +template +void spg_renderer_device::draw_tilestrip(uint32_t screenwidth, uint32_t drawwidthmask, const rectangle &cliprect, uint32_t tile_h, uint32_t tile_w, uint32_t tilegfxdata_addr, uint32_t tile, uint32_t tile_scanline, int drawx, bool flip_y, uint32_t palette_offset, const uint32_t nc_bpp, const uint32_t bits_per_row, const uint32_t words_per_tile, address_space &spc, uint16_t *paletteram, uint8_t blendlevel) { const uint32_t yflipmask = flip_y ? tile_h - 1 : 0; uint32_t m = tilegfxdata_addr + words_per_tile * tile + bits_per_row * (tile_scanline ^ yflipmask); @@ -97,30 +93,10 @@ void spg_renderer_device::draw_tilestrip(bool read_from_csspace, uint32_t screen if (nbits < nc_bpp) { - if (!read_from_csspace) - { - uint16_t b = spc.read_word(m++ & 0x3fffff); - b = (b << 8) | (b >> 8); - bits |= b << (nc_bpp - nbits); - nbits += 16; - } - else - { - uint16_t b; - const int addr = m & 0x7ffffff; - if (addr < m_csbase) - { - b = m_cpuspace->read_word(addr); - } - else - { - b = m_cs_space->read_word(addr-m_csbase); - } - m++; - b = (b << 8) | (b >> 8); - bits |= b << (nc_bpp - nbits); - nbits += 16; - } + uint16_t b = spc.read_word(m++ & 0x3fffff); + b = (b << 8) | (b >> 8); + bits |= b << (nc_bpp - nbits); + nbits += 16; } nbits -= nc_bpp; @@ -151,189 +127,89 @@ void spg_renderer_device::draw_tilestrip(bool read_from_csspace, uint32_t screen } -void spg_renderer_device::draw_linemap(bool has_extended_tilemaps, const rectangle& cliprect, uint32_t scanline, int priority, uint32_t tilegfxdata_addr, uint16_t* scrollregs, uint16_t* tilemapregs, address_space &spc, uint16_t* paletteram) +void spg_renderer_device::draw_linemap(const rectangle &cliprect, uint32_t scanline, int priority, uint32_t tilegfxdata_addr, uint16_t *scrollregs, uint16_t *tilemapregs, address_space &spc, uint16_t *paletteram) { - if (has_extended_tilemaps) - { - uint32_t ctrl = tilemapregs[1]; + if ((scanline < 0) || (scanline >= 240)) + return; - if (0) - { - if (ctrl & 0x0010) - popmessage("bitmap mode %08x with rowscroll\n", tilegfxdata_addr); - else - popmessage("bitmap mode %08x\n", tilegfxdata_addr); - } + uint32_t tilemap = tilemapregs[2]; + uint32_t palette_map = tilemapregs[3]; - // note, in interlace modes it appears every other line is unused? (480 entry table, but with blank values) - // and furthermore the rowscroll and rowzoom tables only have 240 entries, not enough for every line - // the end of the rowscroll table (entries 240-255) contain something else, maybe garbage data as it's offscreen, maybe not - uint32_t tilemap = tilemapregs[2]; - uint32_t palette_map = tilemapregs[3]; + //if (scanline == 128) + // popmessage("draw draw_linemap reg0 %04x reg1 %04x bases %04x %04x\n", tilemapregs[0], tilemapregs[1], tilemap, palette_map); - uint32_t linebase = spc.read_word(tilemap + scanline); // every other word is unused, but there are only enough entries for 240 lines then, sometimes to do with interlace mode? - uint16_t palette = spc.read_word(palette_map + (scanline / 2)); + //uint32_t xscroll = scrollregs[0]; + uint32_t yscroll = scrollregs[1]; - if (scanline & 1) - palette >>= 8; - else - palette &= 0xff; + int realline = (scanline + yscroll) & 0xff; - if (!linebase) - return; - linebase = linebase | (palette << 16); + uint32_t tile = spc.read_word(tilemap + realline); + uint16_t palette = 0; - int upperpalselect = 0; - if (has_extended_tilemaps && (tilegfxdata_addr & 0x80000000)) - upperpalselect = 1; + //if (!tile) + // continue; - tilegfxdata_addr &= 0x7ffffff; + palette = spc.read_word(palette_map + realline / 2); + if (scanline & 1) + palette >>= 8; + else + palette &= 0x00ff; - // this logic works for jak_s500 and the test modes to get the correct base, doesn't seem to work for jak_car2 ingame, maybe data is copied to wrong place? - int gfxbase = (tilegfxdata_addr&0x7ffffff) + (linebase&0x7ffffff); + //const int linewidth = 320 / 2; + int sourcebase = tile | (palette << 16); - for (int i = 0; i < 160; i++) // will have to be 320 for jak_car2 ingame, jak_s500 lines are wider than screen, and zoomed - { - uint16_t pix; - const int addr = gfxbase & 0x7ffffff; - if (addr < m_csbase) - { - pix = m_cpuspace->read_word(addr); - } - else - { - pix = m_cs_space->read_word(addr-m_csbase); - } - gfxbase++; + uint32_t ctrl = tilemapregs[1]; - int xx; - uint16_t pal; + if (ctrl & 0x80) // HiColor mode (rad_digi) + { + for (int i = 0; i < 320; i++) + { + const uint16_t data = spc.read_word(sourcebase + i); - if ((scanline >= 0) && (scanline < 480)) + if (!(data & 0x8000)) { - xx = i * 2; - - pal = (pix & 0xff) | 0x100; - - if (upperpalselect) - pal |= 0x200; - - if (xx >= 0 && xx <= cliprect.max_x) - { - uint16_t rgb = paletteram[pal]; - - if (!(rgb & 0x8000)) - { - m_linebuf[xx] = rgb; - } - } - - xx = (i * 2)+1; - pal = (pix >> 8) | 0x100; - - if (upperpalselect) - pal |= 0x200; - - if (xx >= 0 && xx <= cliprect.max_x) - { - uint16_t rgb = paletteram[pal]; - - if (!(rgb & 0x8000)) - { - m_linebuf[xx] = rgb; - } - } + m_linebuf[i] = data & 0x7fff; } } } - else // code used for spg2xx cases + else { - if ((scanline < 0) || (scanline >= 240)) - return; - - uint32_t tilemap = tilemapregs[2]; - uint32_t palette_map = tilemapregs[3]; - - //if (scanline == 128) - // popmessage("draw draw_linemap reg0 %04x reg1 %04x bases %04x %04x\n", tilemapregs[0], tilemapregs[1], tilemap, palette_map); - - //uint32_t xscroll = scrollregs[0]; - uint32_t yscroll = scrollregs[1]; - - int realline = (scanline + yscroll) & 0xff; - - - uint32_t tile = spc.read_word(tilemap + realline); - uint16_t palette = 0; - - //if (!tile) - // continue; - - palette = spc.read_word(palette_map + realline / 2); - if (scanline & 1) - palette >>= 8; - else - palette &= 0x00ff; - - //const int linewidth = 320 / 2; - int sourcebase = tile | (palette << 16); + const uint32_t attr = tilemapregs[0]; + const uint8_t bpp = attr & 0x0003; + const uint32_t nc_bpp = ((bpp)+1) << 1; + uint32_t palette_offset = (attr & 0x0f00) >> 4; + palette_offset >>= nc_bpp; + palette_offset <<= nc_bpp; - uint32_t ctrl = tilemapregs[1]; + uint32_t bits = 0; + uint32_t nbits = 0; - if (ctrl & 0x80) // HiColor mode (rad_digi) + for (int i = 0; i < 320; i++) { - for (int i = 0; i < 320; i++) + bits <<= nc_bpp; + if (nbits < nc_bpp) { - const uint16_t data = spc.read_word(sourcebase + i); - - if (!(data & 0x8000)) - { - m_linebuf[i] = data & 0x7fff; - } + uint16_t b = spc.read_word(sourcebase++ & 0x3fffff); + b = (b << 8) | (b >> 8); + bits |= b << (nc_bpp - nbits); + nbits += 16; } - } - else - { - const uint32_t attr = tilemapregs[0]; - const uint8_t bpp = attr & 0x0003; - const uint32_t nc_bpp = ((bpp)+1) << 1; - uint32_t palette_offset = (attr & 0x0f00) >> 4; - palette_offset >>= nc_bpp; - palette_offset <<= nc_bpp; + nbits -= nc_bpp; - uint32_t bits = 0; - uint32_t nbits = 0; + uint32_t pal = palette_offset + (bits >> 16); + bits &= 0xffff; - for (int i = 0; i < 320; i++) - { - bits <<= nc_bpp; - if (nbits < nc_bpp) - { - uint16_t b = spc.read_word(sourcebase++ & 0x3fffff); - b = (b << 8) | (b >> 8); - bits |= b << (nc_bpp - nbits); - nbits += 16; - } - nbits -= nc_bpp; - - uint32_t pal = palette_offset + (bits >> 16); - bits &= 0xffff; - - uint16_t rgb = paletteram[pal]; + uint16_t rgb = paletteram[pal]; - if (!(rgb & 0x8000)) - { - m_linebuf[i] = rgb; - } + if (!(rgb & 0x8000)) + { + m_linebuf[i] = rgb; } } } } - - - // this builds up a line table for the vcmp effect, this is not correct when step is used void spg_renderer_device::update_vcmp_table() { @@ -373,33 +249,33 @@ void spg_renderer_device::update_vcmp_table() } } -void spg_renderer_device::draw_tilestrip(bool read_from_csspace, uint32_t screenwidth, uint32_t drawwidthmask, spg_renderer_device::blend_enable_t blend, spg_renderer_device::flipx_t flip_x, const rectangle& cliprect, uint32_t tile_h, uint32_t tile_w, uint32_t tilegfxdata_addr, uint32_t tile, uint32_t tile_scanline, int drawx, bool flip_y, uint32_t palette_offset, const uint32_t nc_bpp, const uint32_t bits_per_row, const uint32_t words_per_tile, address_space& spc, uint16_t* paletteram, uint8_t blendlevel) +void spg_renderer_device::draw_tilestrip(uint32_t screenwidth, uint32_t drawwidthmask, bool blend, bool flip_x, const rectangle &cliprect, uint32_t tile_h, uint32_t tile_w, uint32_t tilegfxdata_addr, uint32_t tile, uint32_t tile_scanline, int drawx, bool flip_y, uint32_t palette_offset, const uint32_t nc_bpp, const uint32_t bits_per_row, const uint32_t words_per_tile, address_space &spc, uint16_t *paletteram, uint8_t blendlevel) { if (blend) { if (flip_x) { - draw_tilestrip(read_from_csspace, screenwidth, drawwidthmask, cliprect, tile_h, tile_w, tilegfxdata_addr, tile, tile_scanline, drawx, flip_y, palette_offset, nc_bpp, bits_per_row, words_per_tile, spc, paletteram, blendlevel); + draw_tilestrip(screenwidth, drawwidthmask, cliprect, tile_h, tile_w, tilegfxdata_addr, tile, tile_scanline, drawx, flip_y, palette_offset, nc_bpp, bits_per_row, words_per_tile, spc, paletteram, blendlevel); } else { - draw_tilestrip(read_from_csspace, screenwidth, drawwidthmask, cliprect, tile_h, tile_w, tilegfxdata_addr, tile, tile_scanline, drawx, flip_y, palette_offset, nc_bpp, bits_per_row, words_per_tile, spc, paletteram, blendlevel); + draw_tilestrip(screenwidth, drawwidthmask, cliprect, tile_h, tile_w, tilegfxdata_addr, tile, tile_scanline, drawx, flip_y, palette_offset, nc_bpp, bits_per_row, words_per_tile, spc, paletteram, blendlevel); } } else { if (flip_x) { - draw_tilestrip(read_from_csspace, screenwidth, drawwidthmask, cliprect, tile_h, tile_w, tilegfxdata_addr, tile, tile_scanline, drawx, flip_y, palette_offset, nc_bpp, bits_per_row, words_per_tile, spc, paletteram, blendlevel); + draw_tilestrip(screenwidth, drawwidthmask, cliprect, tile_h, tile_w, tilegfxdata_addr, tile, tile_scanline, drawx, flip_y, palette_offset, nc_bpp, bits_per_row, words_per_tile, spc, paletteram, blendlevel); } else { - draw_tilestrip(read_from_csspace, screenwidth, drawwidthmask, cliprect, tile_h, tile_w, tilegfxdata_addr, tile, tile_scanline, drawx, flip_y, palette_offset, nc_bpp, bits_per_row, words_per_tile, spc, paletteram, blendlevel); + draw_tilestrip(screenwidth, drawwidthmask, cliprect, tile_h, tile_w, tilegfxdata_addr, tile, tile_scanline, drawx, flip_y, palette_offset, nc_bpp, bits_per_row, words_per_tile, spc, paletteram, blendlevel); } } } -void spg_renderer_device::draw_page(bool read_from_csspace, bool has_extended_tilemaps, uint32_t palbank, const rectangle& cliprect, uint32_t scanline, int priority, uint16_t tilegfxdata_addr_msb, uint16_t tilegfxdata_addr, uint16_t* scrollregs, uint16_t* tilemapregs, address_space& spc, uint16_t* paletteram, uint16_t* scrollram, uint32_t which) +void spg_renderer_device::draw_page(const rectangle &cliprect, uint32_t scanline, int priority, uint16_t tilegfxdata_addr, uint16_t *scrollregs, uint16_t *tilemapregs, address_space &spc, uint16_t *paletteram, uint16_t *scrollram, uint32_t which) { const uint32_t attr = tilemapregs[0]; const uint32_t ctrl = tilemapregs[1]; @@ -415,21 +291,11 @@ void spg_renderer_device::draw_page(bool read_from_csspace, bool has_extended_ti } // graphic data segments/bases - uint32_t tilegfxdata_addr_full; - - if (m_video_regs_7f & 0x0040) // FREE == 1 - { - tilegfxdata_addr_full = ((tilegfxdata_addr_msb & 0x07ff) << 16) | tilegfxdata_addr; - } - else // FREE == 0 (default / legacy) - { - tilegfxdata_addr_full = tilegfxdata_addr * 0x40; - } - + uint32_t tilegfxdata_addr_full = tilegfxdata_addr * 0x40; if (ctrl & 0x0001) // Bitmap / Linemap mode! (basically screen width tile mode) { - draw_linemap(has_extended_tilemaps, cliprect, scanline, priority, tilegfxdata_addr_full, scrollregs, tilemapregs, spc, paletteram); + draw_linemap(cliprect, scanline, priority, tilegfxdata_addr_full, scrollregs, tilemapregs, spc, paletteram); return; } @@ -446,29 +312,9 @@ void spg_renderer_device::draw_page(bool read_from_csspace, bool has_extended_ti return; } - uint32_t total_width; - uint32_t y_mask; - uint32_t screenwidth; - - - if (read_from_csspace && (attr & 0x8000)) // is this only available in high res mode, or always? - { - // just a guess based on this being set on the higher resolution tilemaps we've seen, could be 100% incorrect register - total_width = 1024; - y_mask = 0x200; - screenwidth = 640; - } - else - { - total_width = 512; - y_mask = 0x100; - screenwidth = 320; - } - - if (has_extended_tilemaps && (attr & 0x4000)) // is this only available in high res mode, or always? - { - y_mask <<= 1; // double height tilemap? - } + const uint32_t total_width = 512; + uint32_t y_mask = 0x100; + const uint32_t screenwidth = 320; const uint32_t drawwidthmask = total_width - 1; y_mask--; // turn into actual mask @@ -487,53 +333,29 @@ void spg_renderer_device::draw_page(bool read_from_csspace, bool has_extended_ti const uint8_t bpp = attr & 0x0003; const uint32_t nc_bpp = ((bpp)+1) << 1; const uint32_t bits_per_row = nc_bpp * tile_w / 16; - //const uint32_t words_per_tile = bits_per_row * tile_h; const bool row_scroll = (ctrl & 0x0010); // Max blend level (3) should result in 100% opacity, per docs // Min blend level (0) should result in 25% opacity, per docs static const uint8_t s_blend_levels[4] = { 0x08, 0x10, 0x18, 0x20 }; - uint8_t blendlevel = s_blend_levels[m_video_regs_2a & 3]; + const uint8_t blendlevel = s_blend_levels[m_video_regs_2a & 3]; - uint32_t words_per_tile; - - words_per_tile = bits_per_row * tile_h; - - // good for gormiti, smartfp, wrlshunt, paccon, jak_totm, jak_s500, jak_gtg - if (has_extended_tilemaps) - { - if (m_video_regs_7f & 0x0004) // TX_DIRECT - words_per_tile = 8; - } + const uint32_t words_per_tile = bits_per_row * tile_h; int realxscroll = xscroll; + + // Tennis in My Wireless Sports confirms the need to add the scroll value here rather than rowscroll being screen-aligned + // this is different to GPL? if (row_scroll) - { - if (!has_extended_tilemaps) - { - // Tennis in My Wireless Sports confirms the need to add the scroll value here rather than rowscroll being screen-aligned - realxscroll += (int16_t)scrollram[(logical_scanline + yscroll) & 0xff]; - } - else - { - // the logic seems to be different on GPL16250, see Galaxian in paccon and Crazy Moto in myac220, is this mode be selected or did behavior just change? - realxscroll += (int16_t)scrollram[logical_scanline & 0xff]; - } - } + realxscroll += (int16_t)scrollram[(logical_scanline + yscroll) & 0xff]; const int upperscrollbits = (realxscroll >> (tile_width + 3)); const int endpos = (screenwidth + tile_w) / tile_w; - int upperpalselect = 0; - - // smartfp - if (has_extended_tilemaps && (tilegfxdata_addr_msb & 0x8000)) - upperpalselect = 1; - for (uint32_t x0 = 0; x0 < endpos; x0++) { - spg_renderer_device::blend_enable_t blend; - spg_renderer_device::flipx_t flip_x; + bool blend; + bool flip_x; bool flip_y; uint32_t tile; uint32_t palette_offset; @@ -545,50 +367,20 @@ void spg_renderer_device::draw_page(bool read_from_csspace, bool has_extended_ti tile = (ctrl & 0x0004) ? spc.read_word(tilemap_rambase) : spc.read_word(tilemap_rambase + tile_address); if (!tile) - { - if (!has_extended_tilemaps) - { - // always skip on older SPG types? - continue; - } - else if (m_video_regs_7f & 0x0002) - { - // Galaga in paccon won't render '0' characters in the scoring table if you skip empty tiles, so maybe GPL16250 doesn't skip? - extra tile bits from extended read make no difference - - // probably not based on register m_video_regs_7f, but paccon galaga needs no skip, jak_gtg and jak_hmhsm needs to skip - //49 0100 1001 no skip (paccon galaga) - //4b 0100 1011 skip (paccon pacman) - //53 0101 0011 skip (jak_gtg, jak_hmhsm) - continue; - } - } - + continue; uint32_t tileattr = attr; uint32_t tilectrl = ctrl; - if (has_extended_tilemaps && (m_video_regs_7f & 0x0004)) // TX_DIRECT + if ((tilectrl & 2) == 0) { - uint16_t exattribute = (ctrl & 0x0004) ? spc.read_word(exattributemap_rambase) : spc.read_word(exattributemap_rambase + tile_address / 2); - if (realx0 & 1) - exattribute >>= 8; - else - exattribute &= 0x00ff; - - // when TX_DIRECT is used the attributes become extra addressing bits (smartfp) - tile |= (exattribute & 0xff) << 16; - //blendlevel = 0x1f; // hack - } - else if ((ctrl & 2) == 0) - { // -(1) bld(1) flip(2) pal(4) - - uint16_t exattribute = (ctrl & 0x0004) ? spc.read_word(exattributemap_rambase) : spc.read_word(exattributemap_rambase + tile_address / 2); + // -(1) bld(1) flip(2) pal(4) + uint16_t exattribute = (tilectrl & 0x0004) ? spc.read_word(exattributemap_rambase) : spc.read_word(exattributemap_rambase + tile_address / 2); if (realx0 & 1) exattribute >>= 8; else exattribute &= 0x00ff; - tileattr &= ~0x000c; tileattr |= (exattribute >> 2) & 0x000c; // flip @@ -599,29 +391,22 @@ void spg_renderer_device::draw_page(bool read_from_csspace, bool has_extended_ti tilectrl |= (exattribute << 2) & 0x0100; // blend } - if (!has_extended_tilemaps) - blend = (tilectrl & 0x0100) ? BlendOn : BlendOff; - else - blend = ((/*tileattr & 0x4000 ||*/ tilectrl & 0x0100)) ? BlendOn : BlendOff; // is this logic even correct or should it just be like above? where is the extra enable needed? - - flip_x = (tileattr & 0x0004) ? FlipXOn : FlipXOff; - flip_y = (tileattr & 0x0008); + blend = (tilectrl & 0x0100) ? true : false; + flip_x = (tileattr & 0x0004) ? true : false; + flip_y = (tileattr & 0x0008) ? true : false; palette_offset = (tileattr & 0x0f00) >> 4; // got tile info - if (upperpalselect) - palette_offset |= 0x200; - palette_offset >>= nc_bpp; palette_offset <<= nc_bpp; const int drawx = (x0 * tile_w) - (realxscroll & (tile_w - 1)); - draw_tilestrip(read_from_csspace, screenwidth, drawwidthmask, blend, flip_x, cliprect, tile_h, tile_w, tilegfxdata_addr_full, tile, tile_scanline, drawx, flip_y, palette_offset, nc_bpp, bits_per_row, words_per_tile, spc, paletteram, blendlevel); + draw_tilestrip(screenwidth, drawwidthmask, blend, flip_x, cliprect, tile_h, tile_w, tilegfxdata_addr_full, tile, tile_scanline, drawx, flip_y, palette_offset, nc_bpp, bits_per_row, words_per_tile, spc, paletteram, blendlevel); } } -void spg_renderer_device::draw_sprite(bool read_from_csspace, int extended_sprites_mode, uint32_t palbank, bool highres, const rectangle& cliprect, uint32_t scanline, int priority, uint32_t spritegfxdata_addr, uint32_t base_addr, address_space &spc, uint16_t* paletteram, uint16_t* spriteram) +void spg_renderer_device::draw_sprite(const rectangle &cliprect, uint32_t scanline, int priority, uint32_t spritegfxdata_addr, uint32_t base_addr, address_space &spc, uint16_t *paletteram, uint16_t *spriteram) { uint32_t tilegfxdata_addr = spritegfxdata_addr; uint32_t tile = spriteram[base_addr + 0]; @@ -639,29 +424,18 @@ void spg_renderer_device::draw_sprite(bool read_from_csspace, int extended_sprit return; } - - uint32_t screenwidth = 320; -// uint32_t screenheight = 240; - uint32_t screenheight = 256; - uint32_t xmask = 0x1ff; - uint32_t ymask = 0x1ff; - - if (highres) - { - screenwidth = 640; -// screenheight = 480; - screenheight = 512; - xmask = 0x3ff; - ymask = 0x3ff; - } + const uint32_t screenwidth = 320; + const uint32_t screenheight = 256; + const uint32_t xmask = 0x1ff; + const uint32_t ymask = 0x1ff; const uint32_t tile_h = 8 << ((attr & 0x00c0) >> 6); const uint32_t tile_w = 8 << ((attr & 0x0030) >> 4); + // TODO: not all SPG2xx models support this, check which ones do if (!(m_video_regs_42 & 0x0002)) { x = ((screenwidth/2) + x) - tile_w / 2; -// y = ((screenheight/2) - y) - (tile_h / 2) + 8; y = ((screenheight/2) - y) - (tile_h / 2); } @@ -672,9 +446,9 @@ void spg_renderer_device::draw_sprite(bool read_from_csspace, int extended_sprit int lastline = y + (tile_h - 1); lastline &= ymask; - const spg_renderer_device::blend_enable_t blend = (attr & 0x4000) ? BlendOn : BlendOff; - spg_renderer_device::flipx_t flip_x = (attr & 0x0004) ? FlipXOn : FlipXOff; - bool flip_y = (attr & 0x0008); + const bool blend = (attr & 0x4000) ? true : false; + bool flip_x = (attr & 0x0004) ? true : false; + bool flip_y = (attr & 0x0008) ? true : false; const uint8_t bpp = attr & 0x0003; const uint32_t nc_bpp = ((bpp)+1) << 1; const uint32_t bits_per_row = nc_bpp * tile_w / 16; @@ -685,78 +459,9 @@ void spg_renderer_device::draw_sprite(bool read_from_csspace, int extended_sprit uint8_t blendlevel = s_blend_levels[m_video_regs_2a & 3]; uint32_t words_per_tile = bits_per_row * tile_h; -; - - if (extended_sprites_mode) - { - // 7400 format on GPL162xx is - // - // 7400 - NNNN NNNN NNNN NNNN (N = sprite tile number/address) - // 7401 - AAAA AAXX XXXX XXXX (A = Angle or Y1[5:0], X = Xpos/X0[9:0]) - // 7402 - ZZZZ ZZYY YYYY YYYY (Z = Zoom, or Y2[5:0], Y = Ypos/Y0[9:0]) - // 7403 - pbDD PPPP VVHH FFCC (p = Palette Bank, b = blend, D = depth, P = palette, V = vertical size, H = horizontal size, F = flip, C = colour) - - if (m_video_regs_7f & 0x0200) // 'virtual 3D' sprite mode (GPAC800 / GPL16250 only) has 4 extra entries per sprite - { - // 2nd sprite bank is... - // - // 7400 - MMBB BBBB NNNN NNNN - M = Mosaic, B = blend level, N = sprite/tile number/adddress) Attribute 1 of sprite 0 - // 7401 - YYYY YYXX XXXX XXXX - Y = Y3[5:0] X = X1[9:0] X1 of sprite 0 - // 7402 - YYyy yyXX XXXX XXXX - Y = Y3[7:6] y = Y1[9:6] X = X2[9:0] X2 of sprite 0 - // 7403 - YYyy yyXX XXXX XXXX - Y = Y3[9:8] y = Y2[9:6] X = X3[9:0] X3 of sprite 0 - // 7404 - Attribute 1 of sprite 1 - // .... - // - // Normally Zoom/Rotate functions are disabled in this mode, as the attributes are use for co-ordinate data - // but setting Flip to 0x3 causes them to be used (ignoring flip) instead of the extra co-ordinates - flip_x = FlipXOff; - flip_y = 0; - - tile |= (spriteram[(base_addr)+0x400] & 0x00ff) << 16; - blendlevel = ((spriteram[(base_addr)+0x400] & 0x3f00) >> 8); - } - else // regular extended mode, just 1 extra entry per sprite - { - // 2nd sprite bank is... - // 7400 - MMBB BBBB NNNN NNNN - M = Mosaic, B = blend level, N = sprite/tile number/adddress) Attribute 1 of sprite 0 - // .... - - // before or after the 0 tile check? - tile |= (spriteram[(base_addr / 4) + 0x400] & 0x00ff) << 16; - blendlevel = ((spriteram[(base_addr / 4) + 0x400] & 0x3f00) >> 8); - } - - blendlevel >>= 1; // hack, drawing code expects 5 bits, not 6 - - // good for gormiti, smartfp, wrlshunt, paccon, jak_totm, jak_s500, jak_gtg - if (m_video_regs_42 & 0x0010) // direct addressing mode - { - // paccon and smartfp use this mode - words_per_tile = 8; - } - else - { - // extended address bits only used in direct mode, jak_prr and other GPAC500 games rely on this - tile &= 0xffff; - } - } uint32_t palette_offset = (attr & 0x0f00) >> 4; - if (extended_sprites_mode) - { - // TODO: tkmag220 / myac220 don't set this bit and expect all sprite palettes to be from the same bank as background palettes - // beijuehh (extended_sprites_mode == 2) appears to disagree with that logic, it has this set, but expects palettes and sprites - // from the first bank but also needs the attr & 0x8000 check below for the 'pause' graphics so isn't ignoring the 'extended' - // capabilities entirely. - if ((palbank & 1) && (extended_sprites_mode != 2)) - palette_offset |= 0x100; - - // many other gpl16250 sets have this bit set when they want the upper 256 colours on a per-sprite basis, seems like an extended feature - if (attr & 0x8000) - palette_offset |= 0x200; - } - // the Circuit Racing game in PDC100 needs this or some graphics have bad colours at the edges when turning as it leaves stray lower bits set palette_offset >>= nc_bpp; palette_offset <<= nc_bpp; @@ -767,7 +472,7 @@ void spg_renderer_device::draw_sprite(bool read_from_csspace, int extended_sprit if ((scanx >= 0) && (scanline <= lastline)) { - draw_tilestrip(read_from_csspace, screenwidth, xmask, blend, flip_x, cliprect, tile_h, tile_w, tilegfxdata_addr, tile, scanx, x, flip_y, palette_offset, nc_bpp, bits_per_row, words_per_tile, spc, paletteram, blendlevel); + draw_tilestrip(screenwidth, xmask, blend, flip_x, cliprect, tile_h, tile_w, tilegfxdata_addr, tile, scanx, x, flip_y, palette_offset, nc_bpp, bits_per_row, words_per_tile, spc, paletteram, blendlevel); } } else @@ -779,7 +484,7 @@ void spg_renderer_device::draw_sprite(bool read_from_csspace, int extended_sprit if ((scanx >= 0) && (scanline <= templastline)) { - draw_tilestrip(read_from_csspace, screenwidth, xmask, blend, flip_x, cliprect, tile_h, tile_w, tilegfxdata_addr, tile, scanx, x, flip_y, palette_offset, nc_bpp, bits_per_row, words_per_tile, spc, paletteram, blendlevel); + draw_tilestrip(screenwidth, xmask, blend, flip_x, cliprect, tile_h, tile_w, tilegfxdata_addr, tile, scanx, x, flip_y, palette_offset, nc_bpp, bits_per_row, words_per_tile, spc, paletteram, blendlevel); } // clipped against the bottom tempfirstline = firstline; @@ -788,33 +493,23 @@ void spg_renderer_device::draw_sprite(bool read_from_csspace, int extended_sprit if ((scanx >= 0) && (scanline <= templastline)) { - draw_tilestrip(read_from_csspace, screenwidth, xmask, blend, flip_x, cliprect, tile_h, tile_w, tilegfxdata_addr, tile, scanx, x, flip_y, palette_offset, nc_bpp, bits_per_row, words_per_tile, spc, paletteram, blendlevel); + draw_tilestrip(screenwidth, xmask, blend, flip_x, cliprect, tile_h, tile_w, tilegfxdata_addr, tile, scanx, x, flip_y, palette_offset, nc_bpp, bits_per_row, words_per_tile, spc, paletteram, blendlevel); } } } -void spg_renderer_device::draw_sprites(bool read_from_csspace, int extended_sprites_mode, uint32_t palbank, bool highres, const rectangle &cliprect, uint32_t scanline, int priority, uint32_t spritegfxdata_addr, address_space &spc, uint16_t* paletteram, uint16_t* spriteram, int sprlimit) +void spg_renderer_device::draw_sprites(const rectangle &cliprect, uint32_t scanline, int priority, uint32_t spritegfxdata_addr, address_space &spc, uint16_t *paletteram, uint16_t *spriteram, int sprlimit) { if (!(m_video_regs_42 & 0x0001)) - { return; - } - - // paccon suggests this, does older hardware have similar (if so, starting at what point?) or only GPL16250? - if (sprlimit == -1) - { - sprlimit = (m_video_regs_42 & 0xff00) >> 8; - if (sprlimit == 0) - sprlimit = 0x100; - } for (uint32_t n = 0; n < sprlimit; n++) { - draw_sprite(read_from_csspace, extended_sprites_mode, palbank, highres, cliprect, scanline, priority, spritegfxdata_addr, 4 * n, spc, paletteram, spriteram); + draw_sprite(cliprect, scanline, priority, spritegfxdata_addr, 4 * n, spc, paletteram, spriteram); } } -void spg_renderer_device::new_line(const rectangle& cliprect) +void spg_renderer_device::new_line(const rectangle &cliprect) { update_palette_lookup(); @@ -879,9 +574,9 @@ void spg_renderer_device::update_palette_lookup() m_brightness_or_saturation_dirty = false; } -void spg_renderer_device::apply_saturation_and_fade(bitmap_rgb32& bitmap, const rectangle& cliprect, int scanline) +void spg_renderer_device::apply_saturation_and_fade(bitmap_rgb32 &bitmap, const rectangle &cliprect, int scanline) { - uint32_t* src = &bitmap.pix(scanline, cliprect.min_x); + uint32_t *src = &bitmap.pix(scanline, cliprect.min_x); for (int x = cliprect.min_x; x <= cliprect.max_x; x++) { diff --git a/src/devices/machine/spg_renderer.h b/src/devices/machine/spg_renderer.h index 9676078c1f89a..503f63f6bc4c2 100644 --- a/src/devices/machine/spg_renderer.h +++ b/src/devices/machine/spg_renderer.h @@ -11,14 +11,13 @@ class spg_renderer_device : public device_t { public: - spg_renderer_device(const machine_config &mconfig, device_type type, const char *tag, device_t *owner, uint32_t clock); spg_renderer_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock); - void draw_sprites(bool read_from_csspace, int extended_sprites_mode, uint32_t palbank, bool highres, const rectangle& cliprect, uint32_t scanline, int priority, uint32_t spritegfxdata_addr, address_space& spc, uint16_t* paletteram, uint16_t* spriteram, int sprlimit); - void draw_page(bool read_from_csspace, bool has_extended_tilemaps, uint32_t palbank, const rectangle& cliprect, uint32_t scanline, int priority, uint16_t tilegfxdata_addr_msb, uint16_t tilegfxdata_addr, uint16_t* scrollregs, uint16_t* tilemapregs, address_space& spc, uint16_t* paletteram, uint16_t* scrollram, uint32_t which); - void new_line(const rectangle& cliprect); + void draw_sprites(const rectangle &cliprect, uint32_t scanline, int priority, uint32_t spritegfxdata_addr, address_space &spc, uint16_t *paletteram, uint16_t *spriteram, int sprlimit); + void draw_page(const rectangle &cliprect, uint32_t scanline, int priority, uint16_t tilegfxdata_addr, uint16_t *scrollregs, uint16_t *tilemapregs, address_space &spc, uint16_t *paletteram, uint16_t *scrollram, uint32_t which); + void new_line(const rectangle &cliprect); - void apply_saturation_and_fade(bitmap_rgb32& bitmap, const rectangle& cliprect, int scanline); + void apply_saturation_and_fade(bitmap_rgb32 &bitmap, const rectangle &cliprect, int scanline); void set_video_reg_1c(uint16_t val) { m_video_regs_1c = val; update_vcmp_table(); } void set_video_reg_1d(uint16_t val) { m_video_regs_1d = val; update_vcmp_table(); } @@ -38,7 +37,6 @@ class spg_renderer_device : public device_t m_video_regs_3c = val; } - void set_video_reg_42(uint16_t val) { m_video_regs_42 = val; } uint16_t get_video_reg_1c(void) { return m_video_regs_1c; } uint16_t get_video_reg_1d(void) { return m_video_regs_1d; } @@ -46,73 +44,53 @@ class spg_renderer_device : public device_t uint16_t get_video_reg_2a(void) { return m_video_regs_2a; } uint16_t get_video_reg_30(void) { return m_video_regs_30; } uint16_t get_video_reg_3c(void) { return m_video_regs_3c; } - uint16_t get_video_reg_42(void) { return m_video_regs_42; } - // used by some hack logic for the gpl16250 rendering for now - void set_video_reg_7f(uint16_t val) { m_video_regs_7f = val; } - uint16_t get_video_reg_7f(void) { return m_video_regs_7f; } + void set_video_reg_42(uint16_t val) { m_video_regs_42 = val; } + uint16_t get_video_reg_42(void) { return m_video_regs_42; } auto space_read_callback() { return m_space_read_cb.bind(); } - void set_video_spaces(address_space* cpuspace, address_space* cs_space, uint32_t csbase) { m_cpuspace = cpuspace; m_cs_space = cs_space; m_csbase = csbase; } + void set_video_spaces(address_space *cpuspace) { m_cpuspace = cpuspace; } protected: + spg_renderer_device(const machine_config &mconfig, device_type type, const char *tag, device_t *owner, uint32_t clock); virtual void device_start() override ATTR_COLD; virtual void device_reset() override ATTR_COLD; - enum blend_enable_t : bool - { - BlendOff = false, - BlendOn = true - }; - - enum flipx_t : bool - { - FlipXOff = false, - FlipXOn = true - }; - - template - inline void draw_tilestrip(bool read_from_csspace, uint32_t screenwidth, uint32_t drawwidthmask, const rectangle& cliprect, uint32_t tile_h, uint32_t tile_w, uint32_t tilegfxdata_addr, uint32_t tile, uint32_t tile_scanline, int drawx, bool flip_y, uint32_t palette_offset, const uint32_t nc_bpp, const uint32_t bits_per_row, const uint32_t words_per_tile, address_space &spc, uint16_t* palette, uint8_t blendlevel); - - inline void draw_tilestrip(bool read_from_csspace, uint32_t screenwidth, uint32_t drawwidthmask, spg_renderer_device::blend_enable_t blend, spg_renderer_device::flipx_t flip_x, const rectangle& cliprect, uint32_t tile_h, uint32_t tile_w, uint32_t tilegfxdata_addr, uint32_t tile, uint32_t tile_scanline, int drawx, bool flip_y, uint32_t palette_offset, const uint32_t nc_bpp, const uint32_t bits_per_row, const uint32_t words_per_tile, address_space& spc, uint16_t* paletteram, uint8_t blendlevel); - - inline void draw_sprite(bool read_from_csspace, int extended_sprites_mode, uint32_t palbank, bool highres, const rectangle& cliprect, uint32_t scanline, int priority, uint32_t spritegfxdata_addr, uint32_t base_addr, address_space& spc, uint16_t* paletteram, uint16_t* spriteram); - - inline void draw_linemap(bool has_extended_tilemaps, const rectangle& cliprect, uint32_t scanline, int priority, uint32_t tilegfxdata_addr, uint16_t* scrollregs, uint16_t* tilemapregs, address_space& spc, uint16_t* paletteram); +private: + template + inline void draw_tilestrip(uint32_t screenwidth, uint32_t drawwidthmask, const rectangle &cliprect, uint32_t tile_h, uint32_t tile_w, uint32_t tilegfxdata_addr, uint32_t tile, uint32_t tile_scanline, int drawx, bool flip_y, uint32_t palette_offset, const uint32_t nc_bpp, const uint32_t bits_per_row, const uint32_t words_per_tile, address_space &spc, uint16_t *palette, uint8_t blendlevel); + inline void draw_tilestrip(uint32_t screenwidth, uint32_t drawwidthmask, bool blend, bool flip_x, const rectangle &cliprect, uint32_t tile_h, uint32_t tile_w, uint32_t tilegfxdata_addr, uint32_t tile, uint32_t tile_scanline, int drawx, bool flip_y, uint32_t palette_offset, const uint32_t nc_bpp, const uint32_t bits_per_row, const uint32_t words_per_tile, address_space &spc, uint16_t *paletteram, uint8_t blendlevel); + inline void draw_sprite(const rectangle &cliprect, uint32_t scanline, int priority, uint32_t spritegfxdata_addr, uint32_t base_addr, address_space &spc, uint16_t *paletteram, uint16_t *spriteram); + void draw_linemap(const rectangle &cliprect, uint32_t scanline, int priority, uint32_t tilegfxdata_addr, uint16_t *scrollregs, uint16_t *tilemapregs, address_space &spc, uint16_t *paletteram); inline uint8_t mix_channel(uint8_t a, uint8_t b, uint8_t alpha); + void update_vcmp_table(); + void update_palette_lookup(void); uint8_t m_rgb5_to_rgb8[32]; uint32_t m_rgb555_to_rgb888[0x8000]; uint32_t m_rgb555_to_rgb888_current[0x8000]; -private: - - void update_vcmp_table(); - + // for vcmp uint16_t m_video_regs_1c; uint16_t m_video_regs_1d; uint16_t m_video_regs_1e; uint16_t m_video_regs_2a; - uint16_t m_video_regs_42; uint16_t m_video_regs_30; uint16_t m_video_regs_3c; - uint16_t m_video_regs_7f; + uint16_t m_video_regs_42; uint32_t m_ycmp_table[480]; devcb_read16 m_space_read_cb; + address_space *m_cpuspace; - address_space* m_cpuspace; - address_space* m_cs_space; - uint32_t m_csbase; bool m_brightness_or_saturation_dirty; - void update_palette_lookup(void); - uint16_t m_linebuf[640]; + uint16_t m_linebuf[320]; }; DECLARE_DEVICE_TYPE(SPG_RENDERER, spg_renderer_device) diff --git a/src/mame/mame.lst b/src/mame/mame.lst index 3ba68a2bce3b5..347cd74e008ad 100644 --- a/src/mame/mame.lst +++ b/src/mame/mame.lst @@ -35781,6 +35781,7 @@ dgun2573a dgunl3201 dgunl3202 fcpocket +fingerd k10_2l k10_5l lxpcli @@ -35874,6 +35875,7 @@ rtvgc300 rtvgc300cr rtvgc300fz rtvgc300pj +s10_520 s10fake sealvt supr200 @@ -35894,6 +35896,8 @@ bittboy bl339 fapocket g5_500 +g6_666 +g7_666 g9_666 gbox2019 gprnrs1 diff --git a/src/mame/nintendo/nes_vt32.cpp b/src/mame/nintendo/nes_vt32.cpp index 33db8d7873077..e1e436faec2f5 100644 --- a/src/mame/nintendo/nes_vt32.cpp +++ b/src/mame/nintendo/nes_vt32.cpp @@ -476,6 +476,10 @@ ROM_START( tvkunio1 ) ROM_LOAD( "mx29lv160dt.u3", 0x00000, 0x200000, CRC(4f502bff) SHA1(5c91c46c8b3b837cf98a5519d71117164c23a721) ) ROM_END +ROM_START( fingerd ) + ROM_REGION( 0x2000000, "mainrom", 0 ) + ROM_LOAD( "s29gl256n11tai02.u2", 0x00000, 0x2000000, CRC(58829d3c) SHA1(fab3b9914ec61f289509344b2d3f8a8b2f5bb5ba) ) +ROM_END } // anonymous namespace @@ -536,7 +540,11 @@ CONS( 2020, lxpcpp, 0, 0, nes_vt32_32mb, nes_vt32, nes_vt32_unk_state, empt CONS( 201?, k10_5l, 0, 0, nes_vt32_16mb, nes_vt32, nes_vt32_unk_state, empty_init, "", "Games Power 500-in-1 Ultra Thin Handheld Game (K10) (5 languages)", MACHINE_NOT_WORKING ) CONS( 201?, k10_2l, 0, 0, nes_vt32_16mb, nes_vt32, nes_vt32_unk_state, empty_init, "", "Games Power 500-in-1 Ultra Thin Handheld Game (K10) (2 languages)", MACHINE_NOT_WORKING ) +CONS( 2022, tvkunio1, 0, 0, nes_vt32_2mb, nes_vt32, nes_vt32_unk_state, empty_init, "Arc System Works", "Kunio-kun TV! Bikkuri Nekketsu Shin Kiroku! Harukanaru Kin Medal (Japan)", MACHINE_NOT_WORKING | MACHINE_IMPERFECT_GRAPHICS ) // yellow unit + +// writes 07 to the encryption register, currently unsupported CONS( 202?, micac250, 0, 0, nes_vt32_16mb, nes_vt32, nes_vt32_unk_state, empty_init, "", "Micro Arcade 250-in-1", MACHINE_NOT_WORKING | MACHINE_IMPERFECT_GRAPHICS ) -CONS( 2022, tvkunio1, 0, 0, nes_vt32_2mb, nes_vt32, nes_vt32_unk_state, empty_init, "Arc System Works", "Kunio-kun TV! Bikkuri Nekketsu Shin Kiroku! Harukanaru Kin Medal (Japan)", MACHINE_NOT_WORKING | MACHINE_IMPERFECT_GRAPHICS ) // yellow unit +// writes 07 to the encryption register, currently unsupported +CONS( 201?, fingerd, 0, 0, nes_vt32_32mb, nes_vt32, nes_vt32_unk_state, empty_init, "Orb Gaming", "Finger Dancing", MACHINE_NOT_WORKING ) diff --git a/src/mame/nintendo/nes_vt369_vtunknown.cpp b/src/mame/nintendo/nes_vt369_vtunknown.cpp index efe47f7ccbd34..e219e61c6f59c 100644 --- a/src/mame/nintendo/nes_vt369_vtunknown.cpp +++ b/src/mame/nintendo/nes_vt369_vtunknown.cpp @@ -1196,6 +1196,11 @@ ROM_START( h12p1000 ) ROM_LOAD( "h12pro1000.u12", 0x00000, 0x2000000, CRC(b471cb79) SHA1(2324d82a6ae00537090fb534cdf4e4ac6a74ebaf) ) ROM_END +ROM_START( s10_520 ) + ROM_REGION( 0x1000000, "mainrom", 0 ) + ROM_LOAD( "s10_white_520.bin", 0x00000, 0x1000000, CRC(552ffddb) SHA1(6a1be8bead43eceb51e674499159e850d4c115be) ) +ROM_END + void vt369_state::init_lxcmcypp() { @@ -1226,7 +1231,8 @@ void vt369_state::init_dgun2572() void vt369_state::init_s10fake() { uint8_t *romdata = memregion("mainrom")->base(); - for (offs_t i = 0; i < 0x800000; i += 2) + int size = memregion("mainrom")->bytes(); + for (offs_t i = 0; i < size; i += 2) { uint16_t w = get_u16le(&romdata[i]); put_u16le(&romdata[i], (w & 0xf9f9) | (w & 0x0600) >> 8 | (w & 0x0006) << 8); @@ -1382,6 +1388,8 @@ CONS( 2018, goretrop, 0, 0, vt369_unk_32mb, vt369, vt36x_state, empty_init, // unused routines suggest this was originally developed for nes_vt42xx.cpp hardware (cf. g9_666, g5_500 with the same bitswap) // there are other S10 units available CONS( 202?, s10fake, 0, 0, vt36x_s10swap_8mb, vt369, vt36x_state, init_s10fake, "", "S10 Handheld Game Console (520-in-1, fake entries)", MACHINE_NOT_WORKING ) +// different version, same packaging. Larger ROM, fewer duplicates etc. needs different bitswap, or different hardware +CONS( 202?, s10_520, 0, 0, vt36x_16mb, vt369, vt36x_state, empty_init, "", "S10 Handheld Game Console (520-in-1)", MACHINE_NOT_WORKING ) // banking(?) issues, some games don't boot (writes data to ALU mirror, then some other ports) CONS( 202?, h12p1000, 0, 0, vt36x, vt369, vt36x_state, empty_init, "", "H12 Pro 1000 in 1 Handheld Game Console", MACHINE_NOT_WORKING | MACHINE_IMPERFECT_GRAPHICS ) diff --git a/src/mame/nintendo/nes_vt42xx.cpp b/src/mame/nintendo/nes_vt42xx.cpp index e9b991dc22a30..4d7d5ae526772 100644 --- a/src/mame/nintendo/nes_vt42xx.cpp +++ b/src/mame/nintendo/nes_vt42xx.cpp @@ -420,14 +420,24 @@ ROM_START( rfcp168 ) ROM_LOAD( "winbond_w29gl128c.bin", 0x00000, 0x1000000, CRC(d11caf71) SHA1(64b269cee30a51549a2d0491bbeed07751771559) ) // ROM verified on 2 units ROM_END -ROM_START( g9_666 ) +ROM_START( g5_500 ) ROM_REGION( 0x1000000, "mainrom", 0 ) - ROM_LOAD( "666in1.u1", 0x00000, 0x1000000, CRC(e3a98465) SHA1(dfec3e74e36aef9bfa57ec530c37642015569dc5) ) + ROM_LOAD( "s29gl128.u1", 0x00000, 0x1000000, CRC(de779dd7) SHA1(ac6d3fa6f18ceb795532ba9e85edffc040d74347) ) ROM_END -ROM_START( g5_500 ) +ROM_START( g6_666 ) ROM_REGION( 0x1000000, "mainrom", 0 ) - ROM_LOAD( "s29gl128.u1", 0x00000, 0x1000000, CRC(de779dd7) SHA1(ac6d3fa6f18ceb795532ba9e85edffc040d74347) ) + ROM_LOAD( "g6_666.bin", 0x00000, 0x1000000, CRC(0f443cbe) SHA1(25c4d59e65b05f1255f18c802d72e4cf308ba49b) ) +ROM_END + +ROM_START( g7_666 ) + ROM_REGION( 0x1000000, "mainrom", 0 ) + ROM_LOAD( "g7_666.u1", 0x00000, 0x1000000, CRC(d2bbc3ab) SHA1(19d3326c30b048dd8483f6336656e0301b5aec8a) ) +ROM_END + +ROM_START( g9_666 ) + ROM_REGION( 0x1000000, "mainrom", 0 ) + ROM_LOAD( "666in1.u1", 0x00000, 0x1000000, CRC(e3a98465) SHA1(dfec3e74e36aef9bfa57ec530c37642015569dc5) ) ROM_END ROM_START( hhgc319 ) @@ -571,11 +581,12 @@ void nes_vt42xx_state::init_bl339() CONS( 201?, rfcp168, 0, 0, nes_vt42xx_16mb, nes_vt42xx, nes_vt42xx_state, init_rfcp168, "", "Retro FC Plus 168 in 1 Handheld", MACHINE_NOT_WORKING | MACHINE_IMPERFECT_GRAPHICS ) // "RETRO_FC_V3.5" -// many duplicates, real game count to be confirmed, graphical issues in some games -CONS( 202?, g9_666, 0, 0, nes_vt42xx_16mb, nes_vt42xx, nes_vt42xx_state, init_g9_666, "", "G9 Game Box 666 Games", MACHINE_NOT_WORKING | MACHINE_IMPERFECT_GRAPHICS ) -// same bitswap as above +// these share the same bitswap, many duplicates, real game counts to be confirmed, graphical issues in some games CONS( 201?, g5_500, 0, 0, nes_vt42xx_16mb, nes_vt42xx, nes_vt42xx_state, init_g9_666, "", "G5 500 in 1 Handheld", MACHINE_NOT_WORKING ) +CONS( 201?, g6_666, 0, 0, nes_vt42xx_16mb, nes_vt42xx, nes_vt42xx_state, init_g9_666, "", "G6 666 in 1 Handheld", MACHINE_NOT_WORKING ) +CONS( 201?, g7_666, 0, 0, nes_vt42xx_16mb, nes_vt42xx, nes_vt42xx_state, init_g9_666, "", "G7 666 in 1 Handheld", MACHINE_NOT_WORKING ) +CONS( 202?, g9_666, 0, 0, nes_vt42xx_16mb, nes_vt42xx, nes_vt42xx_state, init_g9_666, "", "G9 Game Box 666 Games", MACHINE_NOT_WORKING | MACHINE_IMPERFECT_GRAPHICS ) // highly scrambled CONS( 201?, hhgc319, 0, 0, nes_vt42xx_16mb, nes_vt42xx, nes_vt42xx_state, init_hhgc319, "", "Handheld Game Console 319-in-1", MACHINE_NOT_WORKING | MACHINE_IMPERFECT_GRAPHICS )