Sprinter/mame
2
0
Fork 0
mirror of https://github.com/holub/mame synced 2025-05-22 21:58:57 +03:00
Code Issues Actions 3 Packages Projects Releases Wiki Activity

added driver data struct to taitoair.c and taito_b.c

Browse Source 
more taito drivers will follow...
This commit is contained in:
Fabio Priuli 2010-01-07 07:30:37 +00:00
parent 426df9c91c
commit 10b94ff0a7
7 changed files with 583 additions and 301 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
.gitattributes vendored
View File

@ -2731,6 +2731,7 @@ src/mame/includes/taito_b.h svneol=native#text/plain
src/mame/includes/taito_f2.h svneol=native#text/plain
src/mame/includes/taito_f3.h svneol=native#text/plain
src/mame/includes/taito_l.h svneol=native#text/plain
src/mame/includes/taitoair.h svneol=native#text/plain
src/mame/includes/taitoipt.h svneol=native#text/plain
src/mame/includes/taitosj.h svneol=native#text/plain
src/mame/includes/tank8.h svneol=native#text/plain

236
src/mame/drivers/taito_b.c
View File

@ -188,7 +188,8 @@ static WRITE8_HANDLER( bankswitch_w )
static TIMER_CALLBACK( rsaga2_interrupt2 )
{
cputag_set_input_line(machine, "maincpu", 2, HOLD_LINE);
taitob_state *state = (taitob_state *)machine->driver_data;
cpu_set_input_line(state->maincpu, 2, HOLD_LINE);
}
static INTERRUPT_GEN( rastansaga2_interrupt )
@ -200,7 +201,8 @@ static INTERRUPT_GEN( rastansaga2_interrupt )
static TIMER_CALLBACK( crimec_interrupt3 )
{
cputag_set_input_line(machine, "maincpu", 3, HOLD_LINE);
taitob_state *state = (taitob_state *)machine->driver_data;
cpu_set_input_line(state->maincpu, 3, HOLD_LINE);
}
static INTERRUPT_GEN( crimec_interrupt )
@ -212,7 +214,8 @@ static INTERRUPT_GEN( crimec_interrupt )
static TIMER_CALLBACK( hitice_interrupt6 )
{
cputag_set_input_line(machine, "maincpu", 6, HOLD_LINE);
taitob_state *state = (taitob_state *)machine->driver_data;
cpu_set_input_line(state->maincpu, 6, HOLD_LINE);
}
static INTERRUPT_GEN( hitice_interrupt )
@ -224,7 +227,8 @@ static INTERRUPT_GEN( hitice_interrupt )
static TIMER_CALLBACK( rambo3_interrupt1 )
{
cputag_set_input_line(machine, "maincpu", 1, HOLD_LINE);
taitob_state *state = (taitob_state *)machine->driver_data;
cpu_set_input_line(state->maincpu, 1, HOLD_LINE);
}
static INTERRUPT_GEN( rambo3_interrupt )
@ -236,7 +240,8 @@ static INTERRUPT_GEN( rambo3_interrupt )
static TIMER_CALLBACK( pbobble_interrupt5 )
{
cputag_set_input_line(machine, "maincpu", 5, HOLD_LINE);
taitob_state *state = (taitob_state *)machine->driver_data;
cpu_set_input_line(state->maincpu, 5, HOLD_LINE);
}
static INTERRUPT_GEN( pbobble_interrupt )
@ -247,7 +252,8 @@ static INTERRUPT_GEN( pbobble_interrupt )
static TIMER_CALLBACK( viofight_interrupt1 )
{
cputag_set_input_line(machine, "maincpu", 1, HOLD_LINE);
taitob_state *state = (taitob_state *)machine->driver_data;
cpu_set_input_line(state->maincpu, 1, HOLD_LINE);
}
static INTERRUPT_GEN( viofight_interrupt )
@ -258,7 +264,8 @@ static INTERRUPT_GEN( viofight_interrupt )
static TIMER_CALLBACK( masterw_interrupt4 )
{
cputag_set_input_line(machine, "maincpu", 4, HOLD_LINE);
taitob_state *state = (taitob_state *)machine->driver_data;
cpu_set_input_line(state->maincpu, 4, HOLD_LINE);
}
static INTERRUPT_GEN( masterw_interrupt )
@ -269,7 +276,8 @@ static INTERRUPT_GEN( masterw_interrupt )
static TIMER_CALLBACK( silentd_interrupt4 )
{
cputag_set_input_line(machine, "maincpu", 4, HOLD_LINE);
taitob_state *state = (taitob_state *)machine->driver_data;
cpu_set_input_line(state->maincpu, 4, HOLD_LINE);
}
static INTERRUPT_GEN( silentd_interrupt )
@ -280,7 +288,8 @@ static INTERRUPT_GEN( silentd_interrupt )
static TIMER_CALLBACK( selfeena_interrupt4 )
{
cputag_set_input_line(machine, "maincpu", 4, HOLD_LINE);
taitob_state *state = (taitob_state *)machine->driver_data;
cpu_set_input_line(state->maincpu, 4, HOLD_LINE);
}
static INTERRUPT_GEN( selfeena_interrupt )
@ -291,7 +300,8 @@ static INTERRUPT_GEN( selfeena_interrupt )
static TIMER_CALLBACK( sbm_interrupt5 )//4
{
cputag_set_input_line(machine, "maincpu", 5, HOLD_LINE);
taitob_state *state = (taitob_state *)machine->driver_data;
cpu_set_input_line(state->maincpu, 5, HOLD_LINE);
}
static INTERRUPT_GEN( sbm_interrupt )//5
@ -306,49 +316,56 @@ static READ16_HANDLER( tracky1_hi_r )
{
return input_port_read(space->machine, "TRACKX1");
}
static READ16_HANDLER( tracky1_lo_r )
{
return (input_port_read(space->machine, "TRACKX1") & 0xff) <<8;
return (input_port_read(space->machine, "TRACKX1") & 0xff) << 8;
}
static READ16_HANDLER( trackx1_hi_r )
{
return input_port_read(space->machine, "TRACKY1");
}
static READ16_HANDLER( trackx1_lo_r )
{
return (input_port_read(space->machine, "TRACKY1") & 0xff) <<8;
return (input_port_read(space->machine, "TRACKY1") & 0xff) << 8;
}
static READ16_HANDLER( tracky2_hi_r )
{
return input_port_read(space->machine, "TRACKX2");
}
static READ16_HANDLER( tracky2_lo_r )
{
return (input_port_read(space->machine, "TRACKX2") & 0xff) <<8;
return (input_port_read(space->machine, "TRACKX2") & 0xff) << 8;
}
static READ16_HANDLER( trackx2_hi_r )
{
return input_port_read(space->machine, "TRACKY2");
}
static READ16_HANDLER( trackx2_lo_r )
{
return (input_port_read(space->machine, "TRACKY2") & 0xff) <<8;
return (input_port_read(space->machine, "TRACKY2") & 0xff) << 8;
}
static WRITE16_HANDLER( gain_control_w )
{
const device_config *mb87078 = devtag_get_device(space->machine, "mb87078");
taitob_state *state = (taitob_state *)space->machine->driver_data;
if (ACCESSING_BITS_8_15)
{
if (offset == 0)
{
mb87078_data_w(mb87078, data >> 8, 0);
mb87078_data_w(state->mb87078, data >> 8, 0);
//logerror("MB87078 dsel=0 data=%4x\n", data);
}
else
{
mb87078_data_w(mb87078, data >> 8, 1);
mb87078_data_w(state->mb87078, data >> 8, 1);
//logerror("MB87078 dsel=1 data=%4x\n", data);
}
}
@ -371,16 +388,17 @@ static const eeprom_interface taitob_eeprom_intf =
"0100110000" /* unlock command*/
};
static UINT16 eep_latch = 0;
static READ16_HANDLER( eep_latch_r )
{
return eep_latch;
taitob_state *state = (taitob_state *)space->machine->driver_data;
return state->eep_latch;
}
static WRITE16_HANDLER( eeprom_w )
{
COMBINE_DATA(&eep_latch);
taitob_state *state = (taitob_state *)space->machine->driver_data;
COMBINE_DATA(&state->eep_latch);
if (ACCESSING_BITS_8_15)
{
@ -410,53 +428,55 @@ static WRITE16_HANDLER( eeprom_w )
*************************************************************************/
static UINT16 coin_word=0;
static READ16_HANDLER( player_34_coin_ctrl_r )
{
return coin_word;
taitob_state *state = (taitob_state *)space->machine->driver_data;
return state->coin_word;
}
static WRITE16_HANDLER( player_34_coin_ctrl_w )
{
COMBINE_DATA(&coin_word);
taitob_state *state = (taitob_state *)space->machine->driver_data;
COMBINE_DATA(&state->coin_word);
/* coin counters and lockout */
coin_lockout_w(space->machine, 2,~data & 0x0100);
coin_lockout_w(space->machine, 3,~data & 0x0200);
coin_counter_w(space->machine, 2, data & 0x0400);
coin_counter_w(space->machine, 3, data & 0x0800);
coin_lockout_w(space->machine, 2, ~data & 0x0100);
coin_lockout_w(space->machine, 3, ~data & 0x0200);
coin_counter_w(space->machine, 2, data & 0x0400);
coin_counter_w(space->machine, 3, data & 0x0800);
}
static READ16_HANDLER( pbobble_input_bypass_r )
{
const device_config *tc0640fio = devtag_get_device(space->machine, "tc0640fio");
taitob_state *state = (taitob_state *)space->machine->driver_data;
switch (offset)
{
case 0x01:
return input_port_read(space->machine, "COIN") << 8;
default:
return tc0640fio_r(tc0640fio, offset) << 8;
return tc0640fio_r(state->tc0640fio, offset) << 8;
}
}
static WRITE16_HANDLER( spacedxo_tc0220ioc_w )
{
const device_config *tc0220ioc = devtag_get_device(space->machine, "tc0220ioc");
taitob_state *state = (taitob_state *)space->machine->driver_data;
if (ACCESSING_BITS_0_7)
tc0220ioc_w(tc0220ioc, offset, data & 0xff);
tc0220ioc_w(state->tc0220ioc, offset, data & 0xff);
else
{
/* spacedxo also writes here - bug? */
tc0220ioc_w(tc0220ioc, offset, (data >> 8) & 0xff);
tc0220ioc_w(state->tc0220ioc, offset, (data >> 8) & 0xff);
}
}
#define TC0180VCU_MEMRW( ADDR ) \
AM_RANGE(ADDR+0x00000, ADDR+0x0ffff) AM_DEVREADWRITE("tc0180vcu", tc0180vcu_word_r, tc0180vcu_word_w) \
AM_RANGE(ADDR+0x10000, ADDR+0x1197f) AM_RAM AM_BASE(&taitob_spriteram) \
AM_RANGE(ADDR+0x10000, ADDR+0x1197f) AM_RAM AM_BASE_MEMBER(taitob_state, spriteram) \
AM_RANGE(ADDR+0x11980, ADDR+0x137ff) AM_RAM \
AM_RANGE(ADDR+0x13800, ADDR+0x13fff) AM_DEVREADWRITE("tc0180vcu", tc0180vcu_scroll_r, tc0180vcu_scroll_w) \
AM_RANGE(ADDR+0x18000, ADDR+0x1801f) AM_DEVREADWRITE("tc0180vcu", tc0180vcu_ctrl_r, tc0180vcu_ctrl_w) \
@ -516,7 +536,7 @@ static ADDRESS_MAP_START( hitice_map, ADDRESS_SPACE_PROGRAM, 16 )
AM_RANGE(0x700002, 0x700003) AM_DEVREADWRITE8("tc0140syt", tc0140syt_comm_r, tc0140syt_comm_w, 0xff00)
AM_RANGE(0x800000, 0x803fff) AM_RAM /* Main RAM */
AM_RANGE(0xa00000, 0xa01fff) AM_RAM_WRITE(paletteram16_RRRRGGGGBBBBxxxx_word_w) AM_BASE_GENERIC(paletteram)
AM_RANGE(0xb00000, 0xb7ffff) AM_RAM_WRITE(hitice_pixelram_w) AM_BASE(&taitob_pixelram)
AM_RANGE(0xb00000, 0xb7ffff) AM_RAM_WRITE(hitice_pixelram_w) AM_BASE_MEMBER(taitob_state, pixelram)
// { 0xbffff0, 0xbffff1, ???
AM_RANGE(0xbffff2, 0xbffff5) AM_WRITE(hitice_pixel_scroll_w)
// { 0xbffffa, 0xbffffb, ???
@ -2069,9 +2089,10 @@ GFXDECODE_END
/* handler called by the YM2610 emulator when the internal timers cause an IRQ */
static void irqhandler(const device_config *device, int irq)
static void irqhandler( const device_config *device, int irq )
{
cputag_set_input_line(device->machine, "audiocpu", 0, irq ? ASSERT_LINE : CLEAR_LINE);
taitob_state *state = (taitob_state *)device->machine->driver_data;
cpu_set_input_line(state->audiocpu, 0, irq ? ASSERT_LINE : CLEAR_LINE);
}
static const ym2610_interface ym2610_config =
@ -2105,12 +2126,13 @@ static const ym2203_interface ym2203_config =
*/
static void mb87078_gain_changed( running_machine *machine, int channel, int percent )
{
taitob_state *state = (taitob_state *)machine->driver_data;
if (channel == 1)
{
const device_config *ym = devtag_get_device(machine, "ymsnd");
sound_set_output_gain(ym, 0, percent / 100.0);
sound_set_output_gain(ym, 1, percent / 100.0);
sound_set_output_gain(ym, 2, percent / 100.0);
sound_set_output_gain(state->ym, 0, percent / 100.0);
sound_set_output_gain(state->ym, 1, percent / 100.0);
sound_set_output_gain(state->ym, 2, percent / 100.0);
//popmessage("MB87078 gain ch#%i percent=%i", channel, percent);
}
}
@ -2168,8 +2190,35 @@ static const tc0140syt_interface taitob_tc0140syt_intf =
"maincpu", "audiocpu"
};
static MACHINE_START( taitob )
{
taitob_state *state = (taitob_state *)machine->driver_data;
state->maincpu = devtag_get_device(machine, "maincpu");
state->audiocpu = devtag_get_device(machine, "audiocpu");
state->mb87078 = devtag_get_device(machine, "mb87078");
state->ym = devtag_get_device(machine, "ymsnd");
state->tc0180vcu = devtag_get_device(machine, "tc0180vcu");
state->tc0640fio = devtag_get_device(machine, "tc0640fio");
state->tc0220ioc = devtag_get_device(machine, "tc0220ioc");
state_save_register_global(machine, state->eep_latch);
state_save_register_global(machine, state->coin_word);
}
static MACHINE_RESET( taitob )
{
taitob_state *state = (taitob_state *)machine->driver_data;
state->eep_latch = 0;
state->coin_word = 0;
}
static MACHINE_DRIVER_START( rastsag2 )
/* driver data */
MDRV_DRIVER_DATA(taitob_state)
/* basic machine hardware */
MDRV_CPU_ADD("maincpu", M68000, 12000000) /* 12 MHz */
MDRV_CPU_PROGRAM_MAP(rastsag2_map)
@ -2180,6 +2229,9 @@ static MACHINE_DRIVER_START( rastsag2 )
MDRV_QUANTUM_TIME(HZ(600))
MDRV_MACHINE_START(taitob)
MDRV_MACHINE_RESET(taitob)
MDRV_TC0220IOC_ADD("tc0220ioc", taitob_io_intf)
/* video hardware */
@ -2214,6 +2266,9 @@ MACHINE_DRIVER_END
static MACHINE_DRIVER_START( ashura )
/* driver data */
MDRV_DRIVER_DATA(taitob_state)
/* basic machine hardware */
MDRV_CPU_ADD("maincpu", M68000, 12000000) /* 12 MHz */
MDRV_CPU_PROGRAM_MAP(rastsag2_map)
@ -2224,6 +2279,9 @@ static MACHINE_DRIVER_START( ashura )
MDRV_QUANTUM_TIME(HZ(600))
MDRV_MACHINE_START(taitob)
MDRV_MACHINE_RESET(taitob)
MDRV_TC0220IOC_ADD("tc0220ioc", taitob_io_intf)
/* video hardware */
@ -2258,6 +2316,9 @@ MACHINE_DRIVER_END
static MACHINE_DRIVER_START( crimec )
/* driver data */
MDRV_DRIVER_DATA(taitob_state)
/* basic machine hardware */
MDRV_CPU_ADD("maincpu", M68000, 12000000) /* 12 MHz */
MDRV_CPU_PROGRAM_MAP(crimec_map)
@ -2268,6 +2329,9 @@ static MACHINE_DRIVER_START( crimec )
MDRV_QUANTUM_TIME(HZ(600))
MDRV_MACHINE_START(taitob)
MDRV_MACHINE_RESET(taitob)
MDRV_TC0220IOC_ADD("tc0220ioc", taitob_io_intf)
/* video hardware */
@ -2302,6 +2366,9 @@ MACHINE_DRIVER_END
static MACHINE_DRIVER_START( tetrist )
/* driver data */
MDRV_DRIVER_DATA(taitob_state)
/* basic machine hardware */
MDRV_CPU_ADD("maincpu", M68000, 12000000) /* 12 MHz ???*/
MDRV_CPU_PROGRAM_MAP(tetrist_map)
@ -2312,6 +2379,9 @@ static MACHINE_DRIVER_START( tetrist )
MDRV_QUANTUM_TIME(HZ(600))
MDRV_MACHINE_START(taitob)
MDRV_MACHINE_RESET(taitob)
MDRV_TC0220IOC_ADD("tc0220ioc", taitob_io_intf)
/* video hardware */
@ -2345,6 +2415,9 @@ MACHINE_DRIVER_END
static MACHINE_DRIVER_START( tetrista )
/* driver data */
MDRV_DRIVER_DATA(taitob_state)
/* basic machine hardware */
MDRV_CPU_ADD("maincpu", M68000, 12000000) /* 12 MHz */
MDRV_CPU_PROGRAM_MAP(tetrista_map)
@ -2355,6 +2428,9 @@ static MACHINE_DRIVER_START( tetrista )
MDRV_QUANTUM_TIME(HZ(600))
MDRV_MACHINE_START(taitob)
MDRV_MACHINE_RESET(taitob)
MDRV_TC0220IOC_ADD("tc0220ioc", taitob_io_intf)
/* video hardware */
@ -2389,6 +2465,9 @@ MACHINE_DRIVER_END
static MACHINE_DRIVER_START( hitice )
/* driver data */
MDRV_DRIVER_DATA(taitob_state)
/* basic machine hardware */
MDRV_CPU_ADD("maincpu", M68000, 12000000) /* 12 MHz */
MDRV_CPU_PROGRAM_MAP(hitice_map)
@ -2399,6 +2478,9 @@ static MACHINE_DRIVER_START( hitice )
MDRV_QUANTUM_TIME(HZ(600))
MDRV_MACHINE_START(taitob)
MDRV_MACHINE_RESET(taitob)
MDRV_TC0220IOC_ADD("tc0220ioc", taitob_io_intf)
/* video hardware */
@ -2439,6 +2521,9 @@ MACHINE_DRIVER_END
static MACHINE_DRIVER_START( rambo3 )
/* driver data */
MDRV_DRIVER_DATA(taitob_state)
/* basic machine hardware */
MDRV_CPU_ADD("maincpu", M68000, XTAL_24MHz/2) /* verified on pcb */
MDRV_CPU_PROGRAM_MAP(rambo3_map)
@ -2449,6 +2534,9 @@ static MACHINE_DRIVER_START( rambo3 )
MDRV_QUANTUM_TIME(HZ(600))
MDRV_MACHINE_START(taitob)
MDRV_MACHINE_RESET(taitob)
MDRV_TC0220IOC_ADD("tc0220ioc", taitob_io_intf)
/* video hardware */
@ -2483,6 +2571,9 @@ MACHINE_DRIVER_END
static MACHINE_DRIVER_START( rambo3a )
/* driver data */
MDRV_DRIVER_DATA(taitob_state)
/* basic machine hardware */
MDRV_CPU_ADD("maincpu", M68000, XTAL_24MHz/2) /* verified on pcb */
MDRV_CPU_PROGRAM_MAP(rambo3_map)
@ -2493,6 +2584,9 @@ static MACHINE_DRIVER_START( rambo3a )
MDRV_QUANTUM_TIME(HZ(600))
MDRV_MACHINE_START(taitob)
MDRV_MACHINE_RESET(taitob)
MDRV_TC0220IOC_ADD("tc0220ioc", taitob_io_intf)
/* video hardware */
@ -2526,6 +2620,9 @@ MACHINE_DRIVER_END
static MACHINE_DRIVER_START( pbobble )
/* driver data */
MDRV_DRIVER_DATA(taitob_state)
/* basic machine hardware */
MDRV_CPU_ADD("maincpu", M68000, 12000000) /* 12 MHz */
MDRV_CPU_PROGRAM_MAP(pbobble_map)
@ -2534,6 +2631,9 @@ static MACHINE_DRIVER_START( pbobble )
MDRV_CPU_ADD("audiocpu", Z80, 4000000) /* 4 MHz */
MDRV_CPU_PROGRAM_MAP(sound_map)
MDRV_MACHINE_START(taitob)
MDRV_MACHINE_RESET(taitob)
MDRV_QUANTUM_TIME(HZ(600))
MDRV_EEPROM_ADD("eeprom", taitob_eeprom_intf)
@ -2574,6 +2674,9 @@ MACHINE_DRIVER_END
static MACHINE_DRIVER_START( spacedx )
/* driver data */
MDRV_DRIVER_DATA(taitob_state)
/* basic machine hardware */
MDRV_CPU_ADD("maincpu", M68000, 12000000) /* 12 MHz */
MDRV_CPU_PROGRAM_MAP(spacedx_map)
@ -2584,6 +2687,9 @@ static MACHINE_DRIVER_START( spacedx )
MDRV_QUANTUM_TIME(HZ(600))
MDRV_MACHINE_START(taitob)
MDRV_MACHINE_RESET(taitob)
MDRV_EEPROM_ADD("eeprom", taitob_eeprom_intf)
MDRV_TC0640FIO_ADD("tc0640fio", pbobble_io_intf)
@ -2622,6 +2728,9 @@ MACHINE_DRIVER_END
static MACHINE_DRIVER_START( spacedxo )
/* driver data */
MDRV_DRIVER_DATA(taitob_state)
/* basic machine hardware */
MDRV_CPU_ADD("maincpu", M68000, 12000000) /* 12 MHz */
MDRV_CPU_PROGRAM_MAP(spacedxo_map)
@ -2632,6 +2741,9 @@ static MACHINE_DRIVER_START( spacedxo )
MDRV_QUANTUM_TIME(HZ(600))
MDRV_MACHINE_START(taitob)
MDRV_MACHINE_RESET(taitob)
MDRV_TC0220IOC_ADD("tc0220ioc", taitob_io_intf)
/* video hardware */
@ -2666,6 +2778,9 @@ MACHINE_DRIVER_END
static MACHINE_DRIVER_START( qzshowby )
/* driver data */
MDRV_DRIVER_DATA(taitob_state)
/* basic machine hardware */
MDRV_CPU_ADD("maincpu", M68000, 16000000) /* 16 MHz according to the readme*/
MDRV_CPU_PROGRAM_MAP(qzshowby_map)
@ -2676,6 +2791,9 @@ static MACHINE_DRIVER_START( qzshowby )
MDRV_QUANTUM_TIME(HZ(600))
MDRV_MACHINE_START(taitob)
MDRV_MACHINE_RESET(taitob)
MDRV_EEPROM_ADD("eeprom", taitob_eeprom_intf)
MDRV_TC0640FIO_ADD("tc0640fio", pbobble_io_intf)
@ -2714,6 +2832,9 @@ MACHINE_DRIVER_END
static MACHINE_DRIVER_START( viofight )
/* driver data */
MDRV_DRIVER_DATA(taitob_state)
/* basic machine hardware */
MDRV_CPU_ADD("maincpu", M68000, 12000000) /* 12 MHz */
MDRV_CPU_PROGRAM_MAP(viofight_map)
@ -2724,6 +2845,9 @@ static MACHINE_DRIVER_START( viofight )
MDRV_QUANTUM_TIME(HZ(600))
MDRV_MACHINE_START(taitob)
MDRV_MACHINE_RESET(taitob)
MDRV_TC0220IOC_ADD("tc0220ioc", taitob_io_intf)
/* video hardware */
@ -2762,6 +2886,9 @@ MACHINE_DRIVER_END
static MACHINE_DRIVER_START( masterw )
/* driver data */
MDRV_DRIVER_DATA(taitob_state)
/* basic machine hardware */
MDRV_CPU_ADD("maincpu", M68000, 12000000) /* 12 MHz */
MDRV_CPU_PROGRAM_MAP(masterw_map)
@ -2772,6 +2899,9 @@ static MACHINE_DRIVER_START( masterw )
MDRV_QUANTUM_TIME(HZ(600))
MDRV_MACHINE_START(taitob)
MDRV_MACHINE_RESET(taitob)
MDRV_TC0220IOC_ADD("tc0220ioc", taitob_io_intf)
/* video hardware */
@ -2807,6 +2937,9 @@ MACHINE_DRIVER_END
static MACHINE_DRIVER_START( silentd )
/* driver data */
MDRV_DRIVER_DATA(taitob_state)
/* basic machine hardware */
MDRV_CPU_ADD("maincpu", M68000, 16000000) /* 16 MHz ??? */
MDRV_CPU_PROGRAM_MAP(silentd_map)
@ -2817,6 +2950,9 @@ static MACHINE_DRIVER_START( silentd )
MDRV_QUANTUM_TIME(HZ(600))
MDRV_MACHINE_START(taitob)
MDRV_MACHINE_RESET(taitob)
MDRV_TC0220IOC_ADD("tc0220ioc", taitob_io_intf)
/* video hardware */
@ -2851,6 +2987,9 @@ MACHINE_DRIVER_END
static MACHINE_DRIVER_START( selfeena )
/* driver data */
MDRV_DRIVER_DATA(taitob_state)
/* basic machine hardware */
MDRV_CPU_ADD("maincpu", M68000, 12000000) /* 12 MHz */
MDRV_CPU_PROGRAM_MAP(selfeena_map)
@ -2861,6 +3000,9 @@ static MACHINE_DRIVER_START( selfeena )
MDRV_QUANTUM_TIME(HZ(600))
MDRV_MACHINE_START(taitob)
MDRV_MACHINE_RESET(taitob)
MDRV_TC0220IOC_ADD("tc0220ioc", taitob_io_intf)
/* video hardware */
@ -2904,6 +3046,9 @@ static void ryujin_patch(void)
static MACHINE_DRIVER_START( ryujin )
/* driver data */
MDRV_DRIVER_DATA(taitob_state)
/* basic machine hardware */
MDRV_CPU_ADD("maincpu", M68000, 12000000) /* 12 MHz */
MDRV_CPU_PROGRAM_MAP(selfeena_map)
@ -2914,6 +3059,9 @@ static MACHINE_DRIVER_START( ryujin )
MDRV_QUANTUM_TIME(HZ(600))
MDRV_MACHINE_START(taitob)
MDRV_MACHINE_RESET(taitob)
MDRV_TC0220IOC_ADD("tc0220ioc", taitob_io_intf)
/* video hardware */
@ -2955,6 +3103,9 @@ static void sbm_patch(void)
static MACHINE_DRIVER_START( sbm )
/* driver data */
MDRV_DRIVER_DATA(taitob_state)
/* basic machine hardware */
MDRV_CPU_ADD("maincpu", M68000, 12000000) /* 12 MHz */
MDRV_CPU_PROGRAM_MAP(sbm_map)
@ -2965,6 +3116,9 @@ static MACHINE_DRIVER_START( sbm )
MDRV_QUANTUM_TIME(HZ(600))
MDRV_MACHINE_START(taitob)
MDRV_MACHINE_RESET(taitob)
MDRV_TC0510NIO_ADD("tc0510nio", sbm_io_intf)
/* video hardware */

145
src/mame/drivers/taitoair.c
View File

@ -219,84 +219,85 @@ cpu #2 (PC=0000060E): unmapped memory word read from 0000683A & FFFF
#include "cpu/z80/z80.h"
#include "cpu/m68000/m68000.h"
#include "includes/taitoipt.h"
#include "includes/taitoair.h"
#include "audio/taitosnd.h"
#include "video/taitoic.h"
#include "machine/taitoio.h"
#include "cpu/tms32025/tms32025.h"
#include "sound/2610intf.h"
static int dsp_HOLD_signal;
static UINT16 *taitoh_68000_mainram;
UINT16 *taitoair_line_ram;
static UINT16 *dsp_ram; /* Shared 68000/TMS32025 RAM */
VIDEO_UPDATE( taitoair );
/***********************************************************
MEMORY handlers
***********************************************************/
static WRITE16_HANDLER( system_control_w )
{
taitoair_state *state = (taitoair_state *)space->machine->driver_data;
if ((ACCESSING_BITS_0_7 == 0) && ACCESSING_BITS_8_15)
{
data >>= 8;
}
dsp_HOLD_signal = (data & 4) ? CLEAR_LINE : ASSERT_LINE;
state->dsp_hold_signal = (data & 4) ? CLEAR_LINE : ASSERT_LINE;
cputag_set_input_line(space->machine, "dsp", INPUT_LINE_RESET, (data & 1) ? CLEAR_LINE : ASSERT_LINE);
cpu_set_input_line(state->dsp, INPUT_LINE_RESET, (data & 1) ? CLEAR_LINE : ASSERT_LINE);
logerror("68K:%06x writing %04x to TMS32025. %s HOLD , %s RESET\n", cpu_get_previouspc(space->cpu), data, ((data & 4) ? "Clear" : "Assert"), ((data & 1) ? "Clear" : "Assert"));
}
static READ16_HANDLER( lineram_r )
{
return taitoair_line_ram[offset];
taitoair_state *state = (taitoair_state *)space->machine->driver_data;
return state->line_ram[offset];
}
static WRITE16_HANDLER( lineram_w )
{
taitoair_state *state = (taitoair_state *)space->machine->driver_data;
if (ACCESSING_BITS_8_15 && ACCESSING_BITS_0_7)
taitoair_line_ram[offset] = data;
state->line_ram[offset] = data;
}
static READ16_HANDLER( dspram_r )
{
return dsp_ram[offset];
taitoair_state *state = (taitoair_state *)space->machine->driver_data;
return state->dsp_ram[offset];
}
static WRITE16_HANDLER( dspram_w )
{
taitoair_state *state = (taitoair_state *)space->machine->driver_data;
if (ACCESSING_BITS_8_15 && ACCESSING_BITS_0_7)
dsp_ram[offset] = data;
state->dsp_ram[offset] = data;
}
static READ16_HANDLER( dsp_HOLD_signal_r )
{
/* HOLD signal is active low */
// logerror("TMS32025:%04x Reading %01x level from HOLD signal\n",cpu_get_previouspc(space->cpu),dsp_HOLD_signal);
taitoair_state *state = (taitoair_state *)space->machine->driver_data;
return dsp_HOLD_signal;
/* HOLD signal is active low */
// logerror("TMS32025:%04x Reading %01x level from HOLD signal\n", cpu_get_previouspc(space->cpu), state->dsp_hold_signal);
return state->dsp_hold_signal;
}
static WRITE16_HANDLER( dsp_HOLDA_signal_w )
{
if (offset)
logerror("TMS32025:%04x Writing %01x level to HOLD-Acknowledge signal\n",cpu_get_previouspc(space->cpu),data);
logerror("TMS32025:%04x Writing %01x level to HOLD-Acknowledge signal\n", cpu_get_previouspc(space->cpu), data);
}
static WRITE16_HANDLER( airsys_paletteram16_w ) /* xxBBBBxRRRRxGGGG */
{
taitoair_state *state = (taitoair_state *)space->machine->driver_data;
int a;
COMBINE_DATA(&space->machine->generic.paletteram.u16[offset]);
a = space->machine->generic.paletteram.u16[offset];
palette_set_color_rgb(space->machine,offset,pal4bit(a >> 0),pal4bit(a >> 5),pal4bit(a >> 10));
COMBINE_DATA(&state->paletteram[offset]);
a = state->paletteram[offset];
palette_set_color_rgb(space->machine, offset, pal4bit(a >> 0), pal4bit(a >> 5), pal4bit(a >> 10));
}
@ -343,33 +344,21 @@ static READ16_HANDLER( stick2_input_r )
}
static INT32 banknum;
static void reset_sound_region(running_machine *machine)
static void reset_sound_region( running_machine *machine )
{
memory_set_bankptr(machine, "bank1", memory_region(machine, "audiocpu") + (banknum * 0x4000) + 0x10000);
taitoair_state *state = (taitoair_state *)machine->driver_data;
memory_set_bank(machine, "bank1", state->banknum);
}
static WRITE8_HANDLER( sound_bankswitch_w )
{
banknum = (data - 1) & 3;
taitoair_state *state = (taitoair_state *)space->machine->driver_data;
state->banknum = (data - 1) & 3;
reset_sound_region(space->machine);
}
static STATE_POSTLOAD( taitoair_postload )
{
reset_sound_region(machine);
}
static MACHINE_START( taitoair )
{
dsp_HOLD_signal = ASSERT_LINE;
banknum = -1;
state_save_register_global(machine, banknum);
state_save_register_postload(machine, taitoair_postload, NULL);
}
/***********************************************************
MEMORY STRUCTURES
@ -377,14 +366,14 @@ static MACHINE_START( taitoair )
static ADDRESS_MAP_START( airsys_map, ADDRESS_SPACE_PROGRAM, 16 )
AM_RANGE(0x000000, 0x0bffff) AM_ROM
AM_RANGE(0x0c0000, 0x0cffff) AM_RAM AM_BASE(&taitoh_68000_mainram)
AM_RANGE(0x0c0000, 0x0cffff) AM_RAM AM_BASE_MEMBER(taitoair_state, m68000_mainram)
AM_RANGE(0x140000, 0x140001) AM_WRITE(system_control_w) /* Pause the TMS32025 */
AM_RANGE(0x180000, 0x183fff) AM_RAM /* "gradiation ram (0)" */
AM_RANGE(0x184000, 0x187fff) AM_RAM /* "gradiation ram (1)" */
AM_RANGE(0x188000, 0x18bfff) AM_RAM_WRITE(airsys_paletteram16_w) AM_BASE_GENERIC(paletteram)
AM_RANGE(0x188000, 0x18bfff) AM_RAM_WRITE(airsys_paletteram16_w) AM_BASE_MEMBER(taitoair_state, paletteram)
AM_RANGE(0x800000, 0x820fff) AM_DEVREADWRITE("tc0080vco", tc0080vco_word_r, tc0080vco_word_w) /* tilemaps, sprites */
AM_RANGE(0x908000, 0x90ffff) AM_RAM AM_BASE(&taitoair_line_ram) /* "line ram" */
AM_RANGE(0x910000, 0x91ffff) AM_RAM AM_BASE(&dsp_ram) /* "dsp common ram" (TMS320C25) */
AM_RANGE(0x908000, 0x90ffff) AM_RAM AM_BASE_MEMBER(taitoair_state, line_ram) /* "line ram" */
AM_RANGE(0x910000, 0x91ffff) AM_RAM AM_BASE_MEMBER(taitoair_state, dsp_ram) /* "dsp common ram" (TMS320C25) */
AM_RANGE(0xa00000, 0xa00007) AM_READ(stick_input_r)
AM_RANGE(0xa00100, 0xa00107) AM_READ(stick2_input_r)
AM_RANGE(0xa00200, 0xa0020f) AM_DEVREADWRITE8("tc0220ioc", tc0220ioc_r, tc0220ioc_w, 0x00ff) /* other I/O */
@ -580,9 +569,10 @@ GFXDECODE_END
************************************************************/
/* Handler called by the YM2610 emulator when the internal timers cause an IRQ */
static void irqhandler(const device_config *device, int irq)
static void irqhandler( const device_config *device, int irq )
{
cputag_set_input_line(device->machine, "audiocpu", 0, irq ? ASSERT_LINE : CLEAR_LINE);
taitoair_state *state = (taitoair_state *)device->machine->driver_data;
cpu_set_input_line(state->audiocpu, 0, irq ? ASSERT_LINE : CLEAR_LINE);
}
static const ym2610_interface airsys_ym2610_interface =
@ -613,8 +603,64 @@ static const tc0140syt_interface airsys_tc0140syt_intf =
"maincpu", "audiocpu"
};
static STATE_POSTLOAD( taitoair_postload )
{
reset_sound_region(machine);
}
static MACHINE_START( taitoair )
{
taitoair_state *state = (taitoair_state *)machine->driver_data;
UINT8 *ROM = memory_region(machine, "audiocpu");
int i;
memory_configure_bank(machine, "bank1", 0, 3, &ROM[0x10000], 0x4000);
state->audiocpu = devtag_get_device(machine, "audiocpu");
state->dsp = devtag_get_device(machine, "dsp");
state->tc0080vco = devtag_get_device(machine, "tc0080vco");
state_save_register_global(machine, state->banknum);
state_save_register_global(machine, state->view.x1);
state_save_register_global(machine, state->view.y1);
state_save_register_global(machine, state->view.x2);
state_save_register_global(machine, state->view.y2);
state_save_register_global(machine, state->q.col);
state_save_register_global(machine, state->q.pcount);
for (i = 0; i < TAITOAIR_POLY_MAX_PT; i++)
{
state_save_register_item(machine, "globals", NULL, i, state->q.p[i].x);
state_save_register_item(machine, "globals", NULL, i, state->q.p[i].y);
}
state_save_register_postload(machine, taitoair_postload, NULL);
}
static MACHINE_RESET( taitoair )
{
taitoair_state *state = (taitoair_state *)machine->driver_data;
int i;
state->dsp_hold_signal = ASSERT_LINE;
state->banknum = -1;
state->view.x1 = 0;
state->view.y1 = 0;
state->view.x2 = 0;
state->view.y2 = 0;
for (i = 0; i < TAITOAIR_POLY_MAX_PT; i++)
{
state->q.p[i].x = 0;
state->q.p[i].y = 0;
}
}
static MACHINE_DRIVER_START( airsys )
/* driver data */
MDRV_DRIVER_DATA(taitoair_state)
/* basic machine hardware */
MDRV_CPU_ADD("maincpu", M68000,24000000 / 2) /* 12 MHz ??? */
MDRV_CPU_PROGRAM_MAP(airsys_map)
@ -631,6 +677,7 @@ static MACHINE_DRIVER_START( airsys )
MDRV_QUANTUM_TIME(HZ(600))
MDRV_MACHINE_START(taitoair)
MDRV_MACHINE_RESET(taitoair)
MDRV_TC0220IOC_ADD("tc0220ioc", airsys_io_intf)

57
src/mame/includes/taito_b.h
View File

@ -1,20 +1,51 @@
typedef struct _taitob_state taitob_state;
struct _taitob_state
{
/* memory pointers */
UINT16 * spriteram;
UINT16 * pixelram;
// UINT16 * paletteram; // this currently uses generic palette handlers
/* video-related */
/* framebuffer is a raw bitmap, remapped as a last step */
bitmap_t *framebuffer[2], *pixel_bitmap;
UINT16 pixel_scroll[2];
int b_fg_color_base;
int b_sp_color_base;
/* misc */
UINT16 eep_latch;
UINT16 coin_word;
/* devices */
const device_config *maincpu;
const device_config *audiocpu;
const device_config *mb87078;
const device_config *ym;
const device_config *tc0180vcu;
const device_config *tc0640fio;
const device_config *tc0220ioc;
};
/*----------- defined in video/taito_b.c -----------*/
extern UINT16 *taitob_spriteram;
extern UINT16 *taitob_pixelram;
VIDEO_START( taitob_color_order0 );
VIDEO_START( taitob_color_order1 );
VIDEO_START( taitob_color_order2 );
VIDEO_START( hitice );
VIDEO_EOF( taitob );
VIDEO_RESET( hitice );
VIDEO_UPDATE( taitob );
READ16_HANDLER( tc0180vcu_framebuffer_word_r );
WRITE16_HANDLER( tc0180vcu_framebuffer_word_w );
WRITE16_HANDLER( hitice_pixelram_w );
WRITE16_HANDLER( hitice_pixel_scroll_w );
VIDEO_START( taitob_color_order0 );
VIDEO_START( taitob_color_order1 );
VIDEO_START( taitob_color_order2 );
VIDEO_START( hitice );
VIDEO_RESET( hitice );
VIDEO_UPDATE( taitob );
VIDEO_EOF( taitob );

49
src/mame/includes/taitoair.h Normal file
View File

@ -0,0 +1,49 @@
/*************************************************************************
Taito Air System
*************************************************************************/
enum { TAITOAIR_FRAC_SHIFT = 16, TAITOAIR_POLY_MAX_PT = 16 };
struct taitoair_spoint {
INT32 x, y;
};
struct taitoair_poly {
struct taitoair_spoint p[TAITOAIR_POLY_MAX_PT];
int pcount;
int col;
};
typedef struct _taitoair_state taitoair_state;
struct _taitoair_state
{
/* memory pointers */
UINT16 * m68000_mainram;
UINT16 * line_ram;
UINT16 * dsp_ram; /* Shared 68000/TMS32025 RAM */
UINT16 * paletteram;
/* video-related */
struct {
int x1, y1, x2, y2;
} view;
taitoair_poly q;
/* misc */
int dsp_hold_signal;
INT32 banknum;
/* devices */
const device_config *audiocpu;
const device_config *dsp;
const device_config *tc0080vco;
};
/*----------- defined in video/taitoair.c -----------*/
VIDEO_UPDATE( taitoair );

151
src/mame/video/taito_b.c
View File

@ -3,35 +3,26 @@
#include "video/taitoic.h"
#include "includes/taito_b.h"
UINT16 *taitob_spriteram;
UINT16 *taitob_pixelram;
/* framebuffer is a raw bitmap, remapped as a last step */
static bitmap_t *framebuffer[2],*pixel_bitmap;
static UINT16 pixel_scroll[2];
static int b_fg_color_base = 0;
static int b_sp_color_base = 0;
WRITE16_HANDLER( hitice_pixelram_w )
{
taitob_state *state = (taitob_state *)space->machine->driver_data;
int sy = offset >> 9;
int sx = offset & 0x1ff;
COMBINE_DATA(&taitob_pixelram[offset]);
COMBINE_DATA(&state->pixelram[offset]);
if (ACCESSING_BITS_0_7)
{
/* bit 15 of pixel_scroll[0] is probably flip screen */
*BITMAP_ADDR16(pixel_bitmap, sy, 2 * sx + 0) = b_fg_color_base * 16 + (data & 0xff);
*BITMAP_ADDR16(pixel_bitmap, sy, 2 * sx + 1) = b_fg_color_base * 16 + (data & 0xff);
*BITMAP_ADDR16(state->pixel_bitmap, sy, 2 * sx + 0) = state->b_fg_color_base * 16 + (data & 0xff);
*BITMAP_ADDR16(state->pixel_bitmap, sy, 2 * sx + 1) = state->b_fg_color_base * 16 + (data & 0xff);
}
}
WRITE16_HANDLER( hitice_pixel_scroll_w )
{
COMBINE_DATA(&pixel_scroll[offset]);
taitob_state *state = (taitob_state *)space->machine->driver_data;
COMBINE_DATA(&state->pixel_scroll[offset]);
}
static void hitice_clear_pixel_bitmap( running_machine *machine )
@ -46,14 +37,16 @@ static void hitice_clear_pixel_bitmap( running_machine *machine )
static VIDEO_START( taitob_core )
{
framebuffer[0] = auto_bitmap_alloc(machine, 512, 256, video_screen_get_format(machine->primary_screen));
framebuffer[1] = auto_bitmap_alloc(machine, 512, 256, video_screen_get_format(machine->primary_screen));
pixel_bitmap = NULL; /* only hitice needs this */
taitob_state *state = (taitob_state *)machine->driver_data;
state_save_register_global_array(machine, pixel_scroll);
state->framebuffer[0] = auto_bitmap_alloc(machine, 512, 256, video_screen_get_format(machine->primary_screen));
state->framebuffer[1] = auto_bitmap_alloc(machine, 512, 256, video_screen_get_format(machine->primary_screen));
state->pixel_bitmap = NULL; /* only hitice needs this */
state_save_register_global_bitmap(machine, framebuffer[0]);
state_save_register_global_bitmap(machine, framebuffer[1]);
state_save_register_global_array(machine, state->pixel_scroll);
state_save_register_global_bitmap(machine, state->framebuffer[0]);
state_save_register_global_bitmap(machine, state->framebuffer[1]);
}
VIDEO_START( taitob_color_order0 )
@ -61,11 +54,10 @@ VIDEO_START( taitob_color_order0 )
/*graphics are shared, only that they use different palette*/
/*this is the basic layout used in: Nastar, Ashura Blaster, Hit the Ice, Rambo3, Tetris*/
/*Note that in both this and color order 1
* pixel_color_base/color_granularity is equal to sprites color base.
* Pure coincidence ?*/
/*Note that in both this and color order 1 pixel_color_base/color_granularity is equal to sprites color base. Pure coincidence? */
b_sp_color_base = 0x40 * 16; /*sprites */
taitob_state *state = (taitob_state *)machine->driver_data;
state->b_sp_color_base = 0x40 * 16; /*sprites */
/* bg, fg, tx color_base are set in the tc0180vcu interface */
@ -75,7 +67,8 @@ VIDEO_START( taitob_color_order0 )
VIDEO_START( taitob_color_order1 )
{
/* this is the reversed layout used in: Crime City, Puzzle Bobble */
b_sp_color_base = 0x80 * 16;
taitob_state *state = (taitob_state *)machine->driver_data;
state->b_sp_color_base = 0x80 * 16;
VIDEO_START_CALL(taitob_core);
}
@ -83,7 +76,8 @@ VIDEO_START( taitob_color_order1 )
VIDEO_START( taitob_color_order2 )
{
/*this is used in: rambo3a, masterw, silentd, selfeena, ryujin */
b_sp_color_base = 0x10 * 16;
taitob_state *state = (taitob_state *)machine->driver_data;
state->b_sp_color_base = 0x10 * 16;
VIDEO_START_CALL(taitob_core);
}
@ -91,13 +85,15 @@ VIDEO_START( taitob_color_order2 )
VIDEO_START( hitice )
{
taitob_state *state = (taitob_state *)machine->driver_data;
VIDEO_START_CALL(taitob_color_order0);
b_fg_color_base = 0x80; /* hitice also uses this for the pixel_bitmap */
state->b_fg_color_base = 0x80; /* hitice also uses this for the pixel_bitmap */
pixel_bitmap = auto_bitmap_alloc(machine, 1024, 512, video_screen_get_format(machine->primary_screen));
state->pixel_bitmap = auto_bitmap_alloc(machine, 1024, 512, video_screen_get_format(machine->primary_screen));
state_save_register_global_bitmap(machine, pixel_bitmap);
state_save_register_global_bitmap(machine, state->pixel_bitmap);
}
VIDEO_RESET( hitice )
@ -109,21 +105,23 @@ VIDEO_RESET( hitice )
READ16_HANDLER( tc0180vcu_framebuffer_word_r )
{
taitob_state *state = (taitob_state *)space->machine->driver_data;
int sy = offset >> 8;
int sx = 2*(offset & 0xff);
int sx = 2 * (offset & 0xff);
return (*BITMAP_ADDR16(framebuffer[sy >> 8], sy & 0xff, sx + 0) << 8) | *BITMAP_ADDR16(framebuffer[sy >> 8], sy & 0xff, sx + 1);
return (*BITMAP_ADDR16(state->framebuffer[sy >> 8], sy & 0xff, sx + 0) << 8) | *BITMAP_ADDR16(state->framebuffer[sy >> 8], sy & 0xff, sx + 1);
}
WRITE16_HANDLER( tc0180vcu_framebuffer_word_w )
{
taitob_state *state = (taitob_state *)space->machine->driver_data;
int sy = offset >> 8;
int sx = 2*(offset & 0xff);
int sx = 2 * (offset & 0xff);
if (ACCESSING_BITS_8_15)
*BITMAP_ADDR16(framebuffer[sy >> 8], sy & 0xff, sx + 0) = data >> 8;
*BITMAP_ADDR16(state->framebuffer[sy >> 8], sy & 0xff, sx + 0) = data >> 8;
if (ACCESSING_BITS_0_7)
*BITMAP_ADDR16(framebuffer[sy >> 8], sy & 0xff, sx + 1) = data & 0xff;
*BITMAP_ADDR16(state->framebuffer[sy >> 8], sy & 0xff, sx + 1) = data & 0xff;
}
@ -158,53 +156,54 @@ static void draw_sprites( running_machine *machine, bitmap_t *bitmap, const rect
000c - 000f: unused
*/
taitob_state *state = (taitob_state *)machine->driver_data;
int x, y, xlatch = 0, ylatch = 0, x_no = 0, y_no = 0, x_num = 0, y_num = 0, big_sprite = 0;
int offs, code, color, flipx, flipy;
UINT32 data, zoomx, zoomy, zx, zy, zoomxlatch = 0, zoomylatch = 0;
for (offs = (0x1980-16)/2; offs >=0; offs -= 8)
for (offs = (0x1980 - 16) / 2; offs >=0; offs -= 8)
{
code = taitob_spriteram[offs];
code = state->spriteram[offs];
color = taitob_spriteram[offs + 1];
color = state->spriteram[offs + 1];
flipx = color & 0x4000;
flipy = color & 0x8000;
#if 0
/*check the unknown bits*/
if (color & 0x3fc0)
{
logerror("sprite color (taitob)=%4x ofs=%4x\n",color,offs);
color = rand()&0x3f;
logerror("sprite color (taitob)=%4x ofs=%4x\n", color, offs);
color = rand() & 0x3f;
}
#endif
color = (color & 0x3f) * 16;
x = taitob_spriteram[offs + 2] & 0x3ff;
y = taitob_spriteram[offs + 3] & 0x3ff;
x = state->spriteram[offs + 2] & 0x3ff;
y = state->spriteram[offs + 3] & 0x3ff;
if (x >= 0x200) x -= 0x400;
if (y >= 0x200) y -= 0x400;
data = taitob_spriteram[offs + 5];
data = state->spriteram[offs + 5];
if (data)
{
if (!big_sprite)
{
x_num = (data >> 8) & 0xff;
y_num = (data) & 0xff;
y_num = (data >> 0) & 0xff;
x_no = 0;
y_no = 0;
xlatch = x;
ylatch = y;
data = taitob_spriteram[offs + 4];
data = state->spriteram[offs + 4];
zoomxlatch = (data >> 8) & 0xff;
zoomylatch = (data) & 0xff;
zoomylatch = (data >> 0) & 0xff;
big_sprite = 1;
}
}
data = taitob_spriteram[offs+4];
data = state->spriteram[offs + 4];
zoomx = (data >> 8) & 0xff;
zoomy = (data) & 0xff;
zoomy = (data >> 0) & 0xff;
zx = (0x100 - zoomx) / 16;
zy = (0x100 - zoomy) / 16;
@ -215,8 +214,8 @@ static void draw_sprites( running_machine *machine, bitmap_t *bitmap, const rect
x = xlatch + x_no * (0x100 - zoomx) / 16;
y = ylatch + y_no * (0x100 - zoomy) / 16;
zx = xlatch + (x_no+1) * (0x100 - zoomx) / 16 - x;
zy = ylatch + (y_no+1) * (0x100 - zoomy) / 16 - y;
zx = xlatch + (x_no + 1) * (0x100 - zoomx) / 16 - x;
zy = ylatch + (y_no + 1) * (0x100 - zoomy) / 16 - y;
y_no++;
if (y_no > y_num)
@ -253,11 +252,11 @@ static void draw_sprites( running_machine *machine, bitmap_t *bitmap, const rect
static void draw_framebuffer( running_machine *machine, bitmap_t *bitmap, const rectangle *cliprect, int priority )
{
const device_config *tc0180vcu = devtag_get_device(machine, "tc0180vcu");
taitob_state *state = (taitob_state *)machine->driver_data;
rectangle myclip = *cliprect;
int x, y;
UINT8 video_control = tc0180vcu_get_videoctrl(tc0180vcu, 0);
UINT8 framebuffer_page = tc0180vcu_get_fb_page(tc0180vcu, 0);
UINT8 video_control = tc0180vcu_get_videoctrl(state->tc0180vcu, 0);
UINT8 framebuffer_page = tc0180vcu_get_fb_page(state->tc0180vcu, 0);
profiler_mark_start(PROFILER_USER1);
@ -276,7 +275,7 @@ profiler_mark_start(PROFILER_USER1);
/*popmessage("1. X[%3i;%3i] Y[%3i;%3i]", myclip.min_x, myclip.max_x, myclip.min_y, myclip.max_y);*/
for (y = myclip.min_y; y <= myclip.max_y; y++)
{
UINT16 *src = BITMAP_ADDR16(framebuffer[framebuffer_page], y, myclip.min_x);
UINT16 *src = BITMAP_ADDR16(state->framebuffer[framebuffer_page], y, myclip.min_x);
UINT16 *dst;
dst = BITMAP_ADDR16(bitmap, bitmap->height-1-y, myclip.max_x);
@ -286,7 +285,7 @@ profiler_mark_start(PROFILER_USER1);
UINT16 c = *src++;
if (c != 0)
*dst = b_sp_color_base + c;
*dst = state->b_sp_color_base + c;
dst--;
}
@ -296,7 +295,7 @@ profiler_mark_start(PROFILER_USER1);
{
for (y = myclip.min_y; y <= myclip.max_y; y++)
{
UINT16 *src = BITMAP_ADDR16(framebuffer[framebuffer_page], y, myclip.min_x);
UINT16 *src = BITMAP_ADDR16(state->framebuffer[framebuffer_page], y, myclip.min_x);
UINT16 *dst = BITMAP_ADDR16(bitmap, y, myclip.min_x);
for (x = myclip.min_x; x <= myclip.max_x; x++)
@ -304,7 +303,7 @@ profiler_mark_start(PROFILER_USER1);
UINT16 c = *src++;
if (c != 0)
*dst = b_sp_color_base + c;
*dst = state->b_sp_color_base + c;
dst++;
}
@ -318,7 +317,7 @@ profiler_mark_start(PROFILER_USER1);
/*popmessage("3. X[%3i;%3i] Y[%3i;%3i]", myclip.min_x, myclip.max_x, myclip.min_y, myclip.max_y);*/
for (y = myclip.min_y ;y <= myclip.max_y; y++)
{
UINT16 *src = BITMAP_ADDR16(framebuffer[framebuffer_page], y, myclip.min_x);
UINT16 *src = BITMAP_ADDR16(state->framebuffer[framebuffer_page], y, myclip.min_x);
UINT16 *dst;
dst = BITMAP_ADDR16(bitmap, bitmap->height-1-y, myclip.max_x);
@ -328,7 +327,7 @@ profiler_mark_start(PROFILER_USER1);
UINT16 c = *src++;
if (c != 0 && (c & 0x10) == priority)
*dst = b_sp_color_base + c;
*dst = state->b_sp_color_base + c;
dst--;
}
@ -338,7 +337,7 @@ profiler_mark_start(PROFILER_USER1);
{
for (y = myclip.min_y; y <= myclip.max_y; y++)
{
UINT16 *src = BITMAP_ADDR16(framebuffer[framebuffer_page], y, myclip.min_x);
UINT16 *src = BITMAP_ADDR16(state->framebuffer[framebuffer_page], y, myclip.min_x);
UINT16 *dst = BITMAP_ADDR16(bitmap, y, myclip.min_x);
for (x = myclip.min_x; x <= myclip.max_x; x++)
@ -346,7 +345,7 @@ profiler_mark_start(PROFILER_USER1);
UINT16 c = *src++;
if (c != 0 && (c & 0x10) == priority)
*dst = b_sp_color_base + c;
*dst = state->b_sp_color_base + c;
dst++;
}
@ -358,8 +357,8 @@ profiler_mark_end();
VIDEO_UPDATE( taitob )
{
const device_config *tc0180vcu = devtag_get_device(screen->machine, "tc0180vcu");
UINT8 video_control = tc0180vcu_get_videoctrl(tc0180vcu, 0);
taitob_state *state = (taitob_state *)screen->machine->driver_data;
UINT8 video_control = tc0180vcu_get_videoctrl(state->tc0180vcu, 0);
if ((video_control & 0x20) == 0)
{
@ -368,24 +367,24 @@ VIDEO_UPDATE( taitob )
}
/* Draw playfields */
tc0180vcu_tilemap_draw(tc0180vcu, bitmap, cliprect, 0, 1);
tc0180vcu_tilemap_draw(state->tc0180vcu, bitmap, cliprect, 0, 1);
draw_framebuffer(screen->machine, bitmap, cliprect, 1);
tc0180vcu_tilemap_draw(tc0180vcu, bitmap, cliprect, 1, 0);
tc0180vcu_tilemap_draw(state->tc0180vcu, bitmap, cliprect, 1, 0);
if (pixel_bitmap) /* hitice only */
if (state->pixel_bitmap) /* hitice only */
{
int scrollx = -2 * pixel_scroll[0]; //+320;
int scrolly = - pixel_scroll[1]; //+240;
int scrollx = -2 * state->pixel_scroll[0]; //+320;
int scrolly = - state->pixel_scroll[1]; //+240;
/* bit 15 of pixel_scroll[0] is probably flip screen */
copyscrollbitmap_trans(bitmap, pixel_bitmap, 1, &scrollx, 1, &scrolly, cliprect, b_fg_color_base * 16);
copyscrollbitmap_trans(bitmap, state->pixel_bitmap, 1, &scrollx, 1, &scrolly, cliprect, state->b_fg_color_base * 16);
}
draw_framebuffer(screen->machine, bitmap, cliprect, 0);
tc0180vcu_tilemap_draw(tc0180vcu, bitmap, cliprect, 2, 0);
tc0180vcu_tilemap_draw(state->tc0180vcu, bitmap, cliprect, 2, 0);
return 0;
}
@ -394,18 +393,18 @@ VIDEO_UPDATE( taitob )
VIDEO_EOF( taitob )
{
const device_config *tc0180vcu = devtag_get_device(machine, "tc0180vcu");
UINT8 video_control = tc0180vcu_get_videoctrl(tc0180vcu, 0);
UINT8 framebuffer_page = tc0180vcu_get_fb_page(tc0180vcu, 0);
taitob_state *state = (taitob_state *)machine->driver_data;
UINT8 video_control = tc0180vcu_get_videoctrl(state->tc0180vcu, 0);
UINT8 framebuffer_page = tc0180vcu_get_fb_page(state->tc0180vcu, 0);
if (~video_control & 0x01)
bitmap_fill(framebuffer[framebuffer_page], video_screen_get_visible_area(machine->primary_screen), 0);
bitmap_fill(state->framebuffer[framebuffer_page], video_screen_get_visible_area(machine->primary_screen), 0);
if (~video_control & 0x80)
{
framebuffer_page ^= 1;
tc0180vcu_set_fb_page(tc0180vcu, 0, framebuffer_page);
tc0180vcu_set_fb_page(state->tc0180vcu, 0, framebuffer_page);
}
draw_sprites(machine, framebuffer[framebuffer_page], video_screen_get_visible_area(machine->primary_screen));
draw_sprites(machine, state->framebuffer[framebuffer_page], video_screen_get_visible_area(machine->primary_screen));
}

245
src/mame/video/taitoair.c
View File

@ -46,7 +46,8 @@ sprite RAM
***************************************************************************/
#include "driver.h"
#include "taitoic.h"
#include "video/taitoic.h"
#include "includes/taitoair.h"
/* These are hand-tuned values */
@ -68,12 +69,12 @@ static const int zoomy_conv_table[] =
Screen refresh
***************************************************************************/
static void draw_sprites(running_machine *machine, bitmap_t *bitmap, const rectangle *cliprect, int priority)
static void draw_sprites( running_machine *machine, bitmap_t *bitmap, const rectangle *cliprect, int priority )
{
const device_config *tc0080vco = devtag_get_device(machine, "tc0080vco");
/* Y chain size is 16/32?/64/64? pixels. X chain size
is always 64 pixels. */
taitoair_state *state = (taitoair_state *)machine->driver_data;
static const int size[] = { 1, 2, 4, 4 };
int x0, y0, x, y, dx, dy, ex, ey, zx, zy;
int ysize;
@ -87,12 +88,12 @@ static void draw_sprites(running_machine *machine, bitmap_t *bitmap, const recta
if (offs < 0x01b0 && priority == 0) continue;
if (offs >= 0x01b0 && priority == 1) continue;
x0 = tc0080vco_sprram_r(tc0080vco, offs + 1, 0xffff) & 0x3ff;
y0 = tc0080vco_sprram_r(tc0080vco, offs + 0, 0xffff) & 0x3ff;
zoomx = (tc0080vco_sprram_r(tc0080vco, offs + 2, 0xffff) & 0x7f00) >> 8;
zoomy = (tc0080vco_sprram_r(tc0080vco, offs + 2, 0xffff) & 0x007f);
tile_offs = (tc0080vco_sprram_r(tc0080vco, offs + 3, 0xffff) & 0x1fff) << 2;
ysize = size[(tc0080vco_sprram_r(tc0080vco, offs, 0xffff) & 0x0c00) >> 10];
x0 = tc0080vco_sprram_r(state->tc0080vco, offs + 1, 0xffff) & 0x3ff;
y0 = tc0080vco_sprram_r(state->tc0080vco, offs + 0, 0xffff) & 0x3ff;
zoomx = (tc0080vco_sprram_r(state->tc0080vco, offs + 2, 0xffff) & 0x7f00) >> 8;
zoomy = (tc0080vco_sprram_r(state->tc0080vco, offs + 2, 0xffff) & 0x007f);
tile_offs = (tc0080vco_sprram_r(state->tc0080vco, offs + 3, 0xffff) & 0x1fff) << 2;
ysize = size[(tc0080vco_sprram_r(state->tc0080vco, offs, 0xffff) & 0x0c00) >> 10];
if (tile_offs)
{
@ -128,7 +129,7 @@ static void draw_sprites(running_machine *machine, bitmap_t *bitmap, const recta
if (x0 >= 0x200) x0 -= 0x400;
if (y0 >= 0x200) y0 -= 0x400;
if (tc0080vco_flipscreen_r(tc0080vco))
if (tc0080vco_flipscreen_r(state->tc0080vco))
{
x0 = 497 - x0;
y0 = 498 - y0;
@ -151,12 +152,12 @@ static void draw_sprites(running_machine *machine, bitmap_t *bitmap, const recta
{
int tile, color, flipx, flipy;
tile = tc0080vco_cram_0_r(tc0080vco, tile_offs, 0xffff) & 0x7fff;
color = tc0080vco_cram_1_r(tc0080vco, tile_offs, 0xffff) & 0x001f;
flipx = tc0080vco_cram_1_r(tc0080vco, tile_offs, 0xffff) & 0x0040;
flipy = tc0080vco_cram_1_r(tc0080vco, tile_offs, 0xffff) & 0x0080;
tile = tc0080vco_cram_0_r(state->tc0080vco, tile_offs, 0xffff) & 0x7fff;
color = tc0080vco_cram_1_r(state->tc0080vco, tile_offs, 0xffff) & 0x001f;
flipx = tc0080vco_cram_1_r(state->tc0080vco, tile_offs, 0xffff) & 0x0040;
flipy = tc0080vco_cram_1_r(state->tc0080vco, tile_offs, 0xffff) & 0x0080;
if (tc0080vco_flipscreen_r(tc0080vco))
if (tc0080vco_flipscreen_r(state->tc0080vco))
{
flipx ^= 0x0040;
flipy ^= 0x0080;
@ -180,50 +181,37 @@ static void draw_sprites(running_machine *machine, bitmap_t *bitmap, const recta
}
}
extern UINT16 *taitoair_line_ram;
enum { FRAC_SHIFT = 16, POLY_MAX_PT = 16 };
static struct {
int x1, y1, x2, y2;
} view;
struct spoint {
INT32 x, y;
};
struct poly {
struct spoint p[POLY_MAX_PT];
int pcount;
int col;
};
static void fill_slope(bitmap_t *bitmap, int color, INT32 x1, INT32 x2, INT32 sl1, INT32 sl2, INT32 y1, INT32 y2, INT32 *nx1, INT32 *nx2)
static void fill_slope( running_machine *machine, bitmap_t *bitmap, int color, INT32 x1, INT32 x2, INT32 sl1, INT32 sl2, INT32 y1, INT32 y2, INT32 *nx1, INT32 *nx2 )
{
if(y1 > view.y2)
taitoair_state *state = (taitoair_state *)machine->driver_data;
if (y1 > state->view.y2)
return;
if(y2 <= view.y1) {
int delta = y2-y1;
*nx1 = x1+delta*sl1;
*nx2 = x2+delta*sl2;
if (y2 <= state->view.y1)
{
int delta = y2 - y1;
*nx1 = x1 + delta * sl1;
*nx2 = x2 + delta * sl2;
return;
}
if(y1 < -1000000 || y1 > 1000000)
if (y1 < -1000000 || y1 > 1000000)
return;
if(y2 > view.y2)
y2 = view.y2+1;
if (y2 > state->view.y2)
y2 = state->view.y2 + 1;
if(y1 < view.y1) {
int delta = view.y1 - y1;
x1 += delta*sl1;
x2 += delta*sl2;
y1 = view.y1;
if (y1 < state->view.y1)
{
int delta = state->view.y1 - y1;
x1 += delta * sl1;
x2 += delta * sl2;
y1 = state->view.y1;
}
if(x1 > x2 || (x1==x2 && sl1 > sl2)) {
if (x1 > x2 || (x1==x2 && sl1 > sl2))
{
INT32 t, *tp;
t = x1;
x1 = x2;
@ -236,22 +224,26 @@ static void fill_slope(bitmap_t *bitmap, int color, INT32 x1, INT32 x2, INT32 sl
nx2 = tp;
}
while(y1 < y2) {
if(y1 >= view.y1) {
int xx1 = x1>>FRAC_SHIFT;
int xx2 = x2>>FRAC_SHIFT;
if(xx1 <= view.x2 || xx2 >= view.x1) {
if(xx1 < view.x1)
xx1 = view.x1;
if(xx2 > view.x2)
xx2 = view.x2;
while (y1 < y2)
{
if (y1 >= state->view.y1)
{
int xx1 = x1 >> TAITOAIR_FRAC_SHIFT;
int xx2 = x2 >> TAITOAIR_FRAC_SHIFT;
if (xx1 <= state->view.x2 || xx2 >= state->view.x1)
{
if (xx1 < state->view.x1)
xx1 = state->view.x1;
if (xx2 > state->view.x2)
xx2 = state->view.x2;
while(xx1 <= xx2) {
*BITMAP_ADDR16(bitmap, y1, xx1) = color;
xx1++;
while (xx1 <= xx2)
{
*BITMAP_ADDR16(bitmap, y1, xx1) = color;
xx1++;
}
}
}
}
x1 += sl1;
x2 += sl2;
@ -261,144 +253,153 @@ static void fill_slope(bitmap_t *bitmap, int color, INT32 x1, INT32 x2, INT32 sl
*nx2 = x2;
}
static void fill_poly(bitmap_t *bitmap, const struct poly *q)
static void fill_poly( running_machine *machine, bitmap_t *bitmap, const struct taitoair_poly *q )
{
taitoair_state *state = (taitoair_state *)machine->driver_data;
INT32 sl1, sl2, cury, limy, x1, x2;
int pmin, pmax, i, ps1, ps2;
struct spoint p[POLY_MAX_PT*2];
struct taitoair_spoint p[TAITOAIR_POLY_MAX_PT * 2];
int color = q->col;
int pcount = q->pcount;
for(i=0; i<pcount; i++) {
p[i].x = p[i+pcount].x = q->p[i].x << FRAC_SHIFT;
p[i].y = p[i+pcount].y = q->p[i].y;
for (i = 0; i < pcount; i++)
{
p[i].x = p[i + pcount].x = q->p[i].x << TAITOAIR_FRAC_SHIFT;
p[i].y = p[i + pcount].y = q->p[i].y;
}
pmin = pmax = 0;
for(i=1; i<pcount; i++) {
if(p[i].y < p[pmin].y)
for (i = 1; i < pcount; i++)
{
if (p[i].y < p[pmin].y)
pmin = i;
if(p[i].y > p[pmax].y)
if (p[i].y > p[pmax].y)
pmax = i;
}
cury = p[pmin].y;
limy = p[pmax].y;
if(cury == limy)
if (cury == limy)
return;
if(cury > view.y2)
if (cury > state->view.y2)
return;
if(limy <= view.y1)
if (limy <= state->view.y1)
return;
if(limy > view.y2)
limy = view.y2;
if (limy > state->view.y2)
limy = state->view.y2;
ps1 = pmin+pcount;
ps1 = pmin + pcount;
ps2 = pmin;
goto startup;
for(;;) {
if(p[ps1-1].y == p[ps2+1].y) {
fill_slope(bitmap, color, x1, x2, sl1, sl2, cury, p[ps1-1].y, &x1, &x2);
cury = p[ps1-1].y;
if(cury >= limy)
for (;;)
{
if (p[ps1 - 1].y == p[ps2 + 1].y)
{
fill_slope(machine, bitmap, color, x1, x2, sl1, sl2, cury, p[ps1 - 1].y, &x1, &x2);
cury = p[ps1 - 1].y;
if (cury >= limy)
break;
ps1--;
ps2++;
startup:
while(p[ps1-1].y == cury)
while (p[ps1 - 1].y == cury)
ps1--;
while(p[ps2+1].y == cury)
while (p[ps2 + 1].y == cury)
ps2++;
x1 = p[ps1].x;
x2 = p[ps2].x;
sl1 = (x1-p[ps1-1].x)/(cury-p[ps1-1].y);
sl2 = (x2-p[ps2+1].x)/(cury-p[ps2+1].y);
} else if(p[ps1-1].y < p[ps2+1].y) {
fill_slope(bitmap, color, x1, x2, sl1, sl2, cury, p[ps1-1].y, &x1, &x2);
cury = p[ps1-1].y;
if(cury >= limy)
sl1 = (x1 - p[ps1 - 1].x) / (cury - p[ps1 - 1].y);
sl2 = (x2 - p[ps2 + 1].x) / (cury - p[ps2 + 1].y);
}
else if (p[ps1 - 1].y < p[ps2 + 1].y)
{
fill_slope(machine, bitmap, color, x1, x2, sl1, sl2, cury, p[ps1 - 1].y, &x1, &x2);
cury = p[ps1 - 1].y;
if (cury >= limy)
break;
ps1--;
while(p[ps1-1].y == cury)
while (p[ps1 - 1].y == cury)
ps1--;
x1 = p[ps1].x;
sl1 = (x1-p[ps1-1].x)/(cury-p[ps1-1].y);
} else {
fill_slope(bitmap, color, x1, x2, sl1, sl2, cury, p[ps2+1].y, &x1, &x2);
cury = p[ps2+1].y;
if(cury >= limy)
sl1 = (x1 - p[ps1 - 1].x) / (cury - p[ps1 - 1].y);
}
else
{
fill_slope(machine, bitmap, color, x1, x2, sl1, sl2, cury, p[ps2 + 1].y, &x1, &x2);
cury = p[ps2 + 1].y;
if (cury >= limy)
break;
ps2++;
while(p[ps2+1].y == cury)
while (p[ps2 + 1].y == cury)
ps2++;
x2 = p[ps2].x;
sl2 = (x2-p[ps2+1].x)/(cury-p[ps2+1].y);
sl2 = (x2 - p[ps2 + 1].x) / (cury - p[ps2 + 1].y);
}
}
}
VIDEO_UPDATE( taitoair )
{
const device_config *tc0080vco = devtag_get_device(screen->machine, "tc0080vco");
taitoair_state *state = (taitoair_state *)screen->machine->driver_data;
tc0080vco_tilemap_update(tc0080vco);
tc0080vco_tilemap_update(state->tc0080vco);
bitmap_fill(bitmap, cliprect, 0x41);
#ifdef MAME_DEBUG
if ( !input_code_pressed(screen->machine, KEYCODE_A) )
tc0080vco_tilemap_draw(tc0080vco, bitmap, cliprect, 0, 0, 0);
if ( !input_code_pressed(screen->machine, KEYCODE_S) )
if (!input_code_pressed(screen->machine, KEYCODE_A))
tc0080vco_tilemap_draw(state->tc0080vco, bitmap, cliprect, 0, 0, 0);
if (!input_code_pressed(screen->machine, KEYCODE_S))
draw_sprites(screen->machine, bitmap, cliprect, 0);
if ( !input_code_pressed(screen->machine, KEYCODE_D) )
tc0080vco_tilemap_draw(tc0080vco, bitmap, cliprect, 1, 0, 0);
if ( !input_code_pressed(screen->machine, KEYCODE_F) )
if (!input_code_pressed(screen->machine, KEYCODE_D))
tc0080vco_tilemap_draw(state->tc0080vco, bitmap, cliprect, 1, 0, 0);
if (!input_code_pressed(screen->machine, KEYCODE_F))
draw_sprites(screen->machine, bitmap, cliprect, 1);
#else
tc0080vco_tilemap_draw(tc0080vco, bitmap, cliprect, 0, 0, 0);
tc0080vco_tilemap_draw(state->tc0080vco, bitmap, cliprect, 0, 0, 0);
draw_sprites(screen->machine, bitmap, cliprect, 0);
tc0080vco_tilemap_draw(tc0080vco, bitmap, cliprect, 1, 0, 0);
tc0080vco_tilemap_draw(state->tc0080vco, bitmap, cliprect, 1, 0, 0);
draw_sprites(screen->machine, bitmap, cliprect, 1);
#endif
tc0080vco_tilemap_draw(tc0080vco, bitmap, cliprect, 2, 0, 0);
tc0080vco_tilemap_draw(state->tc0080vco, bitmap, cliprect, 2, 0, 0);
if (taitoair_line_ram[0x3fff])
if (state->line_ram[0x3fff])
{
int adr = 0x3fff;
struct poly q;
view.x1 = cliprect->min_x;
view.y1 = cliprect->min_y;
view.x2 = cliprect->max_x;
view.y2 = cliprect->max_y;
// struct taitoair_poly q;
state->view.x1 = cliprect->min_x;
state->view.y1 = cliprect->min_y;
state->view.x2 = cliprect->max_x;
state->view.y2 = cliprect->max_y;
while(adr>=0 && taitoair_line_ram[adr] && taitoair_line_ram[adr] != 0x4000)
while (adr >= 0 && state->line_ram[adr] && state->line_ram[adr] != 0x4000)
{
int pcount;
if(!(taitoair_line_ram[adr] & 0x8000) || adr < 10)
if (!(state->line_ram[adr] & 0x8000) || adr < 10)
{
logerror("quad: unknown value %04x at %04x\n", taitoair_line_ram[adr], adr);
logerror("quad: unknown value %04x at %04x\n", state->line_ram[adr], adr);
break;
}
q.col = (taitoair_line_ram[adr] & 0x7fff) + 0x300;
state->q.col = (state->line_ram[adr] & 0x7fff) + 0x300;
adr--;
pcount = 0;
while(pcount < POLY_MAX_PT && adr>=1 && !(taitoair_line_ram[adr] & 0xc000))
while (pcount < TAITOAIR_POLY_MAX_PT && adr >= 1 && !(state->line_ram[adr] & 0xc000))
{
q.p[pcount].y = taitoair_line_ram[adr]+3*16;
q.p[pcount].x = taitoair_line_ram[adr-1];
state->q.p[pcount].y = state->line_ram[adr] + 3 * 16;
state->q.p[pcount].x = state->line_ram[adr - 1];
pcount++;
adr -= 2;
}
adr--;
q.pcount = pcount;
fill_poly(bitmap, &q);
state->q.pcount = pcount;
fill_poly(screen->machine, bitmap, &state->q);
}
}
return 0;