summaryrefslogtreecommitdiffstatshomepage
diff options
context:
space:
mode:
author cam900 <dbtlrchl@naver.com>2018-12-01 15:55:20 +0900
committer cam900 <dbtlrchl@naver.com>2018-12-01 15:55:20 +0900
commit6873ec7d1bc0747b6ea3735e72c71237a5feaec6 (patch)
tree26eaa299be189995cee566da472d933ca01c4da5
parentd026809d9c71f76078b349ce8f635cfe8b9b5e42 (diff)
psikyo4.cpp : Updates/Cleanups
Fix sound output, Namings, Some spacings, Cleanup duplicates, ACCESSING_BITs, Runtime tag lookups, Add notes
-rw-r--r--src/mame/drivers/psikyo4.cpp235
-rw-r--r--src/mame/includes/psikyo4.h48
-rw-r--r--src/mame/video/psikyo4.cpp55
3 files changed, 131 insertions, 207 deletions
diff --git a/src/mame/drivers/psikyo4.cpp b/src/mame/drivers/psikyo4.cpp
index d98a18fbb7a..0701e399a8b 100644
--- a/src/mame/drivers/psikyo4.cpp
+++ b/src/mame/drivers/psikyo4.cpp
@@ -136,39 +136,32 @@ ROMs -
#include "speaker.h"
+template<int Screen>
+uint32_t psikyo4_state::screen_update(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
+{
+ bitmap.fill(0x800, cliprect);
+ m_gfxdecode->gfx(0)->set_palette(*m_palette[Screen]);
+ draw_sprites(screen, bitmap, cliprect, Screen << 13);
+ return 0;
+}
+
static GFXLAYOUT_RAW( layout_16x16x8, 16, 16, 16*8, 16*16*8 )
static GFXDECODE_START( gfx_ps4 )
GFXDECODE_ENTRY( "gfx1", 0, layout_16x16x8, 0x000, 0x40 ) // 8bpp tiles
GFXDECODE_END
-WRITE32_MEMBER(psikyo4_state::ps4_eeprom_w)
+WRITE8_MEMBER(psikyo4_state::eeprom_w)
{
- if (ACCESSING_BITS_16_31)
- {
- m_eeprom->di_write((data & 0x00200000) ? 1 : 0);
- m_eeprom->cs_write((data & 0x00800000) ? ASSERT_LINE : CLEAR_LINE);
- m_eeprom->clk_write((data & 0x00400000) ? ASSERT_LINE : CLEAR_LINE);
-
- return;
- }
-
- logerror("Unk EEPROM write %x mask %x\n", data, mem_mask);
-}
-
-READ32_MEMBER(psikyo4_state::ps4_eeprom_r)
-{
- if (ACCESSING_BITS_16_31)
- {
- return ioport("JP4")->read();
- }
-
-// logerror("Unk EEPROM read mask %x\n", mem_mask);
+ m_eeprom->di_write((data & 0x20) ? 1 : 0);
+ m_eeprom->cs_write((data & 0x80) ? ASSERT_LINE : CLEAR_LINE);
+ m_eeprom->clk_write((data & 0x40) ? ASSERT_LINE : CLEAR_LINE);
- return 0x00;
+ if (data & ~0xe0)
+ logerror("Unk EEPROM write %x mask %x\n", data, mem_mask);
}
-INTERRUPT_GEN_MEMBER(psikyo4_state::psikyosh_interrupt)
+INTERRUPT_GEN_MEMBER(psikyo4_state::interrupt)
{
device.execute().set_input_line(4, HOLD_LINE);
}
@@ -186,139 +179,89 @@ CUSTOM_INPUT_MEMBER(psikyo4_state::mahjong_ctrl_r)/* used by hotgmck/hgkairak */
return ret;
}
-WRITE32_MEMBER(psikyo4_state::ps4_paletteram32_RRRRRRRRGGGGGGGGBBBBBBBBxxxxxxxx_dword_w)
+WRITE32_MEMBER(psikyo4_state::paletteram_w)
{
- int r, g, b;
COMBINE_DATA(&m_paletteram[offset]);
- b = ((m_paletteram[offset] & 0x0000ff00) >> 8);
- g = ((m_paletteram[offset] & 0x00ff0000) >> 16);
- r = ((m_paletteram[offset] & 0xff000000) >> 24);
+ uint8_t const b = ((m_paletteram[offset] & 0x0000ff00) >> 8);
+ uint8_t const g = ((m_paletteram[offset] & 0x00ff0000) >> 16);
+ uint8_t const r = ((m_paletteram[offset] & 0xff000000) >> 24);
- m_palette->set_pen_color(offset, rgb_t(r, g, b));
- m_palette2->set_pen_color(offset, rgb_t(r, g, b)); // For screen 2
+ m_palette[0]->set_pen_color(offset, rgb_t(r, g, b));
+ m_palette[1]->set_pen_color(offset, rgb_t(r, g, b)); // For screen 2
}
-WRITE32_MEMBER(psikyo4_state::ps4_bgpen_1_dword_w)
+template<int Screen>
+WRITE32_MEMBER(psikyo4_state::bgpen_w)
{
- int r, g, b;
- COMBINE_DATA(&m_bgpen_1[0]);
+ COMBINE_DATA(&m_bgpen[Screen][0]);
- b = ((m_bgpen_1[0] & 0x0000ff00) >>8);
- g = ((m_bgpen_1[0] & 0x00ff0000) >>16);
- r = ((m_bgpen_1[0] & 0xff000000) >>24);
+ uint8_t const b = ((m_bgpen[Screen][0] & 0x0000ff00) >> 8);
+ uint8_t const g = ((m_bgpen[Screen][0] & 0x00ff0000) >> 16);
+ uint8_t const r = ((m_bgpen[Screen][0] & 0xff000000) >> 24);
- m_palette->set_pen_color(0x800, rgb_t(r, g, b)); // Clear colour for screen 1
+ m_palette[Screen]->set_pen_color(0x800, rgb_t(r, g, b)); // Clear colour for screen
}
-WRITE32_MEMBER(psikyo4_state::ps4_bgpen_2_dword_w)
+template<int Screen>
+WRITE8_MEMBER(psikyo4_state::screen_brt_w)
{
- int r, g, b;
- COMBINE_DATA(&m_bgpen_2[0]);
-
- b = ((m_bgpen_2[0] & 0x0000ff00) >>8);
- g = ((m_bgpen_2[0] & 0x00ff0000) >>16);
- r = ((m_bgpen_2[0] & 0xff000000) >>24);
-
- m_palette2->set_pen_color(0x800, rgb_t(r, g, b)); // Clear colour for screen 2
-}
-
-WRITE32_MEMBER(psikyo4_state::ps4_screen1_brt_w)
-{
- if (ACCESSING_BITS_0_7)
- {
- /* Need separate brightness for both screens if displaying together */
- double brt1 = data & 0xff;
-
- if (brt1 > 0x7f)
- brt1 = 0x7f; /* I reckon values must be clamped to 0x7f */
-
- brt1 = (0x7f - brt1) / 127.0;
- if (m_oldbrt1 != brt1)
- {
- int i;
+ /* Need separate brightness for both screens if displaying together */
+ double brt = data & 0xff;
- for (i = 0; i < 0x800; i++)
- m_palette->set_pen_contrast(i, brt1);
+ if (brt > 0x7f)
+ brt = 0x7f; /* I reckon values must be clamped to 0x7f */
- m_oldbrt1 = brt1;
- }
- }
- else
+ brt = (0x7f - brt) / 127.0;
+ if (m_oldbrt[Screen] != brt)
{
- /* I believe this to be separate rgb brightness due to strings in hotdebut, unused in 4 dumped games */
- if((data & mem_mask) != 0)
- logerror("Unk Scr 1 rgb? brt write %08x mask %08x\n", data, mem_mask);
- }
-}
-
-WRITE32_MEMBER(psikyo4_state::ps4_screen2_brt_w)
-{
- if (ACCESSING_BITS_0_7)
- {
- /* Need separate brightness for both screens if displaying together */
- double brt2 = data & 0xff;
-
- if (brt2 > 0x7f)
- brt2 = 0x7f; /* I reckon values must be clamped to 0x7f */
-
- brt2 = (0x7f - brt2) / 127.0;
-
- if (m_oldbrt2 != brt2)
- {
- int i;
+ int i;
- for (i = 0x000; i < 0x800; i++)
- m_palette2->set_pen_contrast(i, brt2);
+ for (i = 0; i < 0x800; i++)
+ m_palette[Screen]->set_pen_contrast(i, brt);
- m_oldbrt2 = brt2;
- }
- }
- else
- {
- /* I believe this to be separate rgb brightness due to strings in hotdebut, unused in 4 dumped games */
- if((data & mem_mask) != 0)
- logerror("Unk Scr 2 rgb? brt write %08x mask %08x\n", data, mem_mask);
+ m_oldbrt[Screen] = brt;
}
+ /* I believe this to be separate rgb brightness due to strings in hotdebut, unused in 4 dumped games */
}
-WRITE32_MEMBER(psikyo4_state::ps4_vidregs_w)
+WRITE32_MEMBER(psikyo4_state::vidregs_w)
{
- COMBINE_DATA(&m_vidregs[offset]);
+ uint32_t const old = m_vidregs[offset];
+ data = COMBINE_DATA(&m_vidregs[offset]);
if (offset == 2) /* Configure bank for gfx test */
{
- if (ACCESSING_BITS_0_15) // Bank
- membank("gfxbank")->set_base(memregion("gfx1")->base() + 0x2000 * (m_vidregs[offset] & 0x1fff)); /* Bank comes from vidregs */
+ if ((old ^ data) & 0x1fff) // Bank
+ {
+ if ((data & 0x1fff) < m_gfx_max_bank)
+ m_gfxbank->set_entry(data & 0x1fff); /* Bank comes from vidregs */
+ }
}
}
-WRITE32_MEMBER(psikyo4_state::io_select_w)
+WRITE16_MEMBER(psikyo4_state::ymf_bank_w)
{
// YMF banking
- if (ACCESSING_BITS_16_31)
+ uint16_t bankdata = data;
+ uint16_t bankmask = mem_mask;
+ for (auto & elem : m_ymf_bank)
{
- uint32_t bankdata = data >> 16;
- uint32_t bankmask = mem_mask >> 16;
- for (auto & elem : m_ymf_bank)
+ if (bankmask & 0x0f)
{
- if (bankmask & 0x0f)
- {
- int banknum = bankdata & 0x0f;
- if (banknum < m_ymf_max_bank)
- elem->set_entry(banknum);
- }
- bankdata >>= 4;
- bankmask >>= 4;
+ int banknum = bankdata & 0x0f;
+ if (banknum < m_ymf_max_bank)
+ elem->set_entry(banknum);
}
+ bankdata >>= 4;
+ bankmask >>= 4;
}
+}
+WRITE8_MEMBER(psikyo4_state::io_select_w)
+{
// mahjong input multiplexing
- if (ACCESSING_BITS_8_15)
- m_io_select = data >> 8;
-
- if (ACCESSING_BITS_0_7)
- logerror("Unk ioselect write %x mask %x\n", data, mem_mask);
+ m_io_select = data;
}
void psikyo4_state::ps4_map(address_map &map)
@@ -326,20 +269,22 @@ void psikyo4_state::ps4_map(address_map &map)
map(0x00000000, 0x000fffff).rom(); // program ROM (1 meg)
map(0x02000000, 0x021fffff).rom().region("maincpu", 0x100000); // data ROM
map(0x03000000, 0x030037ff).ram().share("spriteram");
- map(0x03003fe0, 0x03003fe3).rw(FUNC(psikyo4_state::ps4_eeprom_r), FUNC(psikyo4_state::ps4_eeprom_w));
- map(0x03003fe4, 0x03003fef).ram().w(FUNC(psikyo4_state::ps4_vidregs_w)).share("vidregs"); // vid regs?
+ map(0x03003fe0, 0x03003fe3).portr("JP4");
+ map(0x03003fe1, 0x03003fe1).w(FUNC(psikyo4_state::eeprom_w));
+ map(0x03003fe4, 0x03003fef).ram().w(FUNC(psikyo4_state::vidregs_w)).share("vidregs"); // vid regs?
map(0x03003fe4, 0x03003fe7).nopr(); // also writes to this address - might be vblank?
-// AM_RANGE(0x03003fe4, 0x03003fe7) AM_WRITENOP // might be vblank?
- map(0x03003ff0, 0x03003ff3).w(FUNC(psikyo4_state::ps4_screen1_brt_w)); // screen 1 brightness
- map(0x03003ff4, 0x03003ff7).w(FUNC(psikyo4_state::ps4_bgpen_1_dword_w)).share("bgpen_1"); // screen 1 clear colour
- map(0x03003ff8, 0x03003ffb).w(FUNC(psikyo4_state::ps4_screen2_brt_w)); // screen 2 brightness
- map(0x03003ffc, 0x03003fff).w(FUNC(psikyo4_state::ps4_bgpen_2_dword_w)).share("bgpen_2"); // screen 2 clear colour
- map(0x03004000, 0x03005fff).ram().w(FUNC(psikyo4_state::ps4_paletteram32_RRRRRRRRGGGGGGGGBBBBBBBBxxxxxxxx_dword_w)).share("paletteram"); // palette
+// map(0x03003fe4, 0x03003fe7).nopw(); // might be vblank?
+ map(0x03003ff3, 0x03003ff3).w(FUNC(psikyo4_state::screen_brt_w<0>)); // screen 1 brightness
+ map(0x03003ff4, 0x03003ff7).w(FUNC(psikyo4_state::bgpen_w<0>)).share("bgpen_1"); // screen 1 clear colour
+ map(0x03003ffb, 0x03003ffb).w(FUNC(psikyo4_state::screen_brt_w<1>)); // screen 2 brightness
+ map(0x03003ffc, 0x03003fff).w(FUNC(psikyo4_state::bgpen_w<1>)).share("bgpen_2"); // screen 2 clear colour
+ map(0x03004000, 0x03005fff).ram().w(FUNC(psikyo4_state::paletteram_w)).share("paletteram"); // palette
map(0x03006000, 0x03007fff).bankr("gfxbank"); // data for rom tests (gfx), data is controlled by vidreg
map(0x05000000, 0x05000007).rw("ymf", FUNC(ymf278b_device::read), FUNC(ymf278b_device::write));
map(0x05800000, 0x05800003).portr("P1_P2");
map(0x05800004, 0x05800007).portr("P3_P4");
- map(0x05800008, 0x0580000b).w(FUNC(psikyo4_state::io_select_w)); // Used by Mahjong games to choose input (also maps normal loderndf inputs to offsets)
+ map(0x05800008, 0x05800009).w(FUNC(psikyo4_state::ymf_bank_w));
+ map(0x0580000a, 0x0580000a).w(FUNC(psikyo4_state::io_select_w)); // Used by Mahjong games to choose input (also maps normal loderndf inputs to offsets)
map(0x06000000, 0x060fffff).ram().share("ram"); // main RAM (1 meg)
}
@@ -626,6 +571,9 @@ INPUT_PORTS_END
void psikyo4_state::machine_start()
{
+ m_gfx_max_bank = memregion("gfx1")->bytes() / 0x2000;
+ m_gfxbank->configure_entries(0, m_gfx_max_bank, memregion("gfx1")->base(), 0x2000);
+
// configure YMF ROM banks
memory_region *YMFROM = memregion("ymf");
m_ymf_max_bank = YMFROM->bytes() / 0x100000;
@@ -641,22 +589,21 @@ void psikyo4_state::machine_start()
m_maincpu->sh2drc_add_fastram(0x06000000, 0x060fffff, 0, memshare("ram")->ptr());
save_item(NAME(m_io_select));
- save_item(NAME(m_oldbrt1));
- save_item(NAME(m_oldbrt2));
+ save_item(NAME(m_oldbrt));
}
void psikyo4_state::machine_reset()
{
- m_oldbrt1 = -1;
- m_oldbrt2 = -1;
+ m_oldbrt[0] = -1;
+ m_oldbrt[1] = -1;
}
MACHINE_CONFIG_START(psikyo4_state::ps4big)
/* basic machine hardware */
- MCFG_DEVICE_ADD("maincpu", SH2, MASTER_CLOCK/2)
+ MCFG_DEVICE_ADD("maincpu", SH2, 57272700/2)
MCFG_DEVICE_PROGRAM_MAP(ps4_map)
- MCFG_DEVICE_VBLANK_INT_DRIVER("lscreen", psikyo4_state, psikyosh_interrupt)
+ MCFG_DEVICE_VBLANK_INT_DRIVER("lscreen", psikyo4_state, interrupt)
EEPROM_93C56_8BIT(config, "eeprom").default_value(0);
@@ -667,13 +614,12 @@ MACHINE_CONFIG_START(psikyo4_state::ps4big)
config.set_default_layout(layout_dualhsxs);
-
MCFG_SCREEN_ADD("lscreen", RASTER)
MCFG_SCREEN_REFRESH_RATE(60)
MCFG_SCREEN_VBLANK_TIME(ATTOSECONDS_IN_USEC(0))
MCFG_SCREEN_SIZE(40*8, 32*8)
MCFG_SCREEN_VISIBLE_AREA(0*8, 40*8-1, 0*8, 28*8-1)
- MCFG_SCREEN_UPDATE_DRIVER(psikyo4_state, screen_update_psikyo4_left)
+ MCFG_SCREEN_UPDATE_DRIVER(psikyo4_state, screen_update<0>)
MCFG_SCREEN_PALETTE("lpalette")
MCFG_SCREEN_ADD("rscreen", RASTER)
@@ -681,19 +627,22 @@ MACHINE_CONFIG_START(psikyo4_state::ps4big)
MCFG_SCREEN_VBLANK_TIME(ATTOSECONDS_IN_USEC(0))
MCFG_SCREEN_SIZE(40*8, 32*8)
MCFG_SCREEN_VISIBLE_AREA(0*8, 40*8-1, 0*8, 28*8-1)
- MCFG_SCREEN_UPDATE_DRIVER(psikyo4_state, screen_update_psikyo4_right)
+ MCFG_SCREEN_UPDATE_DRIVER(psikyo4_state, screen_update<1>)
MCFG_SCREEN_PALETTE("rpalette")
-
/* sound hardware */
SPEAKER(config, "lspeaker").front_left();
SPEAKER(config, "rspeaker").front_right();
- MCFG_DEVICE_ADD("ymf", YMF278B, MASTER_CLOCK/2)
+ MCFG_DEVICE_ADD("ymf", YMF278B, 57272700/2)
MCFG_DEVICE_ADDRESS_MAP(0, ps4_ymf_map)
MCFG_YMF278B_IRQ_HANDLER(INPUTLINE("maincpu", 12))
- MCFG_SOUND_ROUTE(ALL_OUTPUTS, "lspeaker", 1.0)
- MCFG_SOUND_ROUTE(ALL_OUTPUTS, "rspeaker", 1.0)
+ MCFG_SOUND_ROUTE(0, "rspeaker", 1.0) // Output for each screen
+ MCFG_SOUND_ROUTE(1, "lspeaker", 1.0)
+ MCFG_SOUND_ROUTE(2, "rspeaker", 1.0)
+ MCFG_SOUND_ROUTE(3, "lspeaker", 1.0)
+ MCFG_SOUND_ROUTE(4, "rspeaker", 1.0)
+ MCFG_SOUND_ROUTE(5, "lspeaker", 1.0)
MACHINE_CONFIG_END
MACHINE_CONFIG_START(psikyo4_state::ps4small)
diff --git a/src/mame/includes/psikyo4.h b/src/mame/includes/psikyo4.h
index 555c180513d..67954dc2ecf 100644
--- a/src/mame/includes/psikyo4.h
+++ b/src/mame/includes/psikyo4.h
@@ -12,24 +12,21 @@
#include "emupal.h"
#include "screen.h"
-#define MASTER_CLOCK 57272700 // main oscillator frequency
-
class psikyo4_state : public driver_device
{
public:
- psikyo4_state(const machine_config &mconfig, device_type type, const char *tag)
- : driver_device(mconfig, type, tag),
+ psikyo4_state(const machine_config &mconfig, device_type type, const char *tag) :
+ driver_device(mconfig, type, tag),
m_spriteram(*this, "spriteram"),
m_vidregs(*this, "vidregs"),
- m_bgpen_1(*this, "bgpen_1"),
- m_bgpen_2(*this, "bgpen_2"),
+ m_bgpen(*this, "bgpen_%u", 1U),
m_paletteram(*this, "paletteram"),
+ m_gfxbank(*this, "gfxbank"),
m_ymf_bank(*this, "ymfbank%u", 0),
m_maincpu(*this, "maincpu"),
m_eeprom(*this, "eeprom"),
m_gfxdecode(*this, "gfxdecode"),
- m_palette(*this, "lpalette"),
- m_palette2(*this, "rpalette"),
+ m_palette(*this, {"lpalette", "rpalette"}),
m_lscreen(*this, "lscreen"),
m_rscreen(*this, "rscreen"),
m_keys(*this, "KEY.%u", 0)
@@ -44,44 +41,41 @@ private:
/* memory pointers */
required_shared_ptr<uint32_t> m_spriteram;
required_shared_ptr<uint32_t> m_vidregs;
- required_shared_ptr<uint32_t> m_bgpen_1;
- required_shared_ptr<uint32_t> m_bgpen_2;
+ required_shared_ptr_array<uint32_t, 2> m_bgpen;
required_shared_ptr<uint32_t> m_paletteram;
+ required_memory_bank m_gfxbank;
required_memory_bank_array<4> m_ymf_bank;
+
+ uint16_t m_gfx_max_bank;
uint8_t m_ymf_max_bank;
uint8_t m_io_select;
/* video-related */
- double m_oldbrt1;
- double m_oldbrt2;
+ double m_oldbrt[2];
/* devices */
required_device<sh2_device> m_maincpu;
required_device<eeprom_serial_93cxx_device> m_eeprom;
required_device<gfxdecode_device> m_gfxdecode;
- required_device<palette_device> m_palette;
- required_device<palette_device> m_palette2;
+ required_device_array<palette_device, 2> m_palette;
required_device<screen_device> m_lscreen;
required_device<screen_device> m_rscreen;
optional_ioport_array<8> m_keys;
- DECLARE_WRITE32_MEMBER(ps4_paletteram32_RRRRRRRRGGGGGGGGBBBBBBBBxxxxxxxx_dword_w);
- DECLARE_WRITE32_MEMBER(ps4_bgpen_1_dword_w);
- DECLARE_WRITE32_MEMBER(ps4_bgpen_2_dword_w);
- DECLARE_WRITE32_MEMBER(ps4_screen1_brt_w);
- DECLARE_WRITE32_MEMBER(ps4_screen2_brt_w);
- DECLARE_WRITE32_MEMBER(ps4_vidregs_w);
- DECLARE_WRITE32_MEMBER(io_select_w);
- DECLARE_WRITE32_MEMBER(ps4_eeprom_w);
- DECLARE_READ32_MEMBER(ps4_eeprom_r);
+ DECLARE_WRITE32_MEMBER(paletteram_w);
+ template<int Screen> DECLARE_WRITE32_MEMBER(bgpen_w);
+ template<int Screen> DECLARE_WRITE8_MEMBER(screen_brt_w);
+ DECLARE_WRITE32_MEMBER(vidregs_w);
+ DECLARE_WRITE16_MEMBER(ymf_bank_w);
+ DECLARE_WRITE8_MEMBER(io_select_w);
+ DECLARE_WRITE8_MEMBER(eeprom_w);
virtual void machine_start() override;
virtual void machine_reset() override;
virtual void video_start() override;
- uint32_t screen_update_psikyo4_left(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
- uint32_t screen_update_psikyo4_right(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
- INTERRUPT_GEN_MEMBER(psikyosh_interrupt);
- void draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect, uint32_t scr);
+ template<int Screen> uint32_t screen_update(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
+ INTERRUPT_GEN_MEMBER(interrupt);
+ void draw_sprites(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect, uint32_t scr);
void ps4_map(address_map &map);
void ps4_ymf_map(address_map &map);
};
diff --git a/src/mame/video/psikyo4.cpp b/src/mame/video/psikyo4.cpp
index e74dcda308a..748ed209456 100644
--- a/src/mame/video/psikyo4.cpp
+++ b/src/mame/video/psikyo4.cpp
@@ -3,7 +3,7 @@
/*
Psikyo PS6807 (PS4):
-See src/drivers/psikyo4.c for more info
+See src/mame/drivers/psikyo4.cpp for more info
Each sprite has a flag denoting the screen to which it should be drawn.
@@ -33,7 +33,7 @@ HgKairak: 86010000 1f201918 a0000000 Large Screen
/* --- SPRITES --- */
-void psikyo4_state::draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect, uint32_t scr)
+void psikyo4_state::draw_sprites(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect, uint32_t scr)
{
/*- Sprite Format 0x0000 - 0x2bff -**
@@ -58,35 +58,32 @@ void psikyo4_state::draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprec
uint32_t *source = m_spriteram;
uint16_t *list = (uint16_t *)m_spriteram.target() + 0x2c00/2 + 0x04/2; /* 0x2c00/0x2c02 what are these for, pointers? one for each screen */
uint16_t listlen = (0xc00/2 - 0x04/2), listcntr = 0;
- bool flipscreen = BIT(m_vidregs[1], (scr == 0 ? 31 : 23));
- int screen_height = (scr == 0 ? m_lscreen : m_rscreen)->visible_area().max_y + 1;
+ bool const flipscreen = BIT(m_vidregs[1], (scr == 0 ? 31 : 23));
+ uint16_t const screen_height = screen.visible_area().max_y + 1;
while (listcntr < listlen)
{
- uint16_t listdat, sprnum;
-
- listdat = list[BYTE_XOR_BE(listcntr)];
- sprnum = (listdat & 0x03ff) * 2;
+ uint16_t const listdat = list[BYTE_XOR_BE(listcntr)];
+ uint16_t const sprnum = (listdat & 0x03ff) * 2;
/* start drawing */
if ((listdat & 0x8000) == 0 && (listdat & 0x2000) == scr) /* draw only selected screen */
{
- int loopnum = 0, i, j;
- uint32_t xpos, ypos, tnum, wide, high, colr, flipx, flipy;
+ int loopnum = 0;
int xstart, ystart, xend, yend, xinc, yinc;
- ypos = (source[sprnum + 0] & 0x03ff0000) >> 16;
- xpos = (source[sprnum + 0] & 0x000003ff) >> 00;
+ int16_t ypos = (source[sprnum + 0] & 0x03ff0000) >> 16;
+ int16_t xpos = (source[sprnum + 0] & 0x000003ff) >> 00;
- high = ((source[sprnum + 0] & 0xf0000000) >> (12 + 16)) + 1;
- wide = ((source[sprnum + 0] & 0x0000f000) >> 12) + 1;
+ uint8_t const high = ((source[sprnum + 0] & 0xf0000000) >> (12 + 16)) + 1;
+ uint8_t const wide = ((source[sprnum + 0] & 0x0000f000) >> 12) + 1;
- tnum = (source[sprnum + 1] & 0x0007ffff) >> 00;
+ uint32_t const tnum = (source[sprnum + 1] & 0x0007ffff) >> 00;
- colr = (source[sprnum + 1] & 0x3f000000) >> 24;
+ uint8_t const colr = (source[sprnum + 1] & 0x3f000000) >> 24;
- flipx = (source[sprnum + 1] & 0x40000000);
- flipy = (source[sprnum + 1] & 0x80000000); /* Guess */
+ bool flipx = (source[sprnum + 1] & 0x40000000);
+ bool flipy = (source[sprnum + 1] & 0x80000000); /* Guess */
if (ypos & 0x200) ypos -= 0x400;
if (xpos & 0x200) xpos -= 0x400;
@@ -106,11 +103,11 @@ void psikyo4_state::draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprec
if (flipy) { ystart = high - 1; yend = -1; yinc = -1; }
else { ystart = 0; yend = high; yinc = +1; }
- for (j = ystart; j != yend; j += yinc)
+ for (int j = ystart; j != yend; j += yinc)
{
- for (i = xstart; i != xend; i += xinc)
+ for (int i = xstart; i != xend; i += xinc)
{
- gfx->transpen(bitmap,cliprect, tnum + loopnum, colr, flipx, flipy, xpos + 16 * i, ypos + 16 * j, 0);
+ gfx->transpen(bitmap,cliprect, tnum + loopnum, colr, flipx, flipy, xpos + 16 * i, ypos + 16 * j, 0);
loopnum++;
}
}
@@ -122,22 +119,6 @@ void psikyo4_state::draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprec
}
}
-uint32_t psikyo4_state::screen_update_psikyo4_left(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
-{
- bitmap.fill(0x800, cliprect);
- m_gfxdecode->gfx(0)->set_palette(*m_palette);
- draw_sprites(bitmap, cliprect, 0x0000);
- return 0;
-}
-
-uint32_t psikyo4_state::screen_update_psikyo4_right(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
-{
- bitmap.fill(0x800, cliprect);
- m_gfxdecode->gfx(0)->set_palette(*m_palette2);
- draw_sprites(bitmap, cliprect, 0x2000);
- return 0;
-}
-
void psikyo4_state::video_start()
{
m_gfxdecode->gfx(0)->set_granularity(32); /* 256 colour sprites with palette selectable on 32 colour boundaries */