Sprinter/mame
2
0
Fork 0
mirror of https://github.com/holub/mame synced 2025-04-22 16:31:49 +03:00
Code Issues Actions Packages Projects Releases Wiki Activity

raiden2.cpp : Update/Cleanups (#3941)

Browse Source 
Split video functions into video/raiden2.cpp, Cleanup ACCESSING_BITs, Fix naming, Reduce runtime tag lookups, Reduce unused, Add save state for sprite encryption values
Fix xsedae config because This game is running into modified Zero Team Hardware, And second OKI chip/surface are not exists.
raiden2.h : Use protected:/private:
r2dx_v33.cpp : Fix compile, Fix naming, Reduce runtime tag lookups, Reduce duplicates between raiden2.cpp
This commit is contained in:
cam900 2019-04-01 05:59:45 +09:00 committed by R. Belmont
parent 1e3fb5c99a
commit 88d055a065
5 changed files with 814 additions and 877 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
scripts/target/mame/arcade.lua
View File

@ -3535,6 +3535,7 @@ files {
MAME_DIR .. "src/mame/video/raiden.cpp",
MAME_DIR .. "src/mame/drivers/raiden2.cpp",
MAME_DIR .. "src/mame/includes/raiden2.h",
MAME_DIR .. "src/mame/video/raiden2.cpp",
MAME_DIR .. "src/mame/machine/r2crypt.cpp",
MAME_DIR .. "src/mame/machine/r2crypt.h",
MAME_DIR .. "src/mame/machine/seibucop/seibucop.cpp",

318
src/mame/drivers/r2dx_v33.cpp
View File

@ -54,7 +54,7 @@ Then it puts settings at 0x9e08 and 0x9e0a (bp 91acb)
230000-2fffff : 'Fixed' ROM data for Raiden DX
300000-3fffff : Banked ROM data for Raiden DX (16x 0x10000 banks)
New Zero Team /Zero
New Zero Team /Zero Team 2000
000000-01ffff : 0xff fill, inaccessible by hardware?
020000-0fffff : Fixed ROM data for Zero Team
@ -73,7 +73,6 @@ Then it puts settings at 0x9e08 and 0x9e0a (bp 91acb)
#include "sound/okim6295.h"
#include "machine/r2crypt.h"
#include "screen.h"
#include "speaker.h"
@ -85,8 +84,10 @@ public:
m_r2dxbank(0),
m_r2dxgameselect(0),
m_eeprom(*this, "eeprom"),
m_math(*this, "math")
{ }
m_math(*this, "math"),
m_okibank(*this, "okibank")
{
}
void nzerotea(machine_config &config);
void rdx_v33(machine_config &config);
@ -98,17 +99,17 @@ public:
private:
DECLARE_WRITE16_MEMBER(r2dx_angle_w);
DECLARE_WRITE16_MEMBER(r2dx_dx_w);
DECLARE_WRITE16_MEMBER(r2dx_dy_w);
DECLARE_WRITE16_MEMBER(r2dx_sdistl_w);
DECLARE_WRITE16_MEMBER(r2dx_sdisth_w);
DECLARE_READ16_MEMBER(r2dx_angle_r);
DECLARE_READ16_MEMBER(r2dx_dist_r);
DECLARE_READ16_MEMBER(r2dx_sin_r);
DECLARE_READ16_MEMBER(r2dx_cos_r);
DECLARE_WRITE16_MEMBER(angle_w);
DECLARE_WRITE16_MEMBER(dx_w);
DECLARE_WRITE16_MEMBER(dy_w);
DECLARE_WRITE16_MEMBER(sdistl_w);
DECLARE_WRITE16_MEMBER(sdisth_w);
DECLARE_READ16_MEMBER(angle_r);
DECLARE_READ16_MEMBER(dist_r);
DECLARE_READ16_MEMBER(sin_r);
DECLARE_READ16_MEMBER(cos_r);
DECLARE_WRITE16_MEMBER(tile_bank_w);
DECLARE_WRITE8_MEMBER(tile_bank_w);
DECLARE_READ16_MEMBER(rdx_v33_unknown_r);
DECLARE_WRITE16_MEMBER(mcu_xval_w);
DECLARE_WRITE16_MEMBER(mcu_yval_w);
@ -121,12 +122,10 @@ private:
DECLARE_WRITE16_MEMBER(zerotm2k_eeprom_w);
DECLARE_WRITE16_MEMBER(r2dx_rom_bank_w);
DECLARE_WRITE16_MEMBER(r2dx_tilemapdma_w);
DECLARE_WRITE16_MEMBER(r2dx_paldma_w);
DECLARE_WRITE16_MEMBER(tilemapdma_w);
DECLARE_WRITE16_MEMBER(paldma_w);
DECLARE_READ16_MEMBER(r2dx_debug_r);
INTERRUPT_GEN_MEMBER(rdx_v33_interrupt);
DECLARE_MACHINE_RESET(r2dx_v33);
DECLARE_MACHINE_RESET(nzeroteam);
@ -138,13 +137,13 @@ private:
virtual void machine_start() override;
void r2dx_setbanking(void);
void r2dx_setbanking();
int m_r2dxbank;
int m_r2dxgameselect;
uint16_t m_r2dx_i_dx, m_r2dx_i_dy, m_r2dx_i_angle;
uint32_t m_r2dx_i_sdist;
uint16_t m_dx, m_dy, m_angle;
uint32_t m_sdist;
uint16_t m_mcu_prog[0x800];
int m_mcu_prog_offs;
uint16_t m_mcu_xval, m_mcu_yval;
@ -152,18 +151,20 @@ private:
optional_device<eeprom_serial_93cxx_device> m_eeprom;
required_region_ptr<uint8_t> m_math;
optional_memory_bank m_okibank;
};
void r2dx_v33_state::machine_start()
{
raiden2_state::machine_start();
common_save_state();
save_item(NAME(m_r2dxbank));
save_item(NAME(m_r2dxgameselect));
save_item(NAME(m_r2dx_i_dx));
save_item(NAME(m_r2dx_i_dy));
save_item(NAME(m_r2dx_i_angle));
save_item(NAME(m_r2dx_i_sdist));
save_item(NAME(m_dx));
save_item(NAME(m_dy));
save_item(NAME(m_angle));
save_item(NAME(m_sdist));
save_item(NAME(m_mcu_prog));
save_item(NAME(m_mcu_prog_offs));
save_item(NAME(m_mcu_xval));
@ -171,34 +172,32 @@ void r2dx_v33_state::machine_start()
save_item(NAME(m_mcu_data));
}
WRITE16_MEMBER(r2dx_v33_state::tile_bank_w)
WRITE8_MEMBER(r2dx_v33_state::tile_bank_w)
{
if(ACCESSING_BITS_0_7) {
int new_bank;
new_bank = ((data & 0x10)>>4);
if(new_bank != bg_bank) {
bg_bank = new_bank;
background_layer->mark_all_dirty();
}
int new_bank;
new_bank = ((data & 0x10)>>4);
if(new_bank != m_bg_bank) {
m_bg_bank = new_bank;
m_background_layer->mark_all_dirty();
}
new_bank = 2 + ((data & 0x20)>>5);
if(new_bank != mid_bank) {
mid_bank = new_bank;
midground_layer->mark_all_dirty();
}
new_bank = 2 + ((data & 0x20)>>5);
if(new_bank != m_mid_bank) {
m_mid_bank = new_bank;
m_midground_layer->mark_all_dirty();
}
new_bank = 4 | (data & 3);
if(new_bank != fg_bank) {
fg_bank = new_bank;
foreground_layer->mark_all_dirty();
}
new_bank = 4 | (data & 3);
if(new_bank != m_fg_bank) {
m_fg_bank = new_bank;
m_foreground_layer->mark_all_dirty();
}
}
void r2dx_v33_state::r2dx_setbanking(void)
void r2dx_v33_state::r2dx_setbanking()
{
membank("bank1")->set_entry(m_r2dxgameselect*0x20 + m_r2dxbank + 16);
membank("bank3")->set_entry(m_r2dxgameselect);
m_mainbank[0]->set_entry(m_r2dxgameselect*0x10 + m_r2dxbank);
m_mainbank[1]->set_entry(m_r2dxgameselect);
}
WRITE16_MEMBER(r2dx_v33_state::rdx_v33_eeprom_w)
@ -216,12 +215,12 @@ WRITE16_MEMBER(r2dx_v33_state::rdx_v33_eeprom_w)
// the bit gets set if it reads RAIDENDX from the EEPROM
m_r2dxgameselect = (data & 0x04) >> 2;
tx_bank = m_r2dxgameselect;
text_layer->mark_all_dirty();
m_tx_bank = m_r2dxgameselect;
m_text_layer->mark_all_dirty();
r2dx_setbanking();
membank("okibank")->set_entry(data&3);
m_okibank->set_entry(data&3);
}
else
@ -308,55 +307,55 @@ WRITE16_MEMBER(r2dx_v33_state::r2dx_rom_bank_w)
}
WRITE16_MEMBER(r2dx_v33_state::r2dx_angle_w)
WRITE16_MEMBER(r2dx_v33_state::angle_w)
{
COMBINE_DATA(&m_r2dx_i_angle);
COMBINE_DATA(&m_angle);
}
WRITE16_MEMBER(r2dx_v33_state::r2dx_dx_w)
WRITE16_MEMBER(r2dx_v33_state::dx_w)
{
COMBINE_DATA(&m_r2dx_i_dx);
COMBINE_DATA(&m_dx);
}
WRITE16_MEMBER(r2dx_v33_state::r2dx_dy_w)
WRITE16_MEMBER(r2dx_v33_state::dy_w)
{
COMBINE_DATA(&m_r2dx_i_dy);
COMBINE_DATA(&m_dy);
}
READ16_MEMBER(r2dx_v33_state::r2dx_angle_r)
READ16_MEMBER(r2dx_v33_state::angle_r)
{
return m_math[((m_r2dx_i_dy & 0xff) << 8) | (m_r2dx_i_dx & 0xff)];
return m_math[((m_dy & 0xff) << 8) | (m_dx & 0xff)];
}
READ16_MEMBER(r2dx_v33_state::r2dx_dist_r)
READ16_MEMBER(r2dx_v33_state::dist_r)
{
return sqrt(double(m_r2dx_i_sdist));
return sqrt(double(m_sdist));
}
READ16_MEMBER(r2dx_v33_state::r2dx_sin_r)
READ16_MEMBER(r2dx_v33_state::sin_r)
{
int off = 65536 + (m_r2dx_i_angle & 0xff)*4;
int off = 65536 + (m_angle & 0xff)*4;
return (m_math[off+0]) | (m_math[off+1] << 8);
}
READ16_MEMBER(r2dx_v33_state::r2dx_cos_r)
READ16_MEMBER(r2dx_v33_state::cos_r)
{
int off = 65536 + (m_r2dx_i_angle & 0xff)*4;
int off = 65536 + (m_angle & 0xff)*4;
return (m_math[off+2]) | (m_math[off+3] << 8);
}
WRITE16_MEMBER(r2dx_v33_state::r2dx_sdistl_w)
WRITE16_MEMBER(r2dx_v33_state::sdistl_w)
{
m_r2dx_i_sdist = (m_r2dx_i_sdist & (0xffff0000 | uint16_t(~mem_mask))) | (data & mem_mask);
m_sdist = (m_sdist & (0xffff0000 | uint16_t(~mem_mask))) | (data & mem_mask);
}
WRITE16_MEMBER(r2dx_v33_state::r2dx_sdisth_w)
WRITE16_MEMBER(r2dx_v33_state::sdisth_w)
{
m_r2dx_i_sdist = (m_r2dx_i_sdist & (0x0000ffff | (uint16_t(~mem_mask)) << 16)) | ((data & mem_mask) << 16);
m_sdist = (m_sdist & (0x0000ffff | (uint16_t(~mem_mask)) << 16)) | ((data & mem_mask) << 16);
}
// these DMA operations seem to use hardcoded addresses on this hardware
WRITE16_MEMBER(r2dx_v33_state::r2dx_tilemapdma_w)
WRITE16_MEMBER(r2dx_v33_state::tilemapdma_w)
{
int src = 0xd000;
@ -368,7 +367,7 @@ WRITE16_MEMBER(r2dx_v33_state::r2dx_tilemapdma_w)
}
}
WRITE16_MEMBER(r2dx_v33_state::r2dx_paldma_w)
WRITE16_MEMBER(r2dx_v33_state::paldma_w)
{
int src = 0x1f000;
@ -390,23 +389,22 @@ void r2dx_v33_state::rdx_v33_map(address_map &map)
{
map(0x00000, 0x003ff).ram(); // vectors copied here
map(0x00400, 0x00401).w(FUNC(r2dx_v33_state::r2dx_tilemapdma_w)); // tilemaps to private buffer
map(0x00402, 0x00403).w(FUNC(r2dx_v33_state::r2dx_paldma_w)); // palettes to private buffer
map(0x00400, 0x00401).w(FUNC(r2dx_v33_state::tilemapdma_w)); // tilemaps to private buffer
map(0x00402, 0x00403).w(FUNC(r2dx_v33_state::paldma_w)); // palettes to private buffer
map(0x00404, 0x00405).w(FUNC(r2dx_v33_state::r2dx_rom_bank_w));
map(0x00406, 0x00407).w(FUNC(r2dx_v33_state::tile_bank_w));
map(0x00406, 0x00406).w(FUNC(r2dx_v33_state::tile_bank_w));
map(0x00420, 0x00421).w(FUNC(r2dx_v33_state::r2dx_dx_w));
map(0x00422, 0x00423).w(FUNC(r2dx_v33_state::r2dx_dy_w));
map(0x00424, 0x00425).w(FUNC(r2dx_v33_state::r2dx_sdistl_w));
map(0x00426, 0x00427).w(FUNC(r2dx_v33_state::r2dx_sdisth_w));
map(0x00428, 0x00429).w(FUNC(r2dx_v33_state::r2dx_angle_w));
map(0x00420, 0x00421).w(FUNC(r2dx_v33_state::dx_w));
map(0x00422, 0x00423).w(FUNC(r2dx_v33_state::dy_w));
map(0x00424, 0x00425).w(FUNC(r2dx_v33_state::sdistl_w));
map(0x00426, 0x00427).w(FUNC(r2dx_v33_state::sdisth_w));
map(0x00428, 0x00429).w(FUNC(r2dx_v33_state::angle_w));
map(0x00430, 0x00431).r(FUNC(r2dx_v33_state::r2dx_angle_r));
map(0x00432, 0x00433).r(FUNC(r2dx_v33_state::r2dx_dist_r));
map(0x00434, 0x00435).r(FUNC(r2dx_v33_state::r2dx_sin_r));
map(0x00436, 0x00437).r(FUNC(r2dx_v33_state::r2dx_cos_r));
map(0x00430, 0x00431).r(FUNC(r2dx_v33_state::angle_r));
map(0x00432, 0x00433).r(FUNC(r2dx_v33_state::dist_r));
map(0x00434, 0x00435).r(FUNC(r2dx_v33_state::sin_r));
map(0x00436, 0x00437).r(FUNC(r2dx_v33_state::cos_r));
map(0x00600, 0x0063f).rw("crtc", FUNC(seibu_crtc_device::read), FUNC(seibu_crtc_device::write));
//AM_RANGE(0x00640, 0x006bf) AM_DEVREADWRITE("obj", seibu_encrypted_sprite_device, read, write)
@ -428,7 +426,6 @@ void r2dx_v33_state::rdx_v33_map(address_map &map)
map(0x006dc, 0x006dd).rw(FUNC(r2dx_v33_state::sprite_prot_maxx_r), FUNC(r2dx_v33_state::sprite_prot_maxx_w));
map(0x006de, 0x006df).w(FUNC(r2dx_v33_state::sprite_prot_src_w));
map(0x00700, 0x00701).w(FUNC(r2dx_v33_state::rdx_v33_eeprom_w));
map(0x00740, 0x00741).r(FUNC(r2dx_v33_state::r2dx_debug_r));
map(0x00744, 0x00745).portr("INPUT");
@ -440,18 +437,18 @@ void r2dx_v33_state::rdx_v33_map(address_map &map)
map(0x00800, 0x00fff).ram(); // copies eeprom here?
map(0x01000, 0x0bfff).ram();
map(0x0c000, 0x0c7ff).ram().share("sprites");
map(0x0c000, 0x0c7ff).ram().share("spriteram");
map(0x0c800, 0x0cfff).ram();
map(0x0d000, 0x0d7ff).ram(); //_WRITE(raiden2_background_w) AM_SHARE("back_data")
map(0x0d800, 0x0dfff).ram(); //_WRITE(raiden2_foreground_w) AM_SHARE("fore_data")
map(0x0e000, 0x0e7ff).ram(); //_WRITE(raiden2_midground_w) AM_SHARE("mid_data")
map(0x0e800, 0x0f7ff).ram(); //_WRITE(raiden2_text_w) AM_SHARE("text_data")
map(0x0d000, 0x0d7ff).ram(); //_WRITE(background_w) AM_SHARE("back_data")
map(0x0d800, 0x0dfff).ram(); //_WRITE(foreground_w) AM_SHARE("fore_data")
map(0x0e000, 0x0e7ff).ram(); //_WRITE(midground_w) AM_SHARE("mid_data")
map(0x0e800, 0x0f7ff).ram(); //_WRITE(text_w) AM_SHARE("text_data")
map(0x0f800, 0x0ffff).ram(); /* Stack area */
map(0x10000, 0x1efff).ram();
map(0x1f000, 0x1ffff).ram(); //_DEVWRITE("palette", palette_device, write) AM_SHARE("palette")
map(0x20000, 0x2ffff).bankr("bank1").nopw();
map(0x30000, 0xfffff).bankr("bank3").nopw();
map(0x20000, 0x2ffff).bankr("mainbank1").nopw();
map(0x30000, 0xfffff).bankr("mainbank2").nopw();
}
@ -459,23 +456,23 @@ void r2dx_v33_state::nzeroteam_base_map(address_map &map)
{
map(0x00000, 0x003ff).ram(); //stack area
map(0x00400, 0x00401).w(FUNC(r2dx_v33_state::r2dx_tilemapdma_w)); // tilemaps to private buffer
map(0x00402, 0x00403).w(FUNC(r2dx_v33_state::r2dx_paldma_w)); // palettes to private buffer
map(0x00400, 0x00401).w(FUNC(r2dx_v33_state::tilemapdma_w)); // tilemaps to private buffer
map(0x00402, 0x00403).w(FUNC(r2dx_v33_state::paldma_w)); // palettes to private buffer
// 0x404 is bank on r2dx, this doesn't need it
// AM_RANGE(0x00406, 0x00407) AM_WRITE(tile_bank_w) // not the same?
// AM_RANGE(0x00406, 0x00406) AM_WRITE(tile_bank_w) // not the same?
map(0x00406, 0x00407).noprw(); // always 6022, supposed to be the tile bank but ignores the actual value???
map(0x00420, 0x00421).w(FUNC(r2dx_v33_state::r2dx_dx_w));
map(0x00422, 0x00423).w(FUNC(r2dx_v33_state::r2dx_dy_w));
map(0x00424, 0x00425).w(FUNC(r2dx_v33_state::r2dx_sdistl_w));
map(0x00426, 0x00427).w(FUNC(r2dx_v33_state::r2dx_sdisth_w));
map(0x00428, 0x00429).w(FUNC(r2dx_v33_state::r2dx_angle_w));
map(0x00420, 0x00421).w(FUNC(r2dx_v33_state::dx_w));
map(0x00422, 0x00423).w(FUNC(r2dx_v33_state::dy_w));
map(0x00424, 0x00425).w(FUNC(r2dx_v33_state::sdistl_w));
map(0x00426, 0x00427).w(FUNC(r2dx_v33_state::sdisth_w));
map(0x00428, 0x00429).w(FUNC(r2dx_v33_state::angle_w));
map(0x00430, 0x00431).r(FUNC(r2dx_v33_state::r2dx_angle_r));
map(0x00432, 0x00433).r(FUNC(r2dx_v33_state::r2dx_dist_r));
map(0x00434, 0x00435).r(FUNC(r2dx_v33_state::r2dx_sin_r));
map(0x00436, 0x00437).r(FUNC(r2dx_v33_state::r2dx_cos_r));
map(0x00430, 0x00431).r(FUNC(r2dx_v33_state::angle_r));
map(0x00432, 0x00433).r(FUNC(r2dx_v33_state::dist_r));
map(0x00434, 0x00435).r(FUNC(r2dx_v33_state::sin_r));
map(0x00436, 0x00437).r(FUNC(r2dx_v33_state::cos_r));
map(0x00600, 0x0063f).rw("crtc", FUNC(seibu_crtc_device::read), FUNC(seibu_crtc_device::write));
//map(0x00640, 0x006bf)rw("obj", FUNC(seibu_encrypted_sprite_device::read), FUNC(seibu_encrypted_sprite_device::write));
@ -499,12 +496,12 @@ void r2dx_v33_state::nzeroteam_base_map(address_map &map)
map(0x00800, 0x00fff).ram();
map(0x01000, 0x0bfff).ram();
map(0x0c000, 0x0c7ff).ram().share("sprites");
map(0x0c000, 0x0c7ff).ram().share("spriteram");
map(0x0c800, 0x0cfff).ram();
map(0x0d000, 0x0d7ff).ram(); //.w(FUNC(r2dx_v33_state::raiden2_background_w)).share("back_data");
map(0x0d800, 0x0dfff).ram(); //.w(FUNC(r2dx_v33_state::raiden2_foreground_w)).share("fore_data");
map(0x0e000, 0x0e7ff).ram(); //.w(FUNC(r2dx_v33_state::raiden2_midground_w)).share("mid_data");
map(0x0e800, 0x0f7ff).ram(); //.w(FUNC(r2dx_v33_state::raiden2_text_w)).share("text_data");
map(0x0d000, 0x0d7ff).ram(); //.w(FUNC(r2dx_v33_state::background_w)).share("back_data");
map(0x0d800, 0x0dfff).ram(); //.w(FUNC(r2dx_v33_state::foreground_w)).share("fore_data");
map(0x0e000, 0x0e7ff).ram(); //.w(FUNC(r2dx_v33_state::midground_w)).share("mid_data");
map(0x0e800, 0x0f7ff).ram(); //.w(FUNC(r2dx_v33_state::text_w)).share("text_data");
map(0x0f800, 0x0ffff).ram(); /* Stack area */
map(0x10000, 0x1efff).ram();
map(0x1f000, 0x1ffff).ram(); //.w("palette", FUNC(palette_device::write)).share("palette");
@ -540,56 +537,6 @@ void r2dx_v33_state::zerotm2k_map(address_map &map)
INTERRUPT_GEN_MEMBER(r2dx_v33_state::rdx_v33_interrupt)
{
device.execute().set_input_line_and_vector(0, HOLD_LINE, 0xc0/4); /* VBL */
}
static const gfx_layout rdx_v33_charlayout =
{
8,8,
RGN_FRAC(1,1),
4,
{ 8,12,0,4 },
{ 3,2,1,0,19,18,17,16 },
{ STEP8(0,32) },
32*8
};
static const gfx_layout rdx_v33_tilelayout =
{
16,16,
RGN_FRAC(1,1),
4,
{ 8,12,0,4 },
{
3,2,1,0,
19,18,17,16,
3+64*8, 2+64*8, 1+64*8, 0+64*8,
19+64*8,18+64*8,17+64*8,16+64*8,
},
{ STEP16(0,32) },
128*8
};
static const gfx_layout rdx_v33_spritelayout =
{
16, 16,
RGN_FRAC(1,1),
4,
{ STEP4(0,1) },
{ 4, 0, 12, 8, 20, 16, 28, 24, 36, 32, 44, 40, 52, 48, 60, 56 },
{ STEP16(0,64) },
16*16*4
};
static GFXDECODE_START( gfx_rdx_v33 )
GFXDECODE_ENTRY( "gfx1", 0x00000, rdx_v33_charlayout, 0x700, 128 )
GFXDECODE_ENTRY( "gfx2", 0x00000, rdx_v33_tilelayout, 0x400, 128 )
GFXDECODE_ENTRY( "gfx3", 0x00000, rdx_v33_spritelayout, 0x000, 4096 )
GFXDECODE_END
static INPUT_PORTS_START( rdx_v33 )
PORT_START("SYSTEM")
PORT_BIT( 0x0001, IP_ACTIVE_LOW, IPT_START1 )
@ -766,16 +713,12 @@ INPUT_PORTS_END
MACHINE_RESET_MEMBER(r2dx_v33_state,r2dx_v33)
{
common_reset();
bank_reset(0,6,2,0);
}
MACHINE_RESET_MEMBER(r2dx_v33_state,nzeroteam)
{
common_reset();
bg_bank = 0;
fg_bank = 2;
mid_bank = 1;
bank_reset(0,2,1,0);
}
void r2dx_v33_state::r2dx_oki_map(address_map &map)
@ -788,7 +731,7 @@ void r2dx_v33_state::rdx_v33(machine_config &config)
/* basic machine hardware */
V33(config, m_maincpu, 32000000/2); // ?
m_maincpu->set_addrmap(AS_PROGRAM, &r2dx_v33_state::rdx_v33_map);
m_maincpu->set_vblank_int("screen", FUNC(r2dx_v33_state::rdx_v33_interrupt));
m_maincpu->set_vblank_int("screen", FUNC(r2dx_v33_state::interrupt));
MCFG_MACHINE_RESET_OVERRIDE(r2dx_v33_state,r2dx_v33)
@ -800,16 +743,14 @@ void r2dx_v33_state::rdx_v33(machine_config &config)
screen.set_vblank_time(ATTOSECONDS_IN_USEC(500)); /* not accurate */
screen.set_size(44*8, 34*8);
screen.set_visarea(0*8, 40*8-1, 0, 30*8-1);
screen.set_screen_update(FUNC(raiden2_state::screen_update_raiden2));
screen.set_screen_update(FUNC(r2dx_v33_state::screen_update));
GFXDECODE(config, m_gfxdecode, m_palette, gfx_rdx_v33);
GFXDECODE(config, m_gfxdecode, m_palette, r2dx_v33_state::gfx_raiden2);
PALETTE(config, m_palette).set_format(palette_device::xBGR_555, 2048);
MCFG_VIDEO_START_OVERRIDE(raiden2_state,raiden2)
seibu_crtc_device &crtc(SEIBU_CRTC(config, "crtc", 0));
crtc.layer_en_callback().set(FUNC(raiden2_state::tilemap_enable_w));
crtc.layer_scroll_callback().set(FUNC(raiden2_state::tile_scroll_w));
crtc.layer_en_callback().set(FUNC(r2dx_v33_state::tilemap_enable_w));
crtc.layer_scroll_callback().set(FUNC(r2dx_v33_state::tile_scroll_w));
/* sound hardware */
SPEAKER(config, "mono").front_center();
@ -824,7 +765,7 @@ void r2dx_v33_state::nzerotea(machine_config &config)
/* basic machine hardware */
V33(config, m_maincpu, XTAL(32'000'000)/2); /* verified on pcb */
m_maincpu->set_addrmap(AS_PROGRAM, &r2dx_v33_state::nzerotea_map);
m_maincpu->set_vblank_int("screen", FUNC(r2dx_v33_state::rdx_v33_interrupt));
m_maincpu->set_vblank_int("screen", FUNC(r2dx_v33_state::interrupt));
MCFG_MACHINE_RESET_OVERRIDE(r2dx_v33_state,nzeroteam)
@ -838,16 +779,14 @@ void r2dx_v33_state::nzerotea(machine_config &config)
screen.set_vblank_time(ATTOSECONDS_IN_USEC(500)); /* not accurate */
screen.set_size(44*8, 34*8);
screen.set_visarea(0*8, 40*8-1, 0, 32*8-1);
screen.set_screen_update(FUNC(raiden2_state::screen_update_raiden2));
screen.set_screen_update(FUNC(r2dx_v33_state::screen_update));
GFXDECODE(config, m_gfxdecode, m_palette, gfx_rdx_v33);
GFXDECODE(config, m_gfxdecode, m_palette, r2dx_v33_state::gfx_raiden2);
PALETTE(config, m_palette).set_format(palette_device::xBGR_555, 2048);
MCFG_VIDEO_START_OVERRIDE(raiden2_state,raiden2)
seibu_crtc_device &crtc(SEIBU_CRTC(config, "crtc", 0));
crtc.layer_en_callback().set(FUNC(raiden2_state::tilemap_enable_w));
crtc.layer_scroll_callback().set(FUNC(raiden2_state::tile_scroll_w));
crtc.layer_en_callback().set(FUNC(r2dx_v33_state::tilemap_enable_w));
crtc.layer_scroll_callback().set(FUNC(r2dx_v33_state::tile_scroll_w));
/* sound hardware */
SPEAKER(config, "mono").front_center();
@ -879,23 +818,20 @@ void r2dx_v33_state::init_rdx_v33()
{
init_blending(raiden_blended_colors);
static const int spri[5] = { 0, 1, 2, 3, -1 };
cur_spri = spri;
membank("bank1")->configure_entries(0, 0x40, memregion("maincpu")->base(), 0x10000);
membank("bank3")->configure_entry(0, memregion("maincpu")->base()+0x030000); // 0x30000 - 0xfffff bank for Raiden 2
membank("bank3")->configure_entry(1, memregion("maincpu")->base()+0x230000); // 0x30000 - 0xfffff bank for Raiden DX
m_cur_spri = spri;
m_mainbank[0]->configure_entries( 0, 0x10, memregion("maincpu")->base() + 0x100000, 0x010000); // 0x20000 - 0x2ffff bank for Raiden 2
m_mainbank[0]->configure_entries(0x10, 0x10, memregion("maincpu")->base() + 0x300000, 0x010000); // 0x20000 - 0x2ffff bank for Raiden DX
m_mainbank[1]->configure_entries( 0, 2, memregion("maincpu")->base() + 0x030000, 0x200000);
raiden2_decrypt_sprites(machine());
// sensible defaults if booting as R2
membank("bank1")->set_entry(0);
membank("bank3")->set_entry(0);
m_mainbank[0]->set_entry(0);
m_mainbank[1]->set_entry(0);
membank("okibank")->configure_entries(0, 4, memregion("oki")->base(), 0x40000);
membank("okibank")->set_entry(0);
m_okibank->configure_entries(0, 4, memregion("oki")->base(), 0x40000);
m_okibank->set_entry(0);
}
@ -903,7 +839,7 @@ void r2dx_v33_state::init_nzerotea()
{
init_blending(zeroteam_blended_colors);
static const int spri[5] = { -1, 0, 1, 2, 3 };
cur_spri = spri;
m_cur_spri = spri;
zeroteam_decrypt_sprites(machine());
}
@ -912,7 +848,7 @@ void r2dx_v33_state::init_zerotm2k()
{
init_blending(zeroteam_blended_colors);
static const int spri[5] = { -1, 0, 1, 2, 3 };
cur_spri = spri;
m_cur_spri = spri;
// no sprite encryption(!)

741
src/mame/drivers/raiden2.cpp
View File

File diff suppressed because it is too large Load Diff

246
src/mame/includes/raiden2.h
View File

@ -9,160 +9,170 @@
#include "machine/seibucop/seibucop.h"
#include "video/seibu_crtc.h"
#include "emupal.h"
#include "screen.h"
#include <algorithm>
class raiden2_state : public driver_device
{
public:
raiden2_state(const machine_config &mconfig, device_type type, const char *tag)
: driver_device(mconfig, type, tag)
, sprites(*this, "sprites")
, m_spriteram(*this, "spriteram")
, m_maincpu(*this, "maincpu")
, m_seibu_sound(*this, "seibu_sound")
, m_gfxdecode(*this, "gfxdecode")
, m_palette(*this, "palette")
, bg_bank(0)
, fg_bank(0)
, mid_bank(0)
, tx_bank(0)
, raiden2_tilemap_enable(0)
, prg_bank(0)
, cop_bank(0)
, sprite_prot_x(0)
, sprite_prot_y(0)
, dst1(0)
, cop_spr_maxx(0)
, cop_spr_off(0)
, tile_buffer(320, 256)
, sprite_buffer(320, 256)
, m_screen(*this, "screen")
, m_mainbank(*this, "mainbank%u", 1U)
, m_raiden2cop(*this, "raiden2cop")
, m_sprite_prot_x(0)
, m_sprite_prot_y(0)
, m_dst1(0)
, m_cop_spr_maxx(0)
, m_cop_spr_off(0)
, m_bg_bank(0)
, m_fg_bank(0)
, m_mid_bank(0)
, m_tx_bank(0)
, m_tilemap_enable(0)
, m_prg_bank(0)
, m_cop_bank(0)
{
memset(scrollvals, 0, sizeof(uint16_t)*6);
memset(sprite_prot_src_addr, 0, sizeof(uint16_t)*2);
std::fill(std::begin(m_sprite_prot_src_addr), std::end(m_sprite_prot_src_addr), 0);
std::fill(std::begin(m_scrollvals), std::end(m_scrollvals), 0);
}
std::unique_ptr<uint16_t[]> m_back_data;
std::unique_ptr<uint16_t[]> m_fore_data;
std::unique_ptr<uint16_t[]> m_mid_data;
std::unique_ptr<uint16_t[]> m_text_data; // private buffers, allocated in init
std::unique_ptr<uint16_t[]> m_palette_data;
required_shared_ptr<uint16_t> sprites;
required_device<cpu_device> m_maincpu;
optional_device<seibu_sound_device> m_seibu_sound;
required_device<gfxdecode_device> m_gfxdecode;
required_device<palette_device> m_palette;
DECLARE_WRITE16_MEMBER ( raiden2_bank_w );
DECLARE_READ16_MEMBER ( cop_tile_bank_2_r );
DECLARE_WRITE16_MEMBER ( cop_tile_bank_2_w );
DECLARE_WRITE16_MEMBER ( raidendx_cop_bank_2_w );
DECLARE_WRITE16_MEMBER ( tilemap_enable_w );
DECLARE_WRITE16_MEMBER ( tile_scroll_w );
DECLARE_WRITE16_MEMBER ( tile_bank_01_w );
DECLARE_WRITE16_MEMBER ( raiden2_background_w );
DECLARE_WRITE16_MEMBER ( raiden2_foreground_w );
DECLARE_WRITE16_MEMBER ( raiden2_midground_w );
DECLARE_WRITE16_MEMBER ( raiden2_text_w );
DECLARE_WRITE16_MEMBER(m_videoram_private_w);
DECLARE_WRITE16_MEMBER( sprcpt_val_1_w );
DECLARE_WRITE16_MEMBER( sprcpt_val_2_w );
DECLARE_WRITE16_MEMBER( sprcpt_data_1_w );
DECLARE_WRITE16_MEMBER( sprcpt_data_2_w );
DECLARE_WRITE16_MEMBER( sprcpt_data_3_w );
DECLARE_WRITE16_MEMBER( sprcpt_data_4_w );
DECLARE_WRITE16_MEMBER( sprcpt_adr_w );
DECLARE_WRITE16_MEMBER( sprcpt_flags_1_w );
DECLARE_WRITE16_MEMBER( sprcpt_flags_2_w );
void common_reset();
static uint16_t const raiden_blended_colors[];
static uint16_t const xsedae_blended_colors[];
static uint16_t const zeroteam_blended_colors[];
bool blend_active[0x800]; // cfg
tilemap_t *background_layer,*midground_layer,*foreground_layer,*text_layer;
int bg_bank, fg_bank, mid_bank, tx_bank;
uint16_t raiden2_tilemap_enable;
uint8_t prg_bank;
uint16_t cop_bank;
uint16_t scrollvals[6];
DECLARE_WRITE16_MEMBER( sprite_prot_x_w );
DECLARE_WRITE16_MEMBER( sprite_prot_y_w );
DECLARE_WRITE16_MEMBER( sprite_prot_src_seg_w );
DECLARE_WRITE16_MEMBER( sprite_prot_src_w );
DECLARE_READ16_MEMBER( sprite_prot_src_seg_r );
DECLARE_READ16_MEMBER( sprite_prot_dst1_r );
DECLARE_READ16_MEMBER( sprite_prot_maxx_r );
DECLARE_READ16_MEMBER( sprite_prot_off_r );
DECLARE_WRITE16_MEMBER( sprite_prot_dst1_w );
DECLARE_WRITE16_MEMBER( sprite_prot_maxx_w );
DECLARE_WRITE16_MEMBER( sprite_prot_off_w );
uint16_t sprite_prot_x,sprite_prot_y,dst1,cop_spr_maxx,cop_spr_off;
uint16_t sprite_prot_src_addr[2];
void draw_sprites(const rectangle &cliprect);
const int *cur_spri; // cfg
void raidendx(machine_config &config);
void xsedae(machine_config &config);
void zeroteam(machine_config &config);
void raiden2(machine_config &config);
void init_raidendx();
void init_xsedae();
void init_zeroteam();
void init_raiden2();
protected:
std::unique_ptr<uint16_t[]> m_back_data;
std::unique_ptr<uint16_t[]> m_fore_data;
std::unique_ptr<uint16_t[]> m_mid_data;
std::unique_ptr<uint16_t[]> m_text_data; // private buffers, allocated in init
std::unique_ptr<uint16_t[]> m_palette_data;
required_shared_ptr<uint16_t> m_spriteram;
required_device<cpu_device> m_maincpu;
optional_device<seibu_sound_device> m_seibu_sound;
required_device<gfxdecode_device> m_gfxdecode;
required_device<palette_device> m_palette;
required_device<screen_device> m_screen;
optional_memory_bank_array<2> m_mainbank;
optional_device<raiden2cop_device> m_raiden2cop;
DECLARE_WRITE16_MEMBER(sprite_prot_x_w);
DECLARE_WRITE16_MEMBER(sprite_prot_y_w);
DECLARE_WRITE16_MEMBER(sprite_prot_src_seg_w);
DECLARE_WRITE16_MEMBER(sprite_prot_src_w);
DECLARE_READ16_MEMBER(sprite_prot_src_seg_r);
DECLARE_READ16_MEMBER(sprite_prot_dst1_r);
DECLARE_READ16_MEMBER(sprite_prot_maxx_r);
DECLARE_READ16_MEMBER(sprite_prot_off_r);
DECLARE_WRITE16_MEMBER(sprite_prot_dst1_w);
DECLARE_WRITE16_MEMBER(sprite_prot_maxx_w);
DECLARE_WRITE16_MEMBER(sprite_prot_off_w);
uint16_t m_sprite_prot_x,m_sprite_prot_y,m_dst1,m_cop_spr_maxx,m_cop_spr_off;
uint16_t m_sprite_prot_src_addr[2];
INTERRUPT_GEN_MEMBER(interrupt);
void common_save_state();
virtual void video_start() override;
DECLARE_WRITE16_MEMBER(tilemap_enable_w);
DECLARE_WRITE16_MEMBER(tile_scroll_w);
DECLARE_WRITE16_MEMBER(background_w);
DECLARE_WRITE16_MEMBER(foreground_w);
DECLARE_WRITE16_MEMBER(midground_w);
DECLARE_WRITE16_MEMBER(text_w);
DECLARE_WRITE16_MEMBER(m_videoram_private_w);
void bank_reset(int bgbank, int fgbank, int midbank, int txbank);
static uint16_t const raiden_blended_colors[];
static uint16_t const xsedae_blended_colors[];
static uint16_t const zeroteam_blended_colors[];
bool m_blend_active[0x800]; // cfg
tilemap_t *m_background_layer,*m_midground_layer,*m_foreground_layer,*m_text_layer;
int m_bg_bank, m_fg_bank, m_mid_bank, m_tx_bank;
uint16_t m_tilemap_enable;
uint16_t m_scrollvals[6];
void draw_sprites(const rectangle &cliprect);
const int *m_cur_spri; // cfg
DECLARE_GFXDECODE_MEMBER(gfx_raiden2);
TILE_GET_INFO_MEMBER(get_back_tile_info);
TILE_GET_INFO_MEMBER(get_mid_tile_info);
TILE_GET_INFO_MEMBER(get_fore_tile_info);
TILE_GET_INFO_MEMBER(get_text_tile_info);
DECLARE_MACHINE_RESET(raiden2);
DECLARE_VIDEO_START(raiden2);
DECLARE_MACHINE_RESET(zeroteam);
DECLARE_MACHINE_RESET(xsedae);
DECLARE_MACHINE_RESET(raidendx);
uint32_t screen_update_raiden2(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect);
INTERRUPT_GEN_MEMBER(raiden2_interrupt);
void combine32(uint32_t *val, int offset, uint16_t data, uint16_t mem_mask);
void sprcpt_init(void);
uint32_t screen_update(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect);
void blend_layer(bitmap_rgb32 &bitmap, const rectangle &cliprect, bitmap_ind16 &source, int layer);
void tilemap_draw_and_blend(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect, tilemap_t *tilemap);
void init_blending(const uint16_t *table);
bitmap_ind16 tile_buffer, sprite_buffer;
optional_device<raiden2cop_device> m_raiden2cop;
bitmap_ind16 m_tile_bitmap, m_sprite_bitmap;
void raidendx(machine_config &config);
void xsedae(machine_config &config);
void zeroteam(machine_config &config);
void raiden2(machine_config &config);
void zeroteam_sound_map(address_map &map);
private:
DECLARE_WRITE8_MEMBER(raiden2_bank_w);
DECLARE_WRITE8_MEMBER(tile_bank_01_w);
DECLARE_READ16_MEMBER(cop_tile_bank_2_r);
DECLARE_WRITE16_MEMBER(cop_tile_bank_2_w);
DECLARE_WRITE16_MEMBER(raidendx_cop_bank_2_w);
uint8_t m_prg_bank;
uint16_t m_cop_bank;
DECLARE_WRITE16_MEMBER(sprcpt_val_1_w);
DECLARE_WRITE16_MEMBER(sprcpt_val_2_w);
DECLARE_WRITE16_MEMBER(sprcpt_data_1_w);
DECLARE_WRITE16_MEMBER(sprcpt_data_2_w);
DECLARE_WRITE16_MEMBER(sprcpt_data_3_w);
DECLARE_WRITE16_MEMBER(sprcpt_data_4_w);
DECLARE_WRITE16_MEMBER(sprcpt_adr_w);
DECLARE_WRITE16_MEMBER(sprcpt_flags_1_w);
DECLARE_WRITE16_MEMBER(sprcpt_flags_2_w);
uint32_t m_sprcpt_adr, m_sprcpt_idx;
uint32_t m_sprcpt_val[2], m_sprcpt_flags1;
uint16_t m_sprcpt_flags2;
uint32_t m_sprcpt_data_1[0x100], m_sprcpt_data_2[0x40], m_sprcpt_data_3[6], m_sprcpt_data_4[4];
virtual void machine_start() override;
DECLARE_MACHINE_RESET(raiden2);
DECLARE_MACHINE_RESET(zeroteam);
DECLARE_MACHINE_RESET(xsedae);
DECLARE_MACHINE_RESET(raidendx);
void combine32(uint32_t *val, int offset, uint16_t data, uint16_t mem_mask);
void sprcpt_init();
void raiden2_cop_mem(address_map &map);
void raiden2_mem(address_map &map);
void raiden2_sound_map(address_map &map);
void raidendx_mem(address_map &map);
void xsedae_mem(address_map &map);
void zeroteam_mem(address_map &map);
void zeroteam_sound_map(address_map &map);
protected:
virtual void machine_start() override;
};
#endif // MAME_INCLUDES_RAIDEN2_H

385
src/mame/video/raiden2.cpp Normal file
View File

@ -0,0 +1,385 @@
// license:LGPL-2.1+
// copyright-holders:Olivier Galibert, Angelo Salese, David Haywood, Tomasz Slanina
/********************************************************************************************************
Seibu Protected 1993-94 era hardware, V30 based (sequel to the SYS68C hardware)
********************************************************************************************************/
#include "emu.h"
#include "includes/raiden2.h"
WRITE16_MEMBER(raiden2_state::m_videoram_private_w)
{
// map(0x0d000, 0x0d7ff).ram().w(FUNC(raiden2_state::background_w)).share("back_data");
// map(0x0d800, 0x0dfff).ram().w(FUNC(raiden2_state::foreground_w).share("fore_data");
// map(0x0e000, 0x0e7ff).ram().w(FUNC(raiden2_state::midground_w).share("mid_data");
// map(0x0e800, 0x0f7ff).ram().w(FUNC(raiden2_state::text_w).share("text_data");
if (offset < 0x800 / 2)
{
background_w(space, offset, data, 0xffff);
}
else if (offset < 0x1000 /2)
{
offset -= 0x800 / 2;
foreground_w(space, offset, data, 0xffff);
}
else if (offset < 0x1800/2)
{
offset -= 0x1000 / 2;
midground_w(space, offset, data, 0xffff);
}
else if (offset < 0x2800/2)
{
offset -= 0x1800 / 2;
text_w(space, offset, data, 0xffff);
}
}
void raiden2_state::draw_sprites(const rectangle &cliprect)
{
uint16_t *source = m_spriteram + (0x1000/2)-4;
m_sprite_bitmap.fill(0xf, cliprect);
gfx_element *gfx = m_gfxdecode->gfx(2);
/*
00 fhhh Fwww ppcc cccc h = height f=flipy w = width F = flipx p = priority c = color
02 nnnn nnnn nnnn nnnn n = tileno
04 xxxx xxxx xxxx xxxx x = xpos
06 yyyy yyyy yyyy yyyy y = ypos
*/
while( source >= m_spriteram ){
int tile_number = source[1];
int sx = source[2];
int sy = source[3];
int colr;
int xtiles, ytiles;
int ytlim, xtlim;
int xflip, yflip;
int xstep, ystep;
int pri;
ytlim = (source[0] >> 12) & 0x7;
xtlim = (source[0] >> 8 ) & 0x7;
xflip = (source[0] >> 15) & 0x1;
yflip = (source[0] >> 11) & 0x1;
colr = source[0] & 0x3f;
pri = (source[0] >> 6) & 3;
colr |= pri << (14-4);
ytlim += 1;
xtlim += 1;
xstep = 16;
ystep = 16;
if (xflip)
{
ystep = -16;
sy += ytlim*16-16;
}
if (yflip)
{
xstep = -16;
sx += xtlim*16-16;
}
for (xtiles = 0; xtiles < xtlim; xtiles++)
{
for (ytiles = 0; ytiles < ytlim; ytiles++)
{
/* note this wraparound handling could be wrong if some of the COP maths is wrong */
#define ZEROTEAM_MASK_X (0x1ff) // causes a blank square in the corner of zero team, but otherwise the thrusters of the ship in the r2 intro are clipped, using 0x8000 as a sign bit instead of this logic works for r2, but not zero team
#define ZEROTEAM_MASK_Y (0x1ff)
gfx->transpen_raw(
m_sprite_bitmap,
cliprect,
tile_number,
colr << 4,
yflip,xflip,
(sx+xstep*xtiles)&ZEROTEAM_MASK_X,(sy+ystep*ytiles)&ZEROTEAM_MASK_Y, 15);
gfx->transpen_raw(
m_sprite_bitmap,
cliprect,
tile_number,
colr << 4,
yflip,xflip,
((sx+xstep*xtiles)&ZEROTEAM_MASK_X)-0x200,(sy+ystep*ytiles)&ZEROTEAM_MASK_Y, 15);
gfx->transpen_raw(
m_sprite_bitmap,
cliprect,
tile_number,
colr << 4,
yflip,xflip,
(sx+xstep*xtiles)&ZEROTEAM_MASK_X,((sy+ystep*ytiles)&ZEROTEAM_MASK_Y)-0x200, 15);
gfx->transpen_raw(
m_sprite_bitmap,
cliprect,
tile_number,
colr << 4,
yflip,xflip,
((sx+xstep*xtiles)&ZEROTEAM_MASK_X)-0x200,((sy+ystep*ytiles)&ZEROTEAM_MASK_Y)-0x200, 15);
tile_number++;
}
}
source -= 4;
}
}
WRITE16_MEMBER(raiden2_state::background_w)
{
COMBINE_DATA(&m_back_data[offset]);
m_background_layer->mark_tile_dirty(offset);
}
WRITE16_MEMBER(raiden2_state::midground_w)
{
COMBINE_DATA(&m_mid_data[offset]);
m_midground_layer->mark_tile_dirty(offset);
}
WRITE16_MEMBER(raiden2_state::foreground_w)
{
COMBINE_DATA(&m_fore_data[offset]);
m_foreground_layer->mark_tile_dirty(offset);
}
WRITE16_MEMBER(raiden2_state::text_w)
{
COMBINE_DATA(&m_text_data[offset]);
m_text_layer->mark_tile_dirty(offset);
}
WRITE16_MEMBER(raiden2_state::tilemap_enable_w)
{
COMBINE_DATA(&m_tilemap_enable);
}
WRITE16_MEMBER(raiden2_state::tile_scroll_w)
{
tilemap_t *tm = nullptr;
switch(offset/2) {
case 0: tm = m_background_layer; break;
case 1: tm = m_midground_layer; break;
case 2: tm = m_foreground_layer; break;
default: assert(0); break;
}
COMBINE_DATA(&m_scrollvals[offset]);
data = m_scrollvals[offset];
if(offset & 1)
tm->set_scrolly(0, data);
else
tm->set_scrollx(0, data);
}
WRITE8_MEMBER(raiden2_state::tile_bank_01_w)
{
int new_bank;
new_bank = 0 | ((data & 1)<<1);
if(new_bank != m_bg_bank) {
m_bg_bank = new_bank;
m_background_layer->mark_all_dirty();
}
new_bank = 1 | (data & 2);
if(new_bank != m_mid_bank) {
m_mid_bank = new_bank;
m_midground_layer->mark_all_dirty();
}
}
READ16_MEMBER(raiden2_state::cop_tile_bank_2_r)
{
return m_cop_bank;
}
WRITE16_MEMBER(raiden2_state::cop_tile_bank_2_w)
{
COMBINE_DATA(&m_cop_bank);
if(ACCESSING_BITS_8_15) {
int new_bank = 4 | (data >> 14);
if(new_bank != m_fg_bank) {
m_fg_bank = new_bank;
m_foreground_layer->mark_all_dirty();
}
}
}
WRITE16_MEMBER(raiden2_state::raidendx_cop_bank_2_w)
{
COMBINE_DATA(&m_cop_bank);
int new_bank = 4 | ((m_cop_bank >> 4) & 3);
if(new_bank != m_fg_bank) {
m_fg_bank = new_bank;
m_foreground_layer->mark_all_dirty();
}
/* mainbank2 coming from 6c9 ? */
int bb = m_cop_bank >> 12;
m_mainbank[0]->set_entry(bb + 16);
m_mainbank[1]->set_entry(3);
}
TILE_GET_INFO_MEMBER(raiden2_state::get_back_tile_info)
{
int tile = m_back_data[tile_index];
int color = (tile >> 12) | (0 << 4);
tile = (tile & 0xfff) | (m_bg_bank << 12);
SET_TILE_INFO_MEMBER(1,tile+0x0000,color,0);
}
TILE_GET_INFO_MEMBER(raiden2_state::get_mid_tile_info)
{
int tile = m_mid_data[tile_index];
int color = (tile >> 12) | (2 << 4);
tile = (tile & 0xfff) | (m_mid_bank << 12);
SET_TILE_INFO_MEMBER(1,tile,color,0);
}
TILE_GET_INFO_MEMBER(raiden2_state::get_fore_tile_info)
{
int tile = m_fore_data[tile_index];
int color = (tile >> 12) | (1 << 4);
tile = (tile & 0xfff) | (m_fg_bank << 12);
SET_TILE_INFO_MEMBER(1,tile,color,0);
}
TILE_GET_INFO_MEMBER(raiden2_state::get_text_tile_info)
{
int tile = m_text_data[tile_index];
int color = (tile>>12)&0xf;
tile &= 0xfff;
SET_TILE_INFO_MEMBER(0,tile + m_tx_bank * 0x1000,color,0);
}
void raiden2_state::video_start()
{
m_screen->register_screen_bitmap(m_tile_bitmap);
m_screen->register_screen_bitmap(m_sprite_bitmap);
m_back_data = make_unique_clear<uint16_t[]>(0x800/2);
m_fore_data = make_unique_clear<uint16_t[]>(0x800/2);
m_mid_data = make_unique_clear<uint16_t[]>(0x800/2);
m_text_data = make_unique_clear<uint16_t[]>(0x1000/2);
m_palette_data = make_unique_clear<uint16_t[]>(0x1000/2);
m_palette->basemem().set(m_palette_data.get(), 0x1000/2 * sizeof(uint16_t), 16, ENDIANNESS_LITTLE, 2);
save_pointer(NAME(m_back_data), 0x800/2);
save_pointer(NAME(m_fore_data), 0x800/2);
save_pointer(NAME(m_mid_data), 0x800/2);
save_pointer(NAME(m_text_data), 0x1000/2);
save_pointer(NAME(m_palette_data), 0x1000/2);
m_text_layer = &machine().tilemap().create(*m_gfxdecode, tilemap_get_info_delegate(FUNC(raiden2_state::get_text_tile_info),this), TILEMAP_SCAN_ROWS, 8, 8, 64,32 );
m_background_layer = &machine().tilemap().create(*m_gfxdecode, tilemap_get_info_delegate(FUNC(raiden2_state::get_back_tile_info),this), TILEMAP_SCAN_ROWS, 16,16, 32,32 );
m_midground_layer = &machine().tilemap().create(*m_gfxdecode, tilemap_get_info_delegate(FUNC(raiden2_state::get_mid_tile_info),this), TILEMAP_SCAN_ROWS, 16,16, 32,32 );
m_foreground_layer = &machine().tilemap().create(*m_gfxdecode, tilemap_get_info_delegate(FUNC(raiden2_state::get_fore_tile_info),this), TILEMAP_SCAN_ROWS, 16,16, 32,32 );
}
void raiden2_state::blend_layer(bitmap_rgb32 &bitmap, const rectangle &cliprect, bitmap_ind16 &source, int layer)
{
if(layer == -1)
return;
const pen_t *pens = &m_palette->pen(0);
layer <<= 14;
for(int y = cliprect.min_y; y <= cliprect.max_y; y++) {
const uint16_t *src = &source.pix16(y, cliprect.min_x);
uint32_t *dst = &bitmap.pix32(y, cliprect.min_x);
for(int x = cliprect.min_x; x <= cliprect.max_x; x++) {
uint16_t val = *src++;
if((val & 0xc000) == layer && (val & 0x000f) != 0x000f) {
val &= 0x07ff;
if(m_blend_active[val])
*dst = alpha_blend_r32(*dst, pens[val], 0x7f);
else
*dst = pens[val];
}
dst++;
}
}
}
void raiden2_state::tilemap_draw_and_blend(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect, tilemap_t *tilemap)
{
tilemap->draw(screen, m_tile_bitmap, cliprect, 0, 0);
blend_layer(bitmap, cliprect, m_tile_bitmap, 0);
}
uint32_t raiden2_state::screen_update(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect)
{
bitmap.fill(m_palette->black_pen(), cliprect);
if (!(m_tilemap_enable & 16)) {
draw_sprites(cliprect);
blend_layer(bitmap, cliprect, m_sprite_bitmap, m_cur_spri[0]);
}
if (!(m_tilemap_enable & 1))
tilemap_draw_and_blend(screen, bitmap, cliprect, m_background_layer);
if (!(m_tilemap_enable & 16))
blend_layer(bitmap, cliprect, m_sprite_bitmap, m_cur_spri[1]);
if (!(m_tilemap_enable & 2))
tilemap_draw_and_blend(screen, bitmap, cliprect, m_midground_layer);
if (!(m_tilemap_enable & 16))
blend_layer(bitmap, cliprect, m_sprite_bitmap, m_cur_spri[2]);
if (!(m_tilemap_enable & 4))
tilemap_draw_and_blend(screen, bitmap, cliprect, m_foreground_layer);
if (!(m_tilemap_enable & 16))
blend_layer(bitmap, cliprect, m_sprite_bitmap, m_cur_spri[3]);
if (!(m_tilemap_enable & 8))
tilemap_draw_and_blend(screen, bitmap, cliprect, m_text_layer);
if (!(m_tilemap_enable & 16))
blend_layer(bitmap, cliprect, m_sprite_bitmap, m_cur_spri[4]);
if (machine().input().code_pressed_once(KEYCODE_Z))
if (m_raiden2cop) m_raiden2cop->dump_table();
return 0;
}