Sprinter/mame
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

segas24: Start untangling the Vogon poetry Atari Ace left is his wake.

Browse Source 
Apply the new timing implementation per cgfm's analysis.
          Gain ground is going to be stuck in free play mode.
          [O. Galibert]
This commit is contained in:
Olivier Galibert 2011-04-17 18:00:35 +00:00
parent 35af804269
commit 59a98d5c7c
12 changed files with 956 additions and 776 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
.gitattributes vendored
View File

@ -3681,7 +3681,6 @@ src/mame/machine/segag80.h svneol=native#text/plain
src/mame/machine/segaic16.c svneol=native#text/plain src/mame/machine/segaic16.c svneol=native#text/plain
src/mame/machine/segaic16.h svneol=native#text/plain src/mame/machine/segaic16.h svneol=native#text/plain
src/mame/machine/segamsys.c svneol=native#text/plain src/mame/machine/segamsys.c svneol=native#text/plain
src/mame/machine/segas24.c svneol=native#text/plain
src/mame/machine/segas32.c svneol=native#text/plain src/mame/machine/segas32.c svneol=native#text/plain
src/mame/machine/seibuspi.c svneol=native#text/plain src/mame/machine/seibuspi.c svneol=native#text/plain
src/mame/machine/seibuspi.h svneol=native#text/plain src/mame/machine/seibuspi.h svneol=native#text/plain

10
src/mame/drivers/model1.c
View File

@ -877,12 +877,12 @@ static ADDRESS_MAP_START( model1_mem, AS_PROGRAM, 16 )
AM_RANGE(0x610000, 0x61ffff) AM_RAM_WRITE(md1_w) AM_BASE_MEMBER(model1_state, m_display_list1) AM_RANGE(0x610000, 0x61ffff) AM_RAM_WRITE(md1_w) AM_BASE_MEMBER(model1_state, m_display_list1)
AM_RANGE(0x680000, 0x680003) AM_READWRITE(model1_listctl_r, model1_listctl_w) AM_RANGE(0x680000, 0x680003) AM_READWRITE(model1_listctl_r, model1_listctl_w)
AM_RANGE(0x700000, 0x70ffff) AM_READWRITE(sys24_tile_r, sys24_tile_w) AM_RANGE(0x700000, 0x70ffff) AM_DEVREADWRITE_MODERN("tile", segas24_tile, tile_r, tile_w)
AM_RANGE(0x720000, 0x720001) AM_WRITENOP // Unknown, always 0 AM_RANGE(0x720000, 0x720001) AM_WRITENOP // Unknown, always 0
AM_RANGE(0x740000, 0x740001) AM_WRITENOP // Horizontal synchronization register AM_RANGE(0x740000, 0x740001) AM_WRITENOP // Horizontal synchronization register
AM_RANGE(0x760000, 0x760001) AM_WRITENOP // Vertical synchronization register AM_RANGE(0x760000, 0x760001) AM_WRITENOP // Vertical synchronization register
AM_RANGE(0x770000, 0x770001) AM_WRITENOP // Video synchronization switch AM_RANGE(0x770000, 0x770001) AM_WRITENOP // Video synchronization switch
AM_RANGE(0x780000, 0x7fffff) AM_READWRITE(sys24_char_r, sys24_char_w) AM_RANGE(0x780000, 0x7fffff) AM_DEVREADWRITE_MODERN("tile", segas24_tile, char_r, char_w)
AM_RANGE(0x900000, 0x903fff) AM_RAM_WRITE(p_w) AM_BASE_GENERIC(paletteram) AM_RANGE(0x900000, 0x903fff) AM_RAM_WRITE(p_w) AM_BASE_GENERIC(paletteram)
AM_RANGE(0x910000, 0x91bfff) AM_RAM AM_BASE_MEMBER(model1_state, m_color_xlat) AM_RANGE(0x910000, 0x91bfff) AM_RAM AM_BASE_MEMBER(model1_state, m_color_xlat)
@ -925,12 +925,12 @@ static ADDRESS_MAP_START( model1_vr_mem, AS_PROGRAM, 16 )
AM_RANGE(0x610000, 0x61ffff) AM_RAM_WRITE(md1_w) AM_BASE_MEMBER(model1_state, m_display_list1) AM_RANGE(0x610000, 0x61ffff) AM_RAM_WRITE(md1_w) AM_BASE_MEMBER(model1_state, m_display_list1)
AM_RANGE(0x680000, 0x680003) AM_READWRITE(model1_listctl_r, model1_listctl_w) AM_RANGE(0x680000, 0x680003) AM_READWRITE(model1_listctl_r, model1_listctl_w)
AM_RANGE(0x700000, 0x70ffff) AM_READWRITE(sys24_tile_r, sys24_tile_w) AM_RANGE(0x700000, 0x70ffff) AM_DEVREADWRITE_MODERN("tile", segas24_tile, tile_r, tile_w)
AM_RANGE(0x720000, 0x720001) AM_WRITENOP // Unknown, always 0 AM_RANGE(0x720000, 0x720001) AM_WRITENOP // Unknown, always 0
AM_RANGE(0x740000, 0x740001) AM_WRITENOP // Horizontal synchronization register AM_RANGE(0x740000, 0x740001) AM_WRITENOP // Horizontal synchronization register
AM_RANGE(0x760000, 0x760001) AM_WRITENOP // Vertical synchronization register AM_RANGE(0x760000, 0x760001) AM_WRITENOP // Vertical synchronization register
AM_RANGE(0x770000, 0x770001) AM_WRITENOP // Video synchronization switch AM_RANGE(0x770000, 0x770001) AM_WRITENOP // Video synchronization switch
AM_RANGE(0x780000, 0x7fffff) AM_READWRITE(sys24_char_r, sys24_char_w) AM_RANGE(0x780000, 0x7fffff) AM_DEVREADWRITE_MODERN("tile", segas24_tile, char_r, char_w)
AM_RANGE(0x900000, 0x903fff) AM_RAM_WRITE(p_w) AM_BASE_GENERIC(paletteram) AM_RANGE(0x900000, 0x903fff) AM_RAM_WRITE(p_w) AM_BASE_GENERIC(paletteram)
AM_RANGE(0x910000, 0x91bfff) AM_RAM AM_BASE_MEMBER(model1_state, m_color_xlat) AM_RANGE(0x910000, 0x91bfff) AM_RAM AM_BASE_MEMBER(model1_state, m_color_xlat)
@ -1514,6 +1514,8 @@ static MACHINE_CONFIG_START( model1, model1_state )
MCFG_MACHINE_RESET(model1) MCFG_MACHINE_RESET(model1)
MCFG_NVRAM_ADD_0FILL("nvram") MCFG_NVRAM_ADD_0FILL("nvram")
MCFG_S24TILE_DEVICE_ADD("tile", 0x3fff)
MCFG_VIDEO_ATTRIBUTES(VIDEO_UPDATE_AFTER_VBLANK ) MCFG_VIDEO_ATTRIBUTES(VIDEO_UPDATE_AFTER_VBLANK )
MCFG_SCREEN_ADD("screen", RASTER) MCFG_SCREEN_ADD("screen", RASTER)

10
src/mame/drivers/model2.c
View File

@ -1373,14 +1373,12 @@ static ADDRESS_MAP_START( model2_base_mem, AS_PROGRAM, 32 )
AM_RANGE(0x00f00000, 0x00f0000f) AM_READWRITE(timers_r, timers_w) AM_RANGE(0x00f00000, 0x00f0000f) AM_READWRITE(timers_r, timers_w)
AM_RANGE(0x01000000, 0x0100ffff) AM_READWRITE(sys24_tile32_r, sys24_tile32_w) AM_MIRROR(0x100000) AM_RANGE(0x01000000, 0x0100ffff) AM_DEVREADWRITE_MODERN("tile", segas24_tile, tile32_r, tile32_w) AM_MIRROR(0x110000)
AM_RANGE(0x01020000, 0x01020003) AM_WRITENOP AM_MIRROR(0x100000) // Unknown, always 0 AM_RANGE(0x01020000, 0x01020003) AM_WRITENOP AM_MIRROR(0x100000) // Unknown, always 0
AM_RANGE(0x01040000, 0x01040003) AM_WRITENOP AM_MIRROR(0x100000) // Horizontal synchronization register AM_RANGE(0x01040000, 0x01040003) AM_WRITENOP AM_MIRROR(0x100000) // Horizontal synchronization register
AM_RANGE(0x01060000, 0x01060003) AM_WRITENOP AM_MIRROR(0x100000) // Vertical synchronization register AM_RANGE(0x01060000, 0x01060003) AM_WRITENOP AM_MIRROR(0x100000) // Vertical synchronization register
AM_RANGE(0x01070000, 0x01070003) AM_WRITENOP AM_MIRROR(0x100000) // Video synchronization switch AM_RANGE(0x01070000, 0x01070003) AM_WRITENOP AM_MIRROR(0x100000) // Video synchronization switch
AM_RANGE(0x01080000, 0x010fffff) AM_READWRITE(sys24_char32_r, sys24_char32_w) AM_MIRROR(0x100000) AM_RANGE(0x01080000, 0x010fffff) AM_DEVREADWRITE_MODERN("tile", segas24_tile, char32_r, char32_w) AM_MIRROR(0x100000)
AM_RANGE(0x01100000, 0x0110ffff) AM_READWRITE(sys24_tile32_r, sys24_tile32_w) AM_MIRROR(0x10000)
AM_RANGE(0x01180000, 0x011fffff) AM_READWRITE(sys24_char32_r, sys24_char32_w) AM_MIRROR(0x100000)
AM_RANGE(0x01800000, 0x01803fff) AM_RAM_WRITE(pal32_w) AM_BASE_MEMBER(model2_state, m_paletteram32) AM_RANGE(0x01800000, 0x01803fff) AM_RAM_WRITE(pal32_w) AM_BASE_MEMBER(model2_state, m_paletteram32)
AM_RANGE(0x01810000, 0x0181bfff) AM_RAM AM_BASE_MEMBER(model2_state, m_colorxlat) AM_RANGE(0x01810000, 0x0181bfff) AM_RAM AM_BASE_MEMBER(model2_state, m_colorxlat)
@ -2028,6 +2026,8 @@ static MACHINE_CONFIG_START( model2o, model2_state )
MCFG_TIMER_ADD("timer3", model2_timer_cb) MCFG_TIMER_ADD("timer3", model2_timer_cb)
MCFG_TIMER_PTR((FPTR)3) MCFG_TIMER_PTR((FPTR)3)
MCFG_S24TILE_DEVICE_ADD("tile", 0x3fff)
MCFG_VIDEO_ATTRIBUTES(VIDEO_UPDATE_AFTER_VBLANK ) MCFG_VIDEO_ATTRIBUTES(VIDEO_UPDATE_AFTER_VBLANK )
MCFG_SCREEN_ADD("screen", RASTER) MCFG_SCREEN_ADD("screen", RASTER)
@ -2085,6 +2085,8 @@ static MACHINE_CONFIG_START( model2a, model2_state )
MCFG_TIMER_ADD("timer3", model2_timer_cb) MCFG_TIMER_ADD("timer3", model2_timer_cb)
MCFG_TIMER_PTR((FPTR)3) MCFG_TIMER_PTR((FPTR)3)
MCFG_S24TILE_DEVICE_ADD("tile", 0x3fff)
MCFG_VIDEO_ATTRIBUTES(VIDEO_UPDATE_AFTER_VBLANK ) MCFG_VIDEO_ATTRIBUTES(VIDEO_UPDATE_AFTER_VBLANK )
MCFG_SCREEN_ADD("screen", RASTER) MCFG_SCREEN_ADD("screen", RASTER)

807
src/mame/drivers/segas24.c
View File

File diff suppressed because it is too large Load Diff

147
src/mame/includes/segas24.h
View File

@ -1,74 +1,94 @@
#include "video/segaic24.h"
class segas24_state : public driver_device class segas24_state : public driver_device
{ {
public: public:
segas24_state(running_machine &machine, const driver_device_config_base &config) segas24_state(running_machine &machine, const driver_device_config_base &config)
: driver_device(machine, config) { } : driver_device(machine, config) { }
int m_fdc_status;
int m_fdc_track; static const UINT8 mahmajn_mlt[8];
int m_fdc_sector; static const UINT8 mahmajn2_mlt[8];
int m_fdc_data; static const UINT8 qgh_mlt[8];
int m_fdc_phys_track; static const UINT8 bnzabros_mlt[8];
int m_fdc_irq; static const UINT8 qrouka_mlt[8];
int m_fdc_drq; static const UINT8 quizmeku_mlt[8];
int m_fdc_span; static const UINT8 dcclub_mlt[8];
int m_fdc_index_count;
UINT8 *m_fdc_pt; int fdc_status;
int m_track_size; int fdc_track;
int m_cur_input_line; int fdc_sector;
UINT8 m_hotrod_ctrl_cur; int fdc_data;
UINT8 m_resetcontrol; int fdc_phys_track;
UINT8 m_prev_resetcontrol; int fdc_irq;
UINT8 m_curbank; int fdc_drq;
UINT8 m_mlatch; int fdc_span;
const UINT8 *m_mlatch_table; int fdc_index_count;
UINT16 m_irq_timera; UINT8 *fdc_pt;
UINT8 m_irq_timerb; int track_size;
UINT8 m_irq_allow0; int cur_input_line;
UINT8 m_irq_allow1; UINT8 hotrod_ctrl_cur;
int m_irq_timer_pend0; UINT8 resetcontrol;
int m_irq_timer_pend1; UINT8 prev_resetcontrol;
int m_irq_yms; UINT8 curbank;
int m_irq_vblank; UINT8 mlatch;
int m_irq_sprite; const UINT8 *mlatch_table;
timer_device *m_irq_timer;
timer_device *m_irq_timer_clear; UINT16 irq_tdata, irq_tval;
int m_turns; UINT8 irq_tmode, irq_allow0, irq_allow1;
UINT16 *m_system24temp_sys16_shared_ram; int irq_timer_pend0;
UINT8 (*m_system24temp_sys16_io_io_r)(running_machine &machine, int port); int irq_timer_pend1;
void (*m_system24temp_sys16_io_io_w)(running_machine &machine, int port, UINT8 data); int irq_yms;
void (*m_system24temp_sys16_io_cnt_w)(address_space *space, UINT8 data); int irq_vblank;
read16_space_func m_system24temp_sys16_io_iod_r; int irq_sprite;
write16_space_func m_system24temp_sys16_io_iod_w; attotime irq_synctime, irq_vsynctime;
UINT8 m_system24temp_sys16_io_cnt; timer_device *irq_timer;
UINT8 m_system24temp_sys16_io_dir; timer_device *irq_timer_clear;
UINT16 *shared_ram;
UINT8 (segas24_state::*io_r)(UINT8 port);
void (segas24_state::*io_w)(UINT8 port, UINT8 data);
UINT8 io_cnt, io_dir;
segas24_tile *vtile;
segas24_sprite *vsprite;
segas24_mixer *vmixer;
DECLARE_READ16_MEMBER( sys16_paletteram_r );
DECLARE_WRITE16_MEMBER( sys16_paletteram_w );
DECLARE_READ16_MEMBER( irq_r );
DECLARE_WRITE16_MEMBER( irq_w );
DECLARE_READ16_MEMBER( fdc_r );
DECLARE_WRITE16_MEMBER( fdc_w );
DECLARE_READ16_MEMBER( fdc_status_r );
DECLARE_WRITE16_MEMBER( fdc_ctrl_w );
DECLARE_READ16_MEMBER( curbank_r );
DECLARE_WRITE16_MEMBER( curbank_w );
DECLARE_READ16_MEMBER( mlatch_r );
DECLARE_WRITE16_MEMBER( mlatch_w );
DECLARE_READ16_MEMBER( hotrod3_ctrl_r );
DECLARE_WRITE16_MEMBER( hotrod3_ctrl_w );
DECLARE_READ16_MEMBER( iod_r );
DECLARE_WRITE16_MEMBER( iod_w );
DECLARE_READ16_MEMBER ( sys16_io_r );
DECLARE_WRITE16_MEMBER( sys16_io_w );
UINT8 hotrod_io_r(UINT8 port);
UINT8 dcclub_io_r(UINT8 port);
UINT8 mahmajn_io_r(UINT8 port);
void hotrod_io_w(UINT8 port, UINT8 data);
void mahmajn_io_w(UINT8 port, UINT8 data);
void fdc_init();
void reset_reset();
void reset_bank();
void irq_init();
void irq_timer_sync();
void irq_timer_start(int old_tmode);
void reset_control_w(UINT8 data);
}; };
/*----------- defined in machine/segas24.c -----------*/
/* system24temp_ functions / variables are from shared rewrite files,
once the rest of the rewrite is complete they can be removed, I
just made a copy & renamed them for now to avoid any conflicts
*/
/* New Code */
void system24temp_sys16_io_set_callbacks(
running_machine &machine,
UINT8 (*io_r)(running_machine &machine, int port),
void (*io_w)(running_machine &machine, int port, UINT8 data),
void (*cnt_w)(address_space *space, UINT8 data),
read16_space_func iod_r,
write16_space_func iod_w);
READ16_HANDLER ( system24temp_sys16_io_r );
WRITE16_HANDLER( system24temp_sys16_io_w );
READ32_HANDLER ( system24temp_sys16_io_dword_r );
/* End New Code */
/*----------- defined in machine/s24fd.c -----------*/ /*----------- defined in machine/s24fd.c -----------*/
extern void s24_fd1094_machine_init(running_machine &machine); extern void s24_fd1094_machine_init(running_machine &machine);
@ -77,5 +97,4 @@ extern void s24_fd1094_driver_init(running_machine &machine);
/*----------- defined in video/segas24.c -----------*/ /*----------- defined in video/segas24.c -----------*/
VIDEO_START(system24);
SCREEN_UPDATE(system24); SCREEN_UPDATE(system24);

109
src/mame/machine/segas24.c
View File

@ -1,109 +0,0 @@
#include "emu.h"
#include "includes/segas24.h"
/* system24temp_ functions / variables are from shared rewrite files,
once the rest of the rewrite is complete they can be removed, I
just made a copy & renamed them for now to avoid any conflicts
*/
#ifdef UNUSED_FUNCTION
READ16_HANDLER( system24temp_sys16_shared_ram_r )
{
segas24_state *state = space->machine().driver_data<segas24_state>();
return state->m_system24temp_sys16_shared_ram[offset];
}
WRITE16_HANDLER( system24temp_sys16_shared_ram_w )
{
segas24_state *state = space->machine().driver_data<segas24_state>();
COMBINE_DATA(state->m_system24temp_sys16_shared_ram + offset);
}
#endif
/* The 315-5296
8 8bits I/O ports, 3 output-only pins, some protection, and
external/daughterboard chip selection on half of the address
range
*/
void system24temp_sys16_io_set_callbacks(
running_machine &machine,
UINT8 (*io_r)(running_machine &machine, int port),
void (*io_w)(running_machine &machine, int port, UINT8 data),
void (*cnt_w)(address_space *space, UINT8 data),
read16_space_func iod_r,
write16_space_func iod_w)
{
segas24_state *state = machine.driver_data<segas24_state>();
state->m_system24temp_sys16_io_io_r = io_r;
state->m_system24temp_sys16_io_io_w = io_w;
state->m_system24temp_sys16_io_cnt_w = cnt_w;
state->m_system24temp_sys16_io_iod_r = iod_r;
state->m_system24temp_sys16_io_iod_w = iod_w;
state->m_system24temp_sys16_io_cnt = 0x00;
state->m_system24temp_sys16_io_dir = 0x00;
}
READ16_HANDLER ( system24temp_sys16_io_r )
{
segas24_state *state = space->machine().driver_data<segas24_state>();
// logerror("IO read %02x (%s:%x)\n", offset, space->device().tag(), cpu_get_pc(&space->device()));
if(offset < 8)
return state->m_system24temp_sys16_io_io_r ? state->m_system24temp_sys16_io_io_r(space->machine(),offset) : 0xff;
else if (offset < 0x20) {
switch(offset) {
case 0x8:
return 'S';
case 0x9:
return 'E';
case 0xa:
return 'G';
case 0xb:
return 'A';
case 0xe:
return state->m_system24temp_sys16_io_cnt;
case 0xf:
return state->m_system24temp_sys16_io_dir;
default:
logerror("IO control read %02x (%s:%x)\n", offset, space->device().tag(), cpu_get_pc(&space->device()));
return 0xff;
}
} else
return state->m_system24temp_sys16_io_iod_r ? state->m_system24temp_sys16_io_iod_r(space, offset & 0x1f, mem_mask) : 0xff;
}
READ32_HANDLER(system24temp_sys16_io_dword_r)
{
return system24temp_sys16_io_r(space, 2*offset, mem_mask)|(system24temp_sys16_io_r(space,2*offset+1, mem_mask>>16)<<16);
}
WRITE16_HANDLER( system24temp_sys16_io_w )
{
segas24_state *state = space->machine().driver_data<segas24_state>();
if(ACCESSING_BITS_0_7) {
if(offset < 8) {
if(!(state->m_system24temp_sys16_io_dir & (1 << offset))) {
logerror("IO port write on input-only port (%d, [%02x], %02x, %s:%x)\n", offset, state->m_system24temp_sys16_io_dir, data & 0xff, space->device().tag(), cpu_get_pc(&space->device()));
return;
}
if(state->m_system24temp_sys16_io_io_w)
state->m_system24temp_sys16_io_io_w(space->machine(), offset, data);
} else if (offset < 0x20) {
switch(offset) {
case 0xe:
state->m_system24temp_sys16_io_cnt = data;
if(state->m_system24temp_sys16_io_cnt_w)
state->m_system24temp_sys16_io_cnt_w(space, data & 7);
break;
case 0xf:
state->m_system24temp_sys16_io_dir = data;
break;
default:
logerror("IO control write %02x, %02x (%s:%x)\n", offset, data & 0xff, space->device().tag(), cpu_get_pc(&space->device()));
}
}
}
if(offset >= 0x20 && state->m_system24temp_sys16_io_iod_w)
state->m_system24temp_sys16_io_iod_w(space, offset & 0x1f, data, mem_mask);
}

2
src/mame/mame.mak
View File

@ -1165,7 +1165,7 @@ $(MAMEOBJ)/sega.a: \
$(DRIVERS)/segas16a.o $(VIDEO)/segas16a.o \ $(DRIVERS)/segas16a.o $(VIDEO)/segas16a.o \
$(DRIVERS)/segas16b.o $(VIDEO)/segas16b.o \ $(DRIVERS)/segas16b.o $(VIDEO)/segas16b.o \
$(DRIVERS)/segas18.o $(VIDEO)/segas18.o \ $(DRIVERS)/segas18.o $(VIDEO)/segas18.o \
$(DRIVERS)/segas24.o $(MACHINE)/segas24.o $(VIDEO)/segas24.o \ $(DRIVERS)/segas24.o $(VIDEO)/segas24.o \
$(DRIVERS)/segas32.o $(MACHINE)/segas32.o $(VIDEO)/segas32.o \ $(DRIVERS)/segas32.o $(MACHINE)/segas32.o $(VIDEO)/segas32.o \
$(DRIVERS)/segaxbd.o $(VIDEO)/segaxbd.o \ $(DRIVERS)/segaxbd.o $(VIDEO)/segaxbd.o \
$(DRIVERS)/segaybd.o $(VIDEO)/segaybd.o \ $(DRIVERS)/segaybd.o $(VIDEO)/segaybd.o \

19
src/mame/video/model1.c
View File

@ -1452,8 +1452,6 @@ VIDEO_START(model1)
state->m_view = auto_alloc_clear(machine, struct view); state->m_view = auto_alloc_clear(machine, struct view);
sys24_tile_vh_start(machine, 0x3fff);
state->m_poly_rom = (UINT32 *)machine.region("user1")->base(); state->m_poly_rom = (UINT32 *)machine.region("user1")->base();
state->m_poly_ram = auto_alloc_array_clear(machine, UINT32, 0x400000); state->m_poly_ram = auto_alloc_array_clear(machine, UINT32, 0x400000);
state->m_tgp_ram = auto_alloc_array_clear(machine, UINT16, 0x100000-0x40000); state->m_tgp_ram = auto_alloc_array_clear(machine, UINT16, 0x100000-0x40000);
@ -1523,17 +1521,18 @@ SCREEN_UPDATE(model1)
bitmap_fill(screen->machine().priority_bitmap, NULL, 0); bitmap_fill(screen->machine().priority_bitmap, NULL, 0);
bitmap_fill(bitmap, cliprect, screen->machine().pens[0]); bitmap_fill(bitmap, cliprect, screen->machine().pens[0]);
sys24_tile_draw(screen->machine(), bitmap, cliprect, 6, 0, 0); segas24_tile *tile = screen->machine().device<segas24_tile>("tile");
sys24_tile_draw(screen->machine(), bitmap, cliprect, 4, 0, 0); tile->draw(bitmap, cliprect, 6, 0, 0);
sys24_tile_draw(screen->machine(), bitmap, cliprect, 2, 0, 0); tile->draw(bitmap, cliprect, 4, 0, 0);
sys24_tile_draw(screen->machine(), bitmap, cliprect, 0, 0, 0); tile->draw(bitmap, cliprect, 2, 0, 0);
tile->draw(bitmap, cliprect, 0, 0, 0);
tgp_render(screen->machine(), bitmap, cliprect); tgp_render(screen->machine(), bitmap, cliprect);
sys24_tile_draw(screen->machine(), bitmap, cliprect, 7, 0, 0); tile->draw(bitmap, cliprect, 7, 0, 0);
sys24_tile_draw(screen->machine(), bitmap, cliprect, 5, 0, 0); tile->draw(bitmap, cliprect, 5, 0, 0);
sys24_tile_draw(screen->machine(), bitmap, cliprect, 3, 0, 0); tile->draw(bitmap, cliprect, 3, 0, 0);
sys24_tile_draw(screen->machine(), bitmap, cliprect, 1, 0, 0); tile->draw(bitmap, cliprect, 1, 0, 0);
return 0; return 0;
} }

18
src/mame/video/model2.c
View File

@ -2712,7 +2712,6 @@ VIDEO_START(model2)
int width = visarea.max_x - visarea.min_x; int width = visarea.max_x - visarea.min_x;
int height = visarea.max_y - visarea.min_y; int height = visarea.max_y - visarea.min_y;
sys24_tile_vh_start(machine, 0x3fff);
state->m_sys24_bitmap = auto_alloc(machine, bitmap_t(width, height+4, BITMAP_FORMAT_INDEXED16)); state->m_sys24_bitmap = auto_alloc(machine, bitmap_t(width, height+4, BITMAP_FORMAT_INDEXED16));
state->m_poly = poly_alloc(machine, 4000, sizeof(poly_extra_data), 0); state->m_poly = poly_alloc(machine, 4000, sizeof(poly_extra_data), 0);
@ -2750,10 +2749,11 @@ SCREEN_UPDATE(model2)
bitmap_fill(bitmap, cliprect, screen->machine().pens[0]); bitmap_fill(bitmap, cliprect, screen->machine().pens[0]);
bitmap_fill(state->m_sys24_bitmap, cliprect, 0); bitmap_fill(state->m_sys24_bitmap, cliprect, 0);
sys24_tile_draw(screen->machine(), state->m_sys24_bitmap, cliprect, 7, 0, 0); segas24_tile *tile = screen->machine().device<segas24_tile>("tile");
sys24_tile_draw(screen->machine(), state->m_sys24_bitmap, cliprect, 6, 0, 0); tile->draw(state->m_sys24_bitmap, cliprect, 7, 0, 0);
sys24_tile_draw(screen->machine(), state->m_sys24_bitmap, cliprect, 5, 0, 0); tile->draw(state->m_sys24_bitmap, cliprect, 6, 0, 0);
sys24_tile_draw(screen->machine(), state->m_sys24_bitmap, cliprect, 4, 0, 0); tile->draw(state->m_sys24_bitmap, cliprect, 5, 0, 0);
tile->draw(state->m_sys24_bitmap, cliprect, 4, 0, 0);
convert_bitmap(screen->machine(), bitmap, state->m_sys24_bitmap, cliprect); convert_bitmap(screen->machine(), bitmap, state->m_sys24_bitmap, cliprect);
@ -2767,10 +2767,10 @@ SCREEN_UPDATE(model2)
model2_3d_frame_end( state, bitmap, cliprect ); model2_3d_frame_end( state, bitmap, cliprect );
bitmap_fill(state->m_sys24_bitmap, cliprect, 0); bitmap_fill(state->m_sys24_bitmap, cliprect, 0);
sys24_tile_draw(screen->machine(), state->m_sys24_bitmap, cliprect, 3, 0, 0); tile->draw(state->m_sys24_bitmap, cliprect, 3, 0, 0);
sys24_tile_draw(screen->machine(), state->m_sys24_bitmap, cliprect, 2, 0, 0); tile->draw(state->m_sys24_bitmap, cliprect, 2, 0, 0);
sys24_tile_draw(screen->machine(), state->m_sys24_bitmap, cliprect, 1, 0, 0); tile->draw(state->m_sys24_bitmap, cliprect, 1, 0, 0);
sys24_tile_draw(screen->machine(), state->m_sys24_bitmap, cliprect, 0, 0, 0); tile->draw(state->m_sys24_bitmap, cliprect, 0, 0, 0);
convert_bitmap(screen->machine(), bitmap, state->m_sys24_bitmap, cliprect); convert_bitmap(screen->machine(), bitmap, state->m_sys24_bitmap, cliprect);

378
src/mame/video/segaic24.c
View File

@ -12,81 +12,78 @@ System 24 68000x2 315-5292 315-5293 315-5294 315-5242 ym2151 da
*/ */
/*
* System 16 color palette formats
*/
/* system24temp_ functions / variables are from shared rewrite files,
once the rest of the rewrite is complete they can be removed, I
just made a copy & renamed them for now to avoid any conflicts
*/
#include "emu.h" #include "emu.h"
#include "segaic24.h" #include "segaic24.h"
static void set_color(running_machine &machine, int color, UINT8 r, UINT8 g, UINT8 b, int highlight) const device_type S24TILE = segas24_tile_config::static_alloc_device_config;
{ const device_type S24SPRITE = segas24_sprite_config::static_alloc_device_config;
palette_set_color (machine, color, MAKE_RGB(r, g, b)); const device_type S24MIXER = segas24_mixer_config::static_alloc_device_config;
if(highlight) { segas24_tile_config::segas24_tile_config(const machine_config &mconfig, const char *tag, const device_config *owner, UINT32 clock)
r = 255-0.6*(255-r); : device_config(mconfig, static_alloc_device_config, "S24TILE", tag, owner, clock)
g = 255-0.6*(255-g); {
b = 255-0.6*(255-b);
} else {
r = 0.6*r;
g = 0.6*g;
b = 0.6*b;
}
palette_set_color(machine,color+machine.total_colors()/2, MAKE_RGB(r, g, b));
} }
// 315-5242 device_config *segas24_tile_config::static_alloc_device_config(const machine_config &mconfig, const char *tag, const device_config *owner, UINT32 clock)
// qgh expects to be able to read the palette shared between CPUs
READ16_HANDLER( system24temp_sys16_paletteram1_r )
{ {
return space->machine().generic.paletteram.u16[offset]; return global_alloc(segas24_tile_config(mconfig, tag, owner, clock));
}
void segas24_tile_config::static_set_tile_mask(device_config *device, UINT16 _tile_mask)
{
segas24_tile_config *dev = downcast<segas24_tile_config *>(device);
dev->tile_mask = _tile_mask;
}
device_t *segas24_tile_config::alloc_device(running_machine &machine) const
{
return auto_alloc(machine, segas24_tile(machine, *this));
} }
WRITE16_HANDLER (system24temp_sys16_paletteram1_w) segas24_sprite_config::segas24_sprite_config(const machine_config &mconfig, const char *tag, const device_config *owner, UINT32 clock)
: device_config(mconfig, static_alloc_device_config, "S24SPRITE", tag, owner, clock)
{ {
int r, g, b;
COMBINE_DATA (space->machine().generic.paletteram.u16 + offset);
data = space->machine().generic.paletteram.u16[offset];
r = (data & 0x00f) << 4;
if(data & 0x1000)
r |= 8;
g = data & 0x0f0;
if(data & 0x2000)
g |= 8;
b = (data & 0xf00) >> 4;
if(data & 0x4000)
b |= 8;
r |= r >> 5;
g |= g >> 5;
b |= b >> 5;
set_color(space->machine(), offset, r, g, b, data & 0x8000);
} }
// - System 24 device_config *segas24_sprite_config::static_alloc_device_config(const machine_config &mconfig, const char *tag, const device_config *owner, UINT32 clock)
{
return global_alloc(segas24_sprite_config(mconfig, tag, owner, clock));
}
enum {SYS24_TILES = 0x4000}; device_t *segas24_sprite_config::alloc_device(running_machine &machine) const
{
return auto_alloc(machine, segas24_sprite(machine, *this));
}
static UINT16 *sys24_char_ram, *sys24_tile_ram;
static UINT16 sys24_tile_mask; segas24_mixer_config::segas24_mixer_config(const machine_config &mconfig, const char *tag, const device_config *owner, UINT32 clock)
static int sys24_char_gfx_index; : device_config(mconfig, static_alloc_device_config, "S24MIXER", tag, owner, clock)
static tilemap_t *sys24_tile_layer[4]; {
}
device_config *segas24_mixer_config::static_alloc_device_config(const machine_config &mconfig, const char *tag, const device_config *owner, UINT32 clock)
{
return global_alloc(segas24_mixer_config(mconfig, tag, owner, clock));
}
device_t *segas24_mixer_config::alloc_device(running_machine &machine) const
{
return auto_alloc(machine, segas24_mixer(machine, *this));
}
segas24_tile::segas24_tile(running_machine &_machine, const segas24_tile_config &_config)
: device_t(_machine, _config),
config(_config)
{
}
#define XOR(a) WORD_XOR_BE(a) #define XOR(a) WORD_XOR_BE(a)
static const gfx_layout sys24_char_layout = { const gfx_layout segas24_tile::char_layout = {
8, 8, 8, 8,
SYS24_TILES, SYS24_TILES,
4, 4,
@ -96,79 +93,75 @@ static const gfx_layout sys24_char_layout = {
8*32 8*32
}; };
static TILE_GET_INFO( sys24_tile_info_0s ) void segas24_tile::tile_info(int offset, tile_data *tileinfo, tilemap_memory_index tile_index)
{ {
UINT16 val = sys24_tile_ram[tile_index]; UINT16 val = tile_ram[tile_index|offset];
tileinfo->category = (val & 0x8000) != 0; tileinfo->category = (val & 0x8000) != 0;
SET_TILE_INFO(sys24_char_gfx_index, val & sys24_tile_mask, (val >> 7) & 0xff, 0); tileinfo_set(machine(), tileinfo, char_gfx_index, val & config.tile_mask, (val >> 7) & 0xff, 0);
} }
static TILE_GET_INFO( sys24_tile_info_0w ) TILE_GET_INFO_DEVICE( segas24_tile::tile_info_0s )
{ {
UINT16 val = sys24_tile_ram[tile_index|0x1000]; downcast<segas24_tile *>(device)->tile_info(0x0000, tileinfo, tile_index);
tileinfo->category = (val & 0x8000) != 0;
SET_TILE_INFO(sys24_char_gfx_index, val & sys24_tile_mask, (val >> 7) & 0xff, 0);
} }
static TILE_GET_INFO( sys24_tile_info_1s ) TILE_GET_INFO_DEVICE( segas24_tile::tile_info_0w )
{ {
UINT16 val = sys24_tile_ram[tile_index|0x2000]; downcast<segas24_tile *>(device)->tile_info(0x1000, tileinfo, tile_index);
tileinfo->category = (val & 0x8000) != 0;
SET_TILE_INFO(sys24_char_gfx_index, val & sys24_tile_mask, (val >> 7) & 0xff, 0);
} }
static TILE_GET_INFO( sys24_tile_info_1w ) TILE_GET_INFO_DEVICE( segas24_tile::tile_info_1s )
{ {
UINT16 val = sys24_tile_ram[tile_index|0x3000]; downcast<segas24_tile *>(device)->tile_info(0x2000, tileinfo, tile_index);
tileinfo->category = (val & 0x8000) != 0;
SET_TILE_INFO(sys24_char_gfx_index, val & sys24_tile_mask, (val >> 7) & 0xff, 0);
} }
void sys24_tile_vh_start(running_machine &machine, UINT16 tile_mask) TILE_GET_INFO_DEVICE( segas24_tile::tile_info_1w )
{ {
sys24_tile_mask = tile_mask; downcast<segas24_tile *>(device)->tile_info(0x3000, tileinfo, tile_index);
}
for(sys24_char_gfx_index = 0; sys24_char_gfx_index < MAX_GFX_ELEMENTS; sys24_char_gfx_index++) void segas24_tile::device_start()
if (machine.gfx[sys24_char_gfx_index] == 0) {
for(char_gfx_index = 0; char_gfx_index < MAX_GFX_ELEMENTS; char_gfx_index++)
if (machine().gfx[char_gfx_index] == 0)
break; break;
assert(sys24_char_gfx_index != MAX_GFX_ELEMENTS); assert(char_gfx_index != MAX_GFX_ELEMENTS);
sys24_char_ram = auto_alloc_array(machine, UINT16, 0x80000/2); char_ram = auto_alloc_array(machine(), UINT16, 0x80000/2);
tile_ram = auto_alloc_array(machine(), UINT16, 0x10000/2);
sys24_tile_ram = auto_alloc_array(machine, UINT16, 0x10000/2); tile_layer[0] = tilemap_create_device(this, tile_info_0s, tilemap_scan_rows, 8, 8, 64, 64);
tile_layer[1] = tilemap_create_device(this, tile_info_0w, tilemap_scan_rows, 8, 8, 64, 64);
tile_layer[2] = tilemap_create_device(this, tile_info_1s, tilemap_scan_rows, 8, 8, 64, 64);
tile_layer[3] = tilemap_create_device(this, tile_info_1w, tilemap_scan_rows, 8, 8, 64, 64);
sys24_tile_layer[0] = tilemap_create(machine, sys24_tile_info_0s, tilemap_scan_rows, 8, 8, 64, 64); tilemap_set_transparent_pen(tile_layer[0], 0);
sys24_tile_layer[1] = tilemap_create(machine, sys24_tile_info_0w, tilemap_scan_rows, 8, 8, 64, 64); tilemap_set_transparent_pen(tile_layer[1], 0);
sys24_tile_layer[2] = tilemap_create(machine, sys24_tile_info_1s, tilemap_scan_rows, 8, 8, 64, 64); tilemap_set_transparent_pen(tile_layer[2], 0);
sys24_tile_layer[3] = tilemap_create(machine, sys24_tile_info_1w, tilemap_scan_rows, 8, 8, 64, 64); tilemap_set_transparent_pen(tile_layer[3], 0);
tilemap_set_transparent_pen(sys24_tile_layer[0], 0); memset(char_ram, 0, 0x80000);
tilemap_set_transparent_pen(sys24_tile_layer[1], 0); memset(tile_ram, 0, 0x10000);
tilemap_set_transparent_pen(sys24_tile_layer[2], 0);
tilemap_set_transparent_pen(sys24_tile_layer[3], 0);
memset(sys24_char_ram, 0, 0x80000); machine().gfx[char_gfx_index] = gfx_element_alloc(machine(), &char_layout, (UINT8 *)char_ram, machine().total_colors() / 16, 0);
memset(sys24_tile_ram, 0, 0x10000);
machine.gfx[sys24_char_gfx_index] = gfx_element_alloc(machine, &sys24_char_layout, (UINT8 *)sys24_char_ram, machine.total_colors() / 16, 0); save_pointer(NAME(tile_ram), 0x10000/2);
save_pointer(NAME(char_ram), 0x80000/2);
state_save_register_global_pointer(machine, sys24_tile_ram, 0x10000/2);
state_save_register_global_pointer(machine, sys24_char_ram, 0x80000/2);
} }
static void sys24_tile_draw_rect(running_machine &machine, bitmap_t *bm, bitmap_t *tm, bitmap_t *dm, const UINT16 *mask, void segas24_tile::draw_rect(bitmap_t *bm, bitmap_t *tm, bitmap_t *dm, const UINT16 *mask,
UINT16 tpri, UINT8 lpri, int win, int sx, int sy, int xx1, int yy1, int xx2, int yy2) UINT16 tpri, UINT8 lpri, int win, int sx, int sy, int xx1, int yy1, int xx2, int yy2)
{ {
int y; int y;
const UINT16 *source = ((UINT16 *)bm->base) + sx + sy*bm->rowpixels; const UINT16 *source = ((UINT16 *)bm->base) + sx + sy*bm->rowpixels;
const UINT8 *trans = ((UINT8 *) tm->base) + sx + sy*tm->rowpixels; const UINT8 *trans = ((UINT8 *) tm->base) + sx + sy*tm->rowpixels;
UINT8 *prib = (UINT8 *)machine.priority_bitmap->base; UINT8 *prib = (UINT8 *)machine().priority_bitmap->base;
UINT16 *dest = (UINT16 *)dm->base; UINT16 *dest = (UINT16 *)dm->base;
tpri |= TILEMAP_PIXEL_LAYER0; tpri |= TILEMAP_PIXEL_LAYER0;
dest += yy1*dm->rowpixels + xx1; dest += yy1*dm->rowpixels + xx1;
prib += yy1*machine.priority_bitmap->rowpixels + xx1; prib += yy1*machine().priority_bitmap->rowpixels + xx1;
mask += yy1*4; mask += yy1*4;
yy2 -= yy1; yy2 -= yy1;
@ -280,7 +273,7 @@ static void sys24_tile_draw_rect(running_machine &machine, bitmap_t *bm, bitmap_
source += bm->rowpixels; source += bm->rowpixels;
trans += tm->rowpixels; trans += tm->rowpixels;
dest += dm->rowpixels; dest += dm->rowpixels;
prib += machine.priority_bitmap->rowpixels; prib += machine().priority_bitmap->rowpixels;
mask += 4; mask += 4;
} }
} }
@ -288,16 +281,16 @@ static void sys24_tile_draw_rect(running_machine &machine, bitmap_t *bm, bitmap_
// The rgb version is used by model 1 & 2 which do not need to care // The rgb version is used by model 1 & 2 which do not need to care
// about sprite priority hence the lack of support for the // about sprite priority hence the lack of support for the
// machine.priority_bitmap // priority_bitmap
static void sys24_tile_draw_rect_rgb(running_machine &machine, bitmap_t *bm, bitmap_t *tm, bitmap_t *dm, const UINT16 *mask, void segas24_tile::draw_rect_rgb(bitmap_t *bm, bitmap_t *tm, bitmap_t *dm, const UINT16 *mask,
UINT16 tpri, UINT8 lpri, int win, int sx, int sy, int xx1, int yy1, int xx2, int yy2) UINT16 tpri, UINT8 lpri, int win, int sx, int sy, int xx1, int yy1, int xx2, int yy2)
{ {
int y; int y;
const UINT16 *source = ((UINT16 *)bm->base) + sx + sy*bm->rowpixels; const UINT16 *source = ((UINT16 *)bm->base) + sx + sy*bm->rowpixels;
const UINT8 *trans = ((UINT8 *) tm->base) + sx + sy*tm->rowpixels; const UINT8 *trans = ((UINT8 *) tm->base) + sx + sy*tm->rowpixels;
UINT16 *dest = (UINT16 *)dm->base; UINT16 *dest = (UINT16 *)dm->base;
const pen_t *pens = machine.pens; const pen_t *pens = machine().pens;
tpri |= TILEMAP_PIXEL_LAYER0; tpri |= TILEMAP_PIXEL_LAYER0;
@ -402,12 +395,12 @@ static void sys24_tile_draw_rect_rgb(running_machine &machine, bitmap_t *bm, bit
} }
} }
void sys24_tile_draw(running_machine &machine, bitmap_t *bitmap, const rectangle *cliprect, int layer, int lpri, int flags) void segas24_tile::draw(bitmap_t *bitmap, const rectangle *cliprect, int layer, int lpri, int flags)
{ {
UINT16 hscr = sys24_tile_ram[0x5000+(layer >> 1)]; UINT16 hscr = tile_ram[0x5000+(layer >> 1)];
UINT16 vscr = sys24_tile_ram[0x5004+(layer >> 1)]; UINT16 vscr = tile_ram[0x5004+(layer >> 1)];
UINT16 ctrl = sys24_tile_ram[0x5004+((layer >> 1) & 2)]; UINT16 ctrl = tile_ram[0x5004+((layer >> 1) & 2)];
UINT16 *mask = sys24_tile_ram + (layer & 4 ? 0x6800 : 0x6000); UINT16 *mask = tile_ram + (layer & 4 ? 0x6800 : 0x6000);
UINT16 tpri = layer & 1; UINT16 tpri = layer & 1;
lpri = 1 << lpri; lpri = 1 << lpri;
@ -422,11 +415,11 @@ void sys24_tile_draw(running_machine &machine, bitmap_t *bitmap, const rectangle
if(layer & 1) if(layer & 1)
return; return;
tilemap_set_scrolly(sys24_tile_layer[layer], 0, vscr & 0x1ff); tilemap_set_scrolly(tile_layer[layer], 0, vscr & 0x1ff);
tilemap_set_scrolly(sys24_tile_layer[layer|1], 0, vscr & 0x1ff); tilemap_set_scrolly(tile_layer[layer|1], 0, vscr & 0x1ff);
if(hscr & 0x8000) { if(hscr & 0x8000) {
UINT16 *hscrtb = sys24_tile_ram + 0x4000 + 0x200*layer; UINT16 *hscrtb = tile_ram + 0x4000 + 0x200*layer;
switch((ctrl & 0x6000) >> 13) { switch((ctrl & 0x6000) >> 13) {
case 1: { case 1: {
@ -446,8 +439,8 @@ void sys24_tile_draw(running_machine &machine, bitmap_t *bitmap, const rectangle
hscr = hscrtb[y]; hscr = hscrtb[y];
h = hscr & 0x1ff; h = hscr & 0x1ff;
tilemap_set_scrollx(sys24_tile_layer[l1], 0, -h); tilemap_set_scrollx(tile_layer[l1], 0, -h);
tilemap_draw(bitmap, &c, sys24_tile_layer[l1], tpri, lpri); tilemap_draw(bitmap, &c, tile_layer[l1], tpri, lpri);
} }
break; break;
} }
@ -462,8 +455,8 @@ void sys24_tile_draw(running_machine &machine, bitmap_t *bitmap, const rectangle
hscr = hscrtb[y]; hscr = hscrtb[y];
h = hscr & 0x1ff; h = hscr & 0x1ff;
tilemap_set_scrollx(sys24_tile_layer[layer], 0, -h); tilemap_set_scrollx(tile_layer[layer], 0, -h);
tilemap_set_scrollx(sys24_tile_layer[layer|1], 0, -h); tilemap_set_scrollx(tile_layer[layer|1], 0, -h);
if(c1.max_x >= h) if(c1.max_x >= h)
c1.max_x = h-1; c1.max_x = h-1;
@ -474,16 +467,16 @@ void sys24_tile_draw(running_machine &machine, bitmap_t *bitmap, const rectangle
c1.min_y = c1.max_y = c2.min_y = c2.max_y = y; c1.min_y = c1.max_y = c2.min_y = c2.max_y = y;
tilemap_draw(bitmap, &c1, sys24_tile_layer[l1], tpri, lpri); tilemap_draw(bitmap, &c1, tile_layer[l1], tpri, lpri);
tilemap_draw(bitmap, &c2, sys24_tile_layer[l1^1], tpri, lpri); tilemap_draw(bitmap, &c2, tile_layer[l1^1], tpri, lpri);
} }
break; break;
} }
} }
} else { } else {
tilemap_set_scrollx(sys24_tile_layer[layer], 0, -(hscr & 0x1ff)); tilemap_set_scrollx(tile_layer[layer], 0, -(hscr & 0x1ff));
tilemap_set_scrollx(sys24_tile_layer[layer|1], 0, -(hscr & 0x1ff)); tilemap_set_scrollx(tile_layer[layer|1], 0, -(hscr & 0x1ff));
switch((ctrl & 0x6000) >> 13) { switch((ctrl & 0x6000) >> 13) {
case 1: { case 1: {
@ -498,8 +491,8 @@ void sys24_tile_draw(running_machine &machine, bitmap_t *bitmap, const rectangle
if(!((-vscr) & 0x200)) if(!((-vscr) & 0x200))
layer ^= 1; layer ^= 1;
tilemap_draw(bitmap, &c1, sys24_tile_layer[layer], tpri, lpri); tilemap_draw(bitmap, &c1, tile_layer[layer], tpri, lpri);
tilemap_draw(bitmap, &c2, sys24_tile_layer[layer^1], tpri, lpri); tilemap_draw(bitmap, &c2, tile_layer[layer^1], tpri, lpri);
break; break;
} }
case 2: case 3: { case 2: case 3: {
@ -514,8 +507,8 @@ void sys24_tile_draw(running_machine &machine, bitmap_t *bitmap, const rectangle
if(!((+hscr) & 0x200)) if(!((+hscr) & 0x200))
layer ^= 1; layer ^= 1;
tilemap_draw(bitmap, &c1, sys24_tile_layer[layer], tpri, lpri); tilemap_draw(bitmap, &c1, tile_layer[layer], tpri, lpri);
tilemap_draw(bitmap, &c2, sys24_tile_layer[layer^1], tpri, lpri); tilemap_draw(bitmap, &c2, tile_layer[layer^1], tpri, lpri);
break; break;
} }
} }
@ -523,32 +516,32 @@ void sys24_tile_draw(running_machine &machine, bitmap_t *bitmap, const rectangle
} else { } else {
bitmap_t *bm, *tm; bitmap_t *bm, *tm;
void (*draw)(running_machine &machine, bitmap_t *, bitmap_t *, bitmap_t *, const UINT16 *, void (segas24_tile::*draw)(bitmap_t *, bitmap_t *, bitmap_t *, const UINT16 *,
UINT16, UINT8, int, int, int, int, int, int, int); UINT16, UINT8, int, int, int, int, int, int, int);
int win = layer & 1; int win = layer & 1;
if(bitmap->format != BITMAP_FORMAT_INDEXED16) if(bitmap->format != BITMAP_FORMAT_INDEXED16)
draw = sys24_tile_draw_rect_rgb; draw = &segas24_tile::draw_rect_rgb;
else else
draw = sys24_tile_draw_rect; draw = &segas24_tile::draw_rect;
bm = tilemap_get_pixmap(sys24_tile_layer[layer]); bm = tilemap_get_pixmap(tile_layer[layer]);
tm = tilemap_get_flagsmap(sys24_tile_layer[layer]); tm = tilemap_get_flagsmap(tile_layer[layer]);
if(hscr & 0x8000) { if(hscr & 0x8000) {
int y; int y;
UINT16 *hscrtb = sys24_tile_ram + 0x4000 + 0x200*layer; UINT16 *hscrtb = tile_ram + 0x4000 + 0x200*layer;
vscr &= 0x1ff; vscr &= 0x1ff;
for(y=0; y<384; y++) { for(y=0; y<384; y++) {
hscr = (-hscrtb[y]) & 0x1ff; hscr = (-hscrtb[y]) & 0x1ff;
if(hscr + 496 <= 512) { if(hscr + 496 <= 512) {
// Horizontal split unnecessary // Horizontal split unnecessary
draw(machine, bm, tm, bitmap, mask, tpri, lpri, win, hscr, vscr, 0, y, 496, y+1); (this->*draw)(bm, tm, bitmap, mask, tpri, lpri, win, hscr, vscr, 0, y, 496, y+1);
} else { } else {
// Horizontal split necessary // Horizontal split necessary
draw(machine, bm, tm, bitmap, mask, tpri, lpri, win, hscr, vscr, 0, y, 512-hscr, y+1); (this->*draw)(bm, tm, bitmap, mask, tpri, lpri, win, hscr, vscr, 0, y, 512-hscr, y+1);
draw(machine, bm, tm, bitmap, mask, tpri, lpri, win, 0, vscr, 512-hscr, y, 496, y+1); (this->*draw)(bm, tm, bitmap, mask, tpri, lpri, win, 0, vscr, 512-hscr, y, 496, y+1);
} }
vscr = (vscr + 1) & 0x1ff; vscr = (vscr + 1) & 0x1ff;
} }
@ -560,89 +553,90 @@ void sys24_tile_draw(running_machine &machine, bitmap_t *bitmap, const rectangle
// Horizontal split unnecessary // Horizontal split unnecessary
if(vscr + 384 <= 512) { if(vscr + 384 <= 512) {
// Vertical split unnecessary // Vertical split unnecessary
draw(machine, bm, tm, bitmap, mask, tpri, lpri, win, hscr, vscr, 0, 0, 496, 384); (this->*draw)(bm, tm, bitmap, mask, tpri, lpri, win, hscr, vscr, 0, 0, 496, 384);
} else { } else {
// Vertical split necessary // Vertical split necessary
draw(machine, bm, tm, bitmap, mask, tpri, lpri, win, hscr, vscr, 0, 0, 496, 512-vscr); (this->*draw)(bm, tm, bitmap, mask, tpri, lpri, win, hscr, vscr, 0, 0, 496, 512-vscr);
draw(machine, bm, tm, bitmap, mask, tpri, lpri, win, hscr, 0, 0, 512-vscr, 496, 384); (this->*draw)(bm, tm, bitmap, mask, tpri, lpri, win, hscr, 0, 0, 512-vscr, 496, 384);
} }
} else { } else {
// Horizontal split necessary // Horizontal split necessary
if(vscr + 384 <= 512) { if(vscr + 384 <= 512) {
// Vertical split unnecessary // Vertical split unnecessary
draw(machine, bm, tm, bitmap, mask, tpri, lpri, win, hscr, vscr, 0, 0, 512-hscr, 384); (this->*draw)(bm, tm, bitmap, mask, tpri, lpri, win, hscr, vscr, 0, 0, 512-hscr, 384);
draw(machine, bm, tm, bitmap, mask, tpri, lpri, win, 0, vscr, 512-hscr, 0, 496, 384); (this->*draw)(bm, tm, bitmap, mask, tpri, lpri, win, 0, vscr, 512-hscr, 0, 496, 384);
} else { } else {
// Vertical split necessary // Vertical split necessary
draw(machine, bm, tm, bitmap, mask, tpri, lpri, win, hscr, vscr, 0, 0, 512-hscr, 512-vscr); (this->*draw)(bm, tm, bitmap, mask, tpri, lpri, win, hscr, vscr, 0, 0, 512-hscr, 512-vscr);
draw(machine, bm, tm, bitmap, mask, tpri, lpri, win, 0, vscr, 512-hscr, 0, 496, 512-vscr); (this->*draw)(bm, tm, bitmap, mask, tpri, lpri, win, 0, vscr, 512-hscr, 0, 496, 512-vscr);
draw(machine, bm, tm, bitmap, mask, tpri, lpri, win, hscr, 0, 0, 512-vscr, 512-hscr, 384); (this->*draw)(bm, tm, bitmap, mask, tpri, lpri, win, hscr, 0, 0, 512-vscr, 512-hscr, 384);
draw(machine, bm, tm, bitmap, mask, tpri, lpri, win, 0, 0, 512-hscr, 512-vscr, 496, 384); (this->*draw)(bm, tm, bitmap, mask, tpri, lpri, win, 0, 0, 512-hscr, 512-vscr, 496, 384);
} }
} }
} }
} }
} }
READ16_HANDLER(sys24_tile_r) READ16_MEMBER(segas24_tile::tile_r)
{ {
return sys24_tile_ram[offset]; return tile_ram[offset];
} }
READ16_HANDLER(sys24_char_r) READ16_MEMBER(segas24_tile::char_r)
{ {
return sys24_char_ram[offset]; return char_ram[offset];
} }
WRITE16_HANDLER(sys24_tile_w) WRITE16_MEMBER(segas24_tile::tile_w)
{ {
COMBINE_DATA(sys24_tile_ram + offset); COMBINE_DATA(tile_ram + offset);
if(offset < 0x4000) if(offset < 0x4000)
tilemap_mark_tile_dirty(sys24_tile_layer[offset >> 12], offset & 0xfff); tilemap_mark_tile_dirty(tile_layer[offset >> 12], offset & 0xfff);
} }
WRITE16_HANDLER(sys24_char_w) WRITE16_MEMBER(segas24_tile::char_w)
{ {
UINT16 old = sys24_char_ram[offset]; UINT16 old = char_ram[offset];
COMBINE_DATA(sys24_char_ram + offset); COMBINE_DATA(char_ram + offset);
if(old != sys24_char_ram[offset]) { if(old != char_ram[offset])
gfx_element_mark_dirty(space->machine().gfx[sys24_char_gfx_index], offset / 16); gfx_element_mark_dirty(machine().gfx[char_gfx_index], offset / 16);
}
} }
READ32_HANDLER(sys24_tile32_r) READ32_MEMBER(segas24_tile::tile32_r)
{ {
return sys24_tile_r(space, offset*2, mem_mask&0xffff) | sys24_tile_r(space, (offset*2)+1, mem_mask>>16)<<16; return tile_r(space, offset*2, mem_mask&0xffff) | tile_r(space, (offset*2)+1, mem_mask>>16)<<16;
} }
READ32_HANDLER(sys24_char32_r) READ32_MEMBER(segas24_tile::char32_r)
{ {
return sys24_char_r(space, offset*2, mem_mask&0xffff) | sys24_char_r(space, (offset*2)+1, mem_mask>>16)<<16; return char_r(space, offset*2, mem_mask&0xffff) | char_r(space, (offset*2)+1, mem_mask>>16)<<16;
} }
WRITE32_HANDLER(sys24_tile32_w) WRITE32_MEMBER(segas24_tile::tile32_w)
{ {
sys24_tile_w(space, offset*2, data&0xffff, mem_mask&0xffff); tile_w(space, offset*2, data&0xffff, mem_mask&0xffff);
sys24_tile_w(space, (offset*2)+1, data>>16, mem_mask>>16); tile_w(space, (offset*2)+1, data>>16, mem_mask>>16);
} }
WRITE32_HANDLER(sys24_char32_w) WRITE32_MEMBER(segas24_tile::char32_w)
{ {
sys24_char_w(space,offset*2, data&0xffff, mem_mask&0xffff); char_w(space, offset*2, data&0xffff, mem_mask&0xffff);
sys24_char_w(space,(offset*2)+1, data>>16, mem_mask>>16); char_w(space, (offset*2)+1, data>>16, mem_mask>>16);
} }
// - System 24
static UINT16 *sys24_sprite_ram; segas24_sprite::segas24_sprite(running_machine &_machine, const segas24_sprite_config &_config)
: device_t(_machine, _config),
void sys24_sprite_vh_start(running_machine &machine) config(_config)
{ {
sys24_sprite_ram = auto_alloc_array(machine, UINT16, 0x40000/2); }
state_save_register_global_pointer(machine, sys24_sprite_ram, 0x40000/2); void segas24_sprite::device_start()
// kc = 0; {
sprite_ram = auto_alloc_array(machine(), UINT16, 0x40000/2);
save_pointer(NAME(sprite_ram), 0x40000/2);
} }
/* System24 sprites /* System24 sprites
@ -669,7 +663,7 @@ void sys24_sprite_vh_start(running_machine &machine)
0 11------ -------- 0 11------ --------
*/ */
void sys24_sprite_draw(running_machine &machine, bitmap_t *bitmap, const rectangle *cliprect, const int *spri) void segas24_sprite::draw(bitmap_t *bitmap, const rectangle *cliprect, const int *spri)
{ {
UINT16 curspr = 0; UINT16 curspr = 0;
int countspr = 0; int countspr = 0;
@ -686,7 +680,7 @@ void sys24_sprite_draw(running_machine &machine, bitmap_t *bitmap, const rectang
UINT16 *source; UINT16 *source;
UINT16 type; UINT16 type;
source = sys24_sprite_ram + (curspr << 3); source = sprite_ram + (curspr << 3);
if(curspr == 0 && source[0] == 0) if(curspr == 0 && source[0] == 0)
break; break;
@ -783,7 +777,7 @@ void sys24_sprite_draw(running_machine &machine, bitmap_t *bitmap, const rectang
flipy = source[4] & 0x8000; flipy = source[4] & 0x8000;
sy = 1 << ((source[4] & 0x7000) >> 12); sy = 1 << ((source[4] & 0x7000) >> 12);
pix = &sys24_sprite_ram[(source[3] & 0x3fff)* 0x8]; pix = &sprite_ram[(source[3] & 0x3fff)* 0x8];
for(px=0; px<8; px++) { for(px=0; px<8; px++) {
int c; int c;
c = pix[px] >> 8; c = pix[px] >> 8;
@ -830,8 +824,8 @@ void sys24_sprite_draw(running_machine &machine, bitmap_t *bitmap, const rectang
if(xpos2 >= min_x && xpos2 <= max_x) { if(xpos2 >= min_x && xpos2 <= max_x) {
int zx1 = flipx ? 7-zx : zx; int zx1 = flipx ? 7-zx : zx;
UINT32 neweroffset = (newoffset+(zx1>>2))&0x1ffff; // crackdown sometimes attempts to use data past the end of spriteram UINT32 neweroffset = (newoffset+(zx1>>2))&0x1ffff; // crackdown sometimes attempts to use data past the end of spriteram
int c = (sys24_sprite_ram[neweroffset] >> (((~zx1) & 3) << 2)) & 0xf; int c = (sprite_ram[neweroffset] >> (((~zx1) & 3) << 2)) & 0xf;
UINT8 *pri = BITMAP_ADDR8(machine.priority_bitmap, ypos1, xpos2); UINT8 *pri = BITMAP_ADDR8(machine().priority_bitmap, ypos1, xpos2);
if(!(*pri & pm[c])) { if(!(*pri & pm[c])) {
c = colors[c]; c = colors[c];
if(c) { if(c) {
@ -868,39 +862,41 @@ void sys24_sprite_draw(running_machine &machine, bitmap_t *bitmap, const rectang
} }
WRITE16_HANDLER(sys24_sprite_w) WRITE16_MEMBER(segas24_sprite::write)
{ {
COMBINE_DATA(sys24_sprite_ram + offset); COMBINE_DATA(sprite_ram + offset);
} }
READ16_HANDLER(sys24_sprite_r) READ16_MEMBER(segas24_sprite::read)
{ {
return sys24_sprite_ram[offset]; return sprite_ram[offset];
} }
// Programmable mixers
// System 24
static UINT16 sys24_mixer_reg[0x10]; segas24_mixer::segas24_mixer(running_machine &_machine, const segas24_mixer_config &_config)
: device_t(_machine, _config),
void sys24_mixer_vh_start(running_machine &machine) config(_config)
{ {
memset(sys24_mixer_reg, 0, sizeof(sys24_mixer_reg));
state_save_register_global_array(machine, sys24_mixer_reg);
} }
WRITE16_HANDLER (sys24_mixer_w) void segas24_mixer::device_start()
{ {
COMBINE_DATA(sys24_mixer_reg + offset); memset(mixer_reg, 0, sizeof(mixer_reg));
save_item(NAME(mixer_reg));
} }
READ16_HANDLER (sys24_mixer_r) WRITE16_MEMBER(segas24_mixer::write)
{ {
return sys24_mixer_reg[offset]; COMBINE_DATA(mixer_reg + offset);
} }
int sys24_mixer_get_reg(int reg) READ16_MEMBER(segas24_mixer::read)
{ {
return sys24_mixer_reg[reg]; return mixer_reg[offset];
}
UINT16 segas24_mixer::get_reg(int reg)
{
return mixer_reg[reg];
} }

174
src/mame/video/segaic24.h
View File

@ -1,43 +1,153 @@
#ifndef __SEGAIC_H #ifndef __SEGAIC24_H
#define __SEGAIC_H #define __SEGAIC24_H
/* system24temp_ functions / variables are from shared rewrite files, #define MCFG_S24TILE_DEVICE_ADD(_tag, tile_mask) \
once the rest of the rewrite is complete they can be removed, I MCFG_DEVICE_ADD(_tag, S24TILE, 0) \
just made a copy & renamed them for now to avoid any conflicts segas24_tile_config::static_set_tile_mask(device, tile_mask);
*/
READ16_HANDLER (system24temp_sys16_paletteram1_r); #define MCFG_S24SPRITE_DEVICE_ADD(_tag) \
WRITE16_HANDLER (system24temp_sys16_paletteram1_w); MCFG_DEVICE_ADD(_tag, S24SPRITE, 0)
// Tilemaps #define MCFG_S24MIXER_DEVICE_ADD(_tag) \
// System24 MCFG_DEVICE_ADD(_tag, S24MIXER, 0)
void sys24_tile_vh_start(running_machine &machine, UINT16 tile_mask);
void sys24_tile_draw(running_machine &machine, bitmap_t *bitmap, const rectangle *cliprect, int layer, int pri, int flags);
READ16_HANDLER(sys24_tile_r); class segas24_tile;
READ16_HANDLER(sys24_char_r); class segas24_sprite;
WRITE16_HANDLER(sys24_tile_w); class segas24_mixer;
WRITE16_HANDLER(sys24_char_w);
READ32_HANDLER(sys24_tile32_r); class segas24_tile_config : public device_config
READ32_HANDLER(sys24_char32_r); {
WRITE32_HANDLER(sys24_tile32_w); friend class segas24_tile;
WRITE32_HANDLER(sys24_char32_w);
// Sprites protected:
// System24 segas24_tile_config(const machine_config &mconfig, const char *tag, const device_config *owner, UINT32 clock);
void sys24_sprite_vh_start(running_machine &machine);
void sys24_sprite_draw(running_machine &machine, bitmap_t *bitmap, const rectangle *cliprect, const int *spri);
WRITE16_HANDLER (sys24_sprite_w); public:
READ16_HANDLER (sys24_sprite_r); static void static_set_tile_mask(device_config *device, UINT16 tile_mask);
// Programmable mixers static device_config *static_alloc_device_config(const machine_config &mconfig, const char *tag, const device_config *owner, UINT32 clock);
// System24 virtual device_t *alloc_device(running_machine &machine) const;
void sys24_mixer_vh_start(running_machine &machine);
int sys24_mixer_get_reg(int reg);
WRITE16_HANDLER (sys24_mixer_w); private:
READ16_HANDLER (sys24_mixer_r); UINT16 tile_mask;
};
class segas24_sprite_config : public device_config
{
friend class segas24_sprite;
protected:
segas24_sprite_config(const machine_config &mconfig, const char *tag, const device_config *owner, UINT32 clock);
public:
static device_config *static_alloc_device_config(const machine_config &mconfig, const char *tag, const device_config *owner, UINT32 clock);
virtual device_t *alloc_device(running_machine &machine) const;
};
class segas24_mixer_config : public device_config
{
friend class segas24_mixer;
protected:
segas24_mixer_config(const machine_config &mconfig, const char *tag, const device_config *owner, UINT32 clock);
public:
static device_config *static_alloc_device_config(const machine_config &mconfig, const char *tag, const device_config *owner, UINT32 clock);
virtual device_t *alloc_device(running_machine &machine) const;
};
class segas24_tile : public device_t
{
friend class segas24_tile_config;
segas24_tile(running_machine &_machine, const segas24_tile_config &config);
public:
DECLARE_READ16_MEMBER(tile_r);
DECLARE_WRITE16_MEMBER(tile_w);
DECLARE_READ16_MEMBER(char_r);
DECLARE_WRITE16_MEMBER(char_w);
DECLARE_READ32_MEMBER(tile32_r);
DECLARE_WRITE32_MEMBER(tile32_w);
DECLARE_READ32_MEMBER(char32_r);
DECLARE_WRITE32_MEMBER(char32_w);
void draw(bitmap_t *bitmap, const rectangle *cliprect, int layer, int pri, int flags);
protected:
virtual void device_start();
const segas24_tile_config &config;
private:
enum {
SYS24_TILES = 0x4000
};
UINT16 *char_ram, *tile_ram;
int char_gfx_index;
tilemap_t *tile_layer[4];
static const gfx_layout char_layout;
void tile_info(int offset, tile_data *tileinfo, tilemap_memory_index tile_index);
static TILE_GET_INFO_DEVICE(tile_info_0s);
static TILE_GET_INFO_DEVICE(tile_info_0w);
static TILE_GET_INFO_DEVICE(tile_info_1s);
static TILE_GET_INFO_DEVICE(tile_info_1w);
void draw_rect(bitmap_t *bm, bitmap_t *tm, bitmap_t *dm, const UINT16 *mask,
UINT16 tpri, UINT8 lpri, int win, int sx, int sy, int xx1, int yy1, int xx2, int yy2);
void draw_rect_rgb(bitmap_t *bm, bitmap_t *tm, bitmap_t *dm, const UINT16 *mask,
UINT16 tpri, UINT8 lpri, int win, int sx, int sy, int xx1, int yy1, int xx2, int yy2);
};
class segas24_sprite : public device_t
{
friend class segas24_sprite_config;
segas24_sprite(running_machine &_machine, const segas24_sprite_config &config);
public:
DECLARE_READ16_MEMBER(read);
DECLARE_WRITE16_MEMBER(write);
void draw(bitmap_t *bitmap, const rectangle *cliprect, const int *spri);
protected:
virtual void device_start();
const segas24_sprite_config &config;
private:
UINT16 *sprite_ram;
};
class segas24_mixer : public device_t
{
friend class segas24_mixer_config;
segas24_mixer(running_machine &_machine, const segas24_mixer_config &config);
public:
DECLARE_READ16_MEMBER(read);
DECLARE_WRITE16_MEMBER(write);
UINT16 get_reg(int reg);
protected:
virtual void device_start();
const segas24_mixer_config &config;
private:
UINT16 mixer_reg[16];
};
extern const device_type S24TILE, S24SPRITE, S24MIXER;
#endif #endif

57
src/mame/video/segas24.c
View File

@ -1,32 +1,33 @@
#include <vector>
#include <algorithm>
#include "emu.h" #include "emu.h"
#include "video/segaic24.h" #include "video/segaic24.h"
#include "includes/segas24.h" #include "includes/segas24.h"
VIDEO_START(system24)
{
sys24_tile_vh_start(machine, 0xfff);
sys24_sprite_vh_start(machine);
sys24_mixer_vh_start(machine);
}
static int layer_cmp(const void *pl1, const void *pl2) namespace {
{ struct layer_sort {
static const int default_pri[12] = { 0, 1, 2, 3, 4, 5, 6, 7, -4, -3, -2, -1 }; layer_sort(segas24_mixer *_mixer) { mixer = _mixer; }
int l1 = *(int *)pl1;
int l2 = *(int *)pl2; bool operator()(int l1, int l2) {
int p1 = sys24_mixer_get_reg(l1) & 7; static const int default_pri[12] = { 0, 1, 2, 3, 4, 5, 6, 7, -4, -3, -2, -1 };
int p2 = sys24_mixer_get_reg(l2) & 7; int p1 = mixer->get_reg(l1) & 7;
if(p1 != p2) int p2 = mixer->get_reg(l2) & 7;
return p1 - p2; if(p1 != p2)
return default_pri[l2] - default_pri[l1]; return p1 - p2 < 0;
} return default_pri[l2] - default_pri[l1] < 0;
}
segas24_mixer *mixer;
};
};
SCREEN_UPDATE(system24) SCREEN_UPDATE(system24)
{ {
int i, level; segas24_state *state = screen->machine().driver_data<segas24_state>();
int order[12], spri[4];
if(sys24_mixer_get_reg(13) & 1) { if(state->vmixer->get_reg(13) & 1) {
bitmap_fill(bitmap, 0, get_black_pen(screen->machine())); bitmap_fill(bitmap, 0, get_black_pen(screen->machine()));
return 0; return 0;
} }
@ -34,19 +35,23 @@ SCREEN_UPDATE(system24)
bitmap_fill(screen->machine().priority_bitmap, 0, 0); bitmap_fill(screen->machine().priority_bitmap, 0, 0);
bitmap_fill(bitmap, cliprect, 0); bitmap_fill(bitmap, cliprect, 0);
for(i=0; i<12; i++) std::vector<int> order;
order.resize(12);
for(int i=0; i<12; i++)
order[i] = i; order[i] = i;
qsort(order, 12, sizeof(int), layer_cmp);
level = 0; std::sort(order.begin(), order.end(), layer_sort(state->vmixer));
for(i=0; i<12; i++)
int spri[4];
int level = 0;
for(int i=0; i<12; i++)
if(order[i] < 8) if(order[i] < 8)
sys24_tile_draw(screen->machine(), bitmap, cliprect, order[i], level, 0); state->vtile->draw(bitmap, cliprect, order[i], level, 0);
else { else {
spri[order[i]-8] = level; spri[order[i]-8] = level;
level++; level++;
} }
sys24_sprite_draw(screen->machine(), bitmap, cliprect, spri); state->vsprite->draw(bitmap, cliprect, spri);
return 0; return 0;
} }