Sprinter/mame
2
0
Fork 0
mirror of https://github.com/holub/mame synced 2025-07-04 01:18:59 +03:00
Code Issues Actions 4 Packages Projects Releases Wiki Activity

namcos2 and namcos21: moved most remaining functions into classes (nw).

Browse Source
This commit is contained in:
Ivan Vangelista 2014-09-30 14:57:36 +00:00
parent bc00aadc06
commit 54c3e62516
6 changed files with 337 additions and 363 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

293
src/mame/drivers/namcos21.c
View File

@ -309,10 +309,9 @@ CPU68 PCB:
#define ENABLE_LOGGING 0 #define ENABLE_LOGGING 0
static INT32 INT32 namcos21_state::read_pointrom_data(unsigned offset)
ReadPointROMData( running_machine &machine, unsigned offset )
{ {
const INT32 *pPointData = (INT32 *)machine.root_device().memregion( "user2" )->base(); const INT32 *pPointData = (INT32 *)memregion( "user2" )->base();
INT32 result = pPointData[offset]; INT32 result = pPointData[offset];
return result; return result;
} }
@ -378,25 +377,22 @@ READ16_MEMBER(namcos21_state::dspcuskey_r)
return result; return result;
} }
static void void namcos21_state::transmit_word_to_slave(UINT16 data)
TransmitWordToSlave( namcos21_state *state, UINT16 data )
{ {
unsigned offs = state->m_mpDspState->slaveInputStart+state->m_mpDspState->slaveBytesAvailable++; unsigned offs = m_mpDspState->slaveInputStart+m_mpDspState->slaveBytesAvailable++;
state->m_mpDspState->slaveInputBuffer[offs%DSP_BUF_MAX] = data; m_mpDspState->slaveInputBuffer[offs%DSP_BUF_MAX] = data;
if (ENABLE_LOGGING) logerror( "+%04x(#%04x)\n", data, state->m_mpDspState->slaveBytesAvailable ); if (ENABLE_LOGGING) logerror( "+%04x(#%04x)\n", data, m_mpDspState->slaveBytesAvailable );
state->m_mpDspState->slaveActive = 1; m_mpDspState->slaveActive = 1;
if( state->m_mpDspState->slaveBytesAvailable >= DSP_BUF_MAX ) if( m_mpDspState->slaveBytesAvailable >= DSP_BUF_MAX )
{ {
logerror( "IDC overflow\n" ); logerror( "IDC overflow\n" );
exit(1); exit(1);
} }
} /* TransmitWordToSlave */ }
static void void namcos21_state::transfer_dsp_data()
TransferDspData( running_machine &machine )
{ {
namcos21_state *state = machine.driver_data<namcos21_state>(); UINT16 addr = m_mpDspState->masterSourceAddr;
UINT16 addr = state->m_mpDspState->masterSourceAddr;
int mode = addr&0x8000; int mode = addr&0x8000;
addr&=0x7fff; addr&=0x7fff;
if( addr ) if( addr )
@ -405,13 +401,13 @@ TransferDspData( running_machine &machine )
{ {
int i; int i;
UINT16 old = addr; UINT16 old = addr;
UINT16 code = state->m_dspram16[addr++]; UINT16 code = m_dspram16[addr++];
if( code == 0xffff ) if( code == 0xffff )
{ {
if( mode ) if( mode )
{ {
addr = state->m_dspram16[addr]; addr = m_dspram16[addr];
state->m_mpDspState->masterSourceAddr = addr; m_mpDspState->masterSourceAddr = addr;
if (ENABLE_LOGGING) logerror( "LOOP:0x%04x\n", addr ); if (ENABLE_LOGGING) logerror( "LOOP:0x%04x\n", addr );
addr&=0x7fff; addr&=0x7fff;
if( old==addr ) if( old==addr )
@ -421,59 +417,59 @@ TransferDspData( running_machine &machine )
} }
else else
{ {
state->m_mpDspState->masterSourceAddr = 0; m_mpDspState->masterSourceAddr = 0;
return; return;
} }
} }
else if( mode==0 ) else if( mode==0 )
{ /* direct data transfer */ { /* direct data transfer */
if (ENABLE_LOGGING) logerror( "DATA TFR(0x%x)\n", code ); if (ENABLE_LOGGING) logerror( "DATA TFR(0x%x)\n", code );
TransmitWordToSlave( state, code ); transmit_word_to_slave(code);
for( i=0; i<code; i++ ) for( i=0; i<code; i++ )
{ {
UINT16 data = state->m_dspram16[addr++]; UINT16 data = m_dspram16[addr++];
TransmitWordToSlave( state, data ); transmit_word_to_slave(data);
} }
} }
else if( code==0x18 || code==0x1a ) else if( code==0x18 || code==0x1a )
{ {
if (ENABLE_LOGGING) logerror( "HEADER TFR(0x%x)\n", code ); if (ENABLE_LOGGING) logerror( "HEADER TFR(0x%x)\n", code );
TransmitWordToSlave( state, code+1 ); transmit_word_to_slave(code+1);
for( i=0; i<code; i++ ) for( i=0; i<code; i++ )
{ {
UINT16 data = state->m_dspram16[addr++]; UINT16 data = m_dspram16[addr++];
TransmitWordToSlave( state, data ); transmit_word_to_slave(data);
} }
} }
else else
{ {
INT32 masterAddr = ReadPointROMData(machine, code); INT32 masterAddr = read_pointrom_data(code);
if (ENABLE_LOGGING) logerror( "OBJ TFR(0x%x)\n", code ); if (ENABLE_LOGGING) logerror( "OBJ TFR(0x%x)\n", code );
{ {
UINT16 len = state->m_dspram16[addr++]; UINT16 len = m_dspram16[addr++];
for(;;) for(;;)
{ {
int subAddr = ReadPointROMData(machine, masterAddr++); int subAddr = read_pointrom_data(masterAddr++);
if( subAddr==0xffffff ) if( subAddr==0xffffff )
{ {
break; break;
} }
else else
{ {
int primWords = (UINT16)ReadPointROMData(machine, subAddr++); int primWords = (UINT16)read_pointrom_data(subAddr++);
if( primWords>2 ) if( primWords>2 )
{ {
TransmitWordToSlave( state, 0 ); /* pad1 */ transmit_word_to_slave(0); /* pad1 */
TransmitWordToSlave( state, len+1 ); transmit_word_to_slave(len+1);
for( i=0; i<len; i++ ) for( i=0; i<len; i++ )
{ /* transform */ { /* transform */
TransmitWordToSlave( state, state->m_dspram16[addr+i] ); transmit_word_to_slave(m_dspram16[addr+i]);
} }
TransmitWordToSlave( state, 0 ); /* pad2 */ transmit_word_to_slave(0); /* pad2 */
TransmitWordToSlave( state, primWords+1 ); transmit_word_to_slave(primWords+1);
for( i=0; i<primWords; i++ ) for( i=0; i<primWords; i++ )
{ {
TransmitWordToSlave( state, (UINT16)ReadPointROMData(machine, subAddr+i) ); transmit_word_to_slave((UINT16)read_pointrom_data(subAddr+i));
} }
} }
else else
@ -487,34 +483,34 @@ TransferDspData( running_machine &machine )
} }
} /* for(;;) */ } /* for(;;) */
} }
} /* TransferDspData */ }
void void namcos21_kickstart(running_machine &machine, int internal)
namcos21_kickstart( running_machine &machine, int internal )
{ {
namcos21_state *state = machine.driver_data<namcos21_state>(); namcos21_state *state = machine.driver_data<namcos21_state>();
/* patch dsp watchdog */ /* patch dsp watchdog */
switch( state->m_gametype ) switch( state->m_gametype )
{ {
case NAMCOS21_AIRCOMBAT: case NAMCOS21_AIRCOMBAT:
state->m_master_dsp_code[0x008e] = 0x808f; state->m_master_dsp_code[0x008e] = 0x808f;
break; break;
case NAMCOS21_SOLVALOU: case NAMCOS21_SOLVALOU:
state->m_master_dsp_code[0x008b] = 0x808c; state->m_master_dsp_code[0x008b] = 0x808c;
break; break;
default: default:
break; break;
} }
if( internal ) if( internal )
{ {
if( state->m_mbNeedsKickstart==0 ) return; if( state->m_mbNeedsKickstart==0 ) return;
state->m_mbNeedsKickstart--; state->m_mbNeedsKickstart--;
if( state->m_mbNeedsKickstart ) return; if( state->m_mbNeedsKickstart ) return;
} }
namcos21_ClearPolyFrameBuffer(machine); state->clear_poly_framebuffer();
state->m_mpDspState->masterSourceAddr = 0; state->m_mpDspState->masterSourceAddr = 0;
state->m_mpDspState->slaveOutputSize = 0; state->m_mpDspState->slaveOutputSize = 0;
state->m_mpDspState->masterFinished = 0; state->m_mpDspState->masterFinished = 0;
@ -523,44 +519,40 @@ namcos21_kickstart( running_machine &machine, int internal )
state->m_dspslave->set_input_line(INPUT_LINE_RESET, PULSE_LINE); state->m_dspslave->set_input_line(INPUT_LINE_RESET, PULSE_LINE);
} }
static UINT16 UINT16 namcos21_state::read_word_from_slave_input()
ReadWordFromSlaveInput( address_space &space )
{ {
namcos21_state *state = space.machine().driver_data<namcos21_state>();
UINT16 data = 0; UINT16 data = 0;
if( state->m_mpDspState->slaveBytesAvailable>0 ) if( m_mpDspState->slaveBytesAvailable>0 )
{ {
data = state->m_mpDspState->slaveInputBuffer[state->m_mpDspState->slaveInputStart++]; data = m_mpDspState->slaveInputBuffer[m_mpDspState->slaveInputStart++];
state->m_mpDspState->slaveInputStart %= DSP_BUF_MAX; m_mpDspState->slaveInputStart %= DSP_BUF_MAX;
state->m_mpDspState->slaveBytesAvailable--; m_mpDspState->slaveBytesAvailable--;
if( state->m_mpDspState->slaveBytesAdvertised>0 ) if( m_mpDspState->slaveBytesAdvertised>0 )
{ {
state->m_mpDspState->slaveBytesAdvertised--; m_mpDspState->slaveBytesAdvertised--;
} }
if (ENABLE_LOGGING) logerror( "%s:-%04x(0x%04x)\n", space.machine().describe_context(), data, state->m_mpDspState->slaveBytesAvailable ); if (ENABLE_LOGGING) logerror( "%s:-%04x(0x%04x)\n", machine().describe_context(), data, m_mpDspState->slaveBytesAvailable );
} }
return data; return data;
} /* ReadWordFromSlaveInput */ }
static size_t size_t namcos21_state::get_input_bytes_advertised_for_slave()
GetInputBytesAdvertisedForSlave( running_machine &machine )
{ {
namcos21_state *state = machine.driver_data<namcos21_state>(); if( m_mpDspState->slaveBytesAdvertised < m_mpDspState->slaveBytesAvailable )
if( state->m_mpDspState->slaveBytesAdvertised < state->m_mpDspState->slaveBytesAvailable )
{ {
state->m_mpDspState->slaveBytesAdvertised++; m_mpDspState->slaveBytesAdvertised++;
} }
else if( state->m_mpDspState->slaveActive && state->m_mpDspState->masterFinished && state->m_mpDspState->masterSourceAddr ) else if( m_mpDspState->slaveActive && m_mpDspState->masterFinished && m_mpDspState->masterSourceAddr )
{ {
namcos21_kickstart(machine, 0); namcos21_kickstart(machine(), 0);
} }
return state->m_mpDspState->slaveBytesAdvertised; return m_mpDspState->slaveBytesAdvertised;
} /* GetInputBytesAdvertisedForSlave */ }
READ16_MEMBER(namcos21_state::dspram16_r) READ16_MEMBER(namcos21_state::dspram16_r)
{ {
return m_dspram16[offset]; return m_dspram16[offset];
} /* dspram16_r */ }
WRITE16_MEMBER(namcos21_state::dspram16_w) WRITE16_MEMBER(namcos21_state::dspram16_w)
{ {
@ -572,7 +564,7 @@ WRITE16_MEMBER(namcos21_state::dspram16_w)
offset == 1+(m_mpDspState->masterSourceAddr&0x7fff) ) offset == 1+(m_mpDspState->masterSourceAddr&0x7fff) )
{ {
if (ENABLE_LOGGING) logerror( "IDC-CONTINUE\n" ); if (ENABLE_LOGGING) logerror( "IDC-CONTINUE\n" );
TransferDspData(machine()); transfer_dsp_data();
} }
else if (m_gametype == NAMCOS21_SOLVALOU && else if (m_gametype == NAMCOS21_SOLVALOU &&
offset == 0x103 && offset == 0x103 &&
@ -581,15 +573,13 @@ WRITE16_MEMBER(namcos21_state::dspram16_w)
space.device().execute().yield(); space.device().execute().yield();
} }
} }
} /* dspram16_w */ }
/************************************************************************************/ /************************************************************************************/
static int int namcos21_state::init_dsp()
InitDSP( running_machine &machine )
{ {
namcos21_state *state = machine.driver_data<namcos21_state>(); UINT16 *pMem = (UINT16 *)memregion("dspmaster")->base();
UINT16 *pMem = (UINT16 *)state->memregion("dspmaster")->base();
/** /**
* DSP BIOS tests "CPU ID" on startup * DSP BIOS tests "CPU ID" on startup
* "JAPAN (C)1990 NAMCO LTD. by H.F " * "JAPAN (C)1990 NAMCO LTD. by H.F "
@ -598,7 +588,7 @@ InitDSP( running_machine &machine )
pMem[0x8000] = 0xFF80; pMem[0x8000] = 0xFF80;
pMem[0x8001] = 0x0000; pMem[0x8001] = 0x0000;
state->m_mpDspState = auto_alloc_clear(machine, dsp_state); m_mpDspState = auto_alloc_clear(machine(), dsp_state);
return 0; return 0;
} }
@ -609,16 +599,16 @@ InitDSP( running_machine &machine )
READ16_MEMBER(namcos21_state::dsp_port0_r) READ16_MEMBER(namcos21_state::dsp_port0_r)
{ {
INT32 data = ReadPointROMData(machine(), m_pointrom_idx++); INT32 data = read_pointrom_data(m_pointrom_idx++);
m_mPointRomMSB = (UINT8)(data>>16); m_mPointRomMSB = (UINT8)(data>>16);
m_mbPointRomDataAvailable = 1; m_mbPointRomDataAvailable = 1;
return (UINT16)data; return (UINT16)data;
} /* dsp_port0_r */ }
WRITE16_MEMBER(namcos21_state::dsp_port0_w) WRITE16_MEMBER(namcos21_state::dsp_port0_w)
{ /* unused? */ { /* unused? */
if (ENABLE_LOGGING) logerror( "PTRAM_LO(0x%04x)\n", data ); if (ENABLE_LOGGING) logerror( "PTRAM_LO(0x%04x)\n", data );
} /* dsp_port0_w */ }
READ16_MEMBER(namcos21_state::dsp_port1_r) READ16_MEMBER(namcos21_state::dsp_port1_r)
{ {
@ -628,44 +618,44 @@ READ16_MEMBER(namcos21_state::dsp_port1_r)
return m_mPointRomMSB; return m_mPointRomMSB;
} }
return 0x8000; /* IDC ack? */ return 0x8000; /* IDC ack? */
} /* dsp_port1_r */ }
WRITE16_MEMBER(namcos21_state::dsp_port1_w) WRITE16_MEMBER(namcos21_state::dsp_port1_w)
{ /* unused? */ { /* unused? */
if (ENABLE_LOGGING) logerror( "PTRAM_HI(0x%04x)\n", data ); if (ENABLE_LOGGING) logerror( "PTRAM_HI(0x%04x)\n", data );
} /* dsp_port1_w */ }
READ16_MEMBER(namcos21_state::dsp_port2_r) READ16_MEMBER(namcos21_state::dsp_port2_r)
{ /* IDC TRANSMIT ENABLE? */ { /* IDC TRANSMIT ENABLE? */
return 0; return 0;
} /* dsp_port2_r */ }
WRITE16_MEMBER(namcos21_state::dsp_port2_w) WRITE16_MEMBER(namcos21_state::dsp_port2_w)
{ {
if (ENABLE_LOGGING) logerror( "IDC ADDR INIT(0x%04x)\n", data ); if (ENABLE_LOGGING) logerror( "IDC ADDR INIT(0x%04x)\n", data );
m_mpDspState->masterSourceAddr = data; m_mpDspState->masterSourceAddr = data;
TransferDspData(machine()); transfer_dsp_data();
} /* dsp_port2_w */ }
READ16_MEMBER(namcos21_state::dsp_port3_idc_rcv_enable_r) READ16_MEMBER(namcos21_state::dsp_port3_idc_rcv_enable_r)
{ /* IDC RECEIVE ENABLE? */ { /* IDC RECEIVE ENABLE? */
return 0; return 0;
} /* dsp_port3_idc_rcv_enable_r */ }
WRITE16_MEMBER(namcos21_state::dsp_port3_w) WRITE16_MEMBER(namcos21_state::dsp_port3_w)
{ {
m_pointrom_idx<<=16; m_pointrom_idx<<=16;
m_pointrom_idx|=data; m_pointrom_idx|=data;
} /* dsp_port3_w */ }
WRITE16_MEMBER(namcos21_state::dsp_port4_w) WRITE16_MEMBER(namcos21_state::dsp_port4_w)
{ /* receives $0B<<4 prior to IDC setup */ { /* receives $0B<<4 prior to IDC setup */
} /* dsp_port4_w */ }
READ16_MEMBER(namcos21_state::dsp_port8_r) READ16_MEMBER(namcos21_state::dsp_port8_r)
{ /* SMU status */ { /* SMU status */
return 1; return 1;
} /* dsp_port8_r */ }
WRITE16_MEMBER(namcos21_state::dsp_port8_w) WRITE16_MEMBER(namcos21_state::dsp_port8_w)
@ -676,17 +666,17 @@ WRITE16_MEMBER(namcos21_state::dsp_port8_w)
m_mpDspState->masterFinished = 1; m_mpDspState->masterFinished = 1;
} }
m_irq_enable = data; m_irq_enable = data;
} /* dsp_port8_w */ }
READ16_MEMBER(namcos21_state::dsp_port9_r) READ16_MEMBER(namcos21_state::dsp_port9_r)
{ /* render-device-busy; used for direct-draw */ { /* render-device-busy; used for direct-draw */
return 0; return 0;
} /* dsp_port9_r */ }
READ16_MEMBER(namcos21_state::dsp_porta_r) READ16_MEMBER(namcos21_state::dsp_porta_r)
{ /* config */ { /* config */
return 0; return 0;
} /* dsp_porta_r */ }
WRITE16_MEMBER(namcos21_state::dsp_porta_w) WRITE16_MEMBER(namcos21_state::dsp_porta_w)
{ {
@ -696,12 +686,12 @@ WRITE16_MEMBER(namcos21_state::dsp_porta_w)
/* direct-draw begin: 0 */ /* direct-draw begin: 0 */
/* INT1 begin: 1 */ /* INT1 begin: 1 */
// if (ENABLE_LOGGING) logerror( "dsp_porta_w(0x%04x)\n", data ); // if (ENABLE_LOGGING) logerror( "dsp_porta_w(0x%04x)\n", data );
} /* dsp_porta_w */ }
READ16_MEMBER(namcos21_state::dsp_portb_r) READ16_MEMBER(namcos21_state::dsp_portb_r)
{ /* config */ { /* config */
return 1; return 1;
} /* dsp_portb_r */ }
WRITE16_MEMBER(namcos21_state::dsp_portb_w) WRITE16_MEMBER(namcos21_state::dsp_portb_w)
{ {
@ -722,7 +712,7 @@ WRITE16_MEMBER(namcos21_state::dsp_portb_w)
} }
if( color&0x8000 ) if( color&0x8000 )
{ {
namcos21_DrawQuad( machine(), sx, sy, zcode, color ); draw_quad(sx, sy, zcode, color);
} }
else else
{ {
@ -734,7 +724,7 @@ WRITE16_MEMBER(namcos21_state::dsp_portb_w)
logerror( "unexpected masterDirectDrawSize=%d!\n",m_mpDspState->masterDirectDrawSize ); logerror( "unexpected masterDirectDrawSize=%d!\n",m_mpDspState->masterDirectDrawSize );
} }
m_mpDspState->masterDirectDrawSize = 0; m_mpDspState->masterDirectDrawSize = 0;
} /* dsp_portb_w */ }
WRITE16_MEMBER(namcos21_state::dsp_portc_w) WRITE16_MEMBER(namcos21_state::dsp_portc_w)
{ {
@ -746,12 +736,12 @@ WRITE16_MEMBER(namcos21_state::dsp_portc_w)
{ {
logerror( "portc overflow\n" ); logerror( "portc overflow\n" );
} }
} /* dsp_portc_w */ }
READ16_MEMBER(namcos21_state::dsp_portf_r) READ16_MEMBER(namcos21_state::dsp_portf_r)
{ /* informs BIOS that this is Master DSP */ { /* informs BIOS that this is Master DSP */
return 0; return 0;
} /* dsp_portf_r */ }
WRITE16_MEMBER(namcos21_state::dsp_xf_w) WRITE16_MEMBER(namcos21_state::dsp_xf_w)
{ {
@ -787,22 +777,20 @@ ADDRESS_MAP_END
/************************************************************************************/ /************************************************************************************/
static void void namcos21_state::render_slave_output(UINT16 data)
RenderSlaveOutput( running_machine &machine, UINT16 data )
{ {
namcos21_state *state = machine.driver_data<namcos21_state>(); if( m_mpDspState->slaveOutputSize >= 4096 )
if( state->m_mpDspState->slaveOutputSize >= 4096 )
{ {
fatalerror( "FATAL ERROR: SLAVE OVERFLOW (0x%x)\n",state->m_mpDspState->slaveOutputBuffer[0] ); fatalerror( "FATAL ERROR: SLAVE OVERFLOW (0x%x)\n",m_mpDspState->slaveOutputBuffer[0] );
} }
/* append word to slave output buffer */ /* append word to slave output buffer */
state->m_mpDspState->slaveOutputBuffer[state->m_mpDspState->slaveOutputSize++] = data; m_mpDspState->slaveOutputBuffer[m_mpDspState->slaveOutputSize++] = data;
{ {
UINT16 *pSource = state->m_mpDspState->slaveOutputBuffer; UINT16 *pSource = m_mpDspState->slaveOutputBuffer;
UINT16 count = *pSource++; UINT16 count = *pSource++;
if( count && state->m_mpDspState->slaveOutputSize > count ) if( count && m_mpDspState->slaveOutputSize > count )
{ {
UINT16 color = *pSource++; UINT16 color = *pSource++;
int sx[4], sy[4],zcode[4]; int sx[4], sy[4],zcode[4];
@ -816,30 +804,30 @@ RenderSlaveOutput( running_machine &machine, UINT16 data )
sy[j] = NAMCOS21_POLY_FRAME_HEIGHT/2 + (INT16)pSource[3*j+1]; sy[j] = NAMCOS21_POLY_FRAME_HEIGHT/2 + (INT16)pSource[3*j+1];
zcode[j] = pSource[3*j+2]; zcode[j] = pSource[3*j+2];
} }
namcos21_DrawQuad( machine, sx, sy, zcode, color&0x7fff ); draw_quad(sx, sy, zcode, color&0x7fff);
} }
else else
{ {
int quad_idx = color*6; int quad_idx = color*6;
for(;;) for(;;)
{ {
UINT8 code = state->m_pointram[quad_idx++]; UINT8 code = m_pointram[quad_idx++];
color = state->m_pointram[quad_idx++]|(code<<8); color = m_pointram[quad_idx++]|(code<<8);
for( j=0; j<4; j++ ) for( j=0; j<4; j++ )
{ {
UINT8 vi = state->m_pointram[quad_idx++]; UINT8 vi = m_pointram[quad_idx++];
sx[j] = NAMCOS21_POLY_FRAME_WIDTH/2 + (INT16)pSource[vi*3+0]; sx[j] = NAMCOS21_POLY_FRAME_WIDTH/2 + (INT16)pSource[vi*3+0];
sy[j] = NAMCOS21_POLY_FRAME_HEIGHT/2 + (INT16)pSource[vi*3+1]; sy[j] = NAMCOS21_POLY_FRAME_HEIGHT/2 + (INT16)pSource[vi*3+1];
zcode[j] = pSource[vi*3+2]; zcode[j] = pSource[vi*3+2];
} }
namcos21_DrawQuad( machine, sx, sy, zcode, color&0x7fff ); draw_quad(sx, sy, zcode, color&0x7fff);
if( code&0x80 ) if( code&0x80 )
{ /* end-of-quadlist marker */ { /* end-of-quadlist marker */
break; break;
} }
} }
} }
state->m_mpDspState->slaveOutputSize = 0; m_mpDspState->slaveOutputSize = 0;
} }
else if( count==0 ) else if( count==0 )
{ {
@ -847,22 +835,22 @@ RenderSlaveOutput( running_machine &machine, UINT16 data )
exit(1); exit(1);
} }
} }
} /* RenderSlaveOutput */ }
READ16_MEMBER(namcos21_state::slave_port0_r) READ16_MEMBER(namcos21_state::slave_port0_r)
{ {
return ReadWordFromSlaveInput(space); return read_word_from_slave_input();
} /* slave_port0_r */ }
WRITE16_MEMBER(namcos21_state::slave_port0_w) WRITE16_MEMBER(namcos21_state::slave_port0_w)
{ {
RenderSlaveOutput( machine(), data ); render_slave_output(data);
} }
READ16_MEMBER(namcos21_state::slave_port2_r) READ16_MEMBER(namcos21_state::slave_port2_r)
{ {
return GetInputBytesAdvertisedForSlave(machine()); return get_input_bytes_advertised_for_slave();
} /* slave_port2_r */ }
READ16_MEMBER(namcos21_state::slave_port3_r) READ16_MEMBER(namcos21_state::slave_port3_r)
{ /* render-device queue size */ { /* render-device queue size */
@ -874,12 +862,12 @@ READ16_MEMBER(namcos21_state::slave_port3_r)
WRITE16_MEMBER(namcos21_state::slave_port3_w) WRITE16_MEMBER(namcos21_state::slave_port3_w)
{ /* 0=busy, 1=ready? */ { /* 0=busy, 1=ready? */
} /* slave_port3_w */ }
WRITE16_MEMBER(namcos21_state::slave_XF_output_w) WRITE16_MEMBER(namcos21_state::slave_XF_output_w)
{ {
if (ENABLE_LOGGING) logerror( "0x%x:slaveXF(%d)\n", space.device().safe_pc(), data ); if (ENABLE_LOGGING) logerror( "0x%x:slaveXF(%d)\n", space.device().safe_pc(), data );
} /* slave_XF_output_w */ }
READ16_MEMBER(namcos21_state::slave_portf_r) READ16_MEMBER(namcos21_state::slave_portf_r)
{ /* informs BIOS that this is Slave DSP */ { /* informs BIOS that this is Slave DSP */
@ -957,12 +945,12 @@ WRITE16_MEMBER(namcos21_state::pointram_control_w)
logerror( "\n" ); logerror( "\n" );
#endif #endif
m_pointram_idx = 0; /* HACK */ m_pointram_idx = 0; /* HACK */
} /* pointram_control_w */ }
READ16_MEMBER(namcos21_state::pointram_data_r) READ16_MEMBER(namcos21_state::pointram_data_r)
{ {
return m_pointram[m_pointram_idx]; return m_pointram[m_pointram_idx];
} /* pointram_data_r */ }
WRITE16_MEMBER(namcos21_state::pointram_data_w) WRITE16_MEMBER(namcos21_state::pointram_data_w)
{ {
@ -973,7 +961,7 @@ WRITE16_MEMBER(namcos21_state::pointram_data_w)
m_pointram[m_pointram_idx++] = data; m_pointram[m_pointram_idx++] = data;
m_pointram_idx &= (PTRAM_SIZE-1); m_pointram_idx &= (PTRAM_SIZE-1);
} }
} /* pointram_data_w */ }
READ16_MEMBER(namcos21_state::namcos21_depthcue_r) READ16_MEMBER(namcos21_state::namcos21_depthcue_r)
@ -1123,19 +1111,17 @@ READ16_MEMBER(namcos21_state::winrun_cuskey_r)
break; break;
} }
return 0; return 0;
} /* winrun_cuskey_r */ }
WRITE16_MEMBER(namcos21_state::winrun_cuskey_w) WRITE16_MEMBER(namcos21_state::winrun_cuskey_w)
{ {
} /* winrun_cuskey_w */ }
static void void namcos21_state::winrun_flush_poly()
winrun_flushpoly( running_machine &machine )
{ {
namcos21_state *state = machine.driver_data<namcos21_state>(); if( m_winrun_poly_index>0 )
if( state->m_winrun_poly_index>0 )
{ {
const UINT16 *pSource = state->m_winrun_poly_buf; const UINT16 *pSource = m_winrun_poly_buf;
UINT16 color; UINT16 color;
int sx[4], sy[4], zcode[4]; int sx[4], sy[4], zcode[4];
int j; int j;
@ -1148,36 +1134,36 @@ winrun_flushpoly( running_machine &machine )
sy[j] = NAMCOS21_POLY_FRAME_HEIGHT/2 + (INT16)*pSource++; sy[j] = NAMCOS21_POLY_FRAME_HEIGHT/2 + (INT16)*pSource++;
zcode[j] = *pSource++; zcode[j] = *pSource++;
} }
namcos21_DrawQuad( machine, sx, sy, zcode, color&0x7fff ); draw_quad(sx, sy, zcode, color&0x7fff);
} }
else else
{ {
int quad_idx = color*6; int quad_idx = color*6;
for(;;) for(;;)
{ {
UINT8 code = state->m_pointram[quad_idx++]; UINT8 code = m_pointram[quad_idx++];
color = state->m_pointram[quad_idx++]; color = m_pointram[quad_idx++];
for( j=0; j<4; j++ ) for( j=0; j<4; j++ )
{ {
UINT8 vi = state->m_pointram[quad_idx++]; UINT8 vi = m_pointram[quad_idx++];
sx[j] = NAMCOS21_POLY_FRAME_WIDTH/2 + (INT16)pSource[vi*3+0]; sx[j] = NAMCOS21_POLY_FRAME_WIDTH/2 + (INT16)pSource[vi*3+0];
sy[j] = NAMCOS21_POLY_FRAME_HEIGHT/2 + (INT16)pSource[vi*3+1]; sy[j] = NAMCOS21_POLY_FRAME_HEIGHT/2 + (INT16)pSource[vi*3+1];
zcode[j] = pSource[vi*3+2]; zcode[j] = pSource[vi*3+2];
} }
namcos21_DrawQuad( machine, sx, sy, zcode, color&0x7fff ); draw_quad(sx, sy, zcode, color&0x7fff);
if( code&0x80 ) if( code&0x80 )
{ /* end-of-quadlist marker */ { /* end-of-quadlist marker */
break; break;
} }
} }
} }
state->m_winrun_poly_index = 0; m_winrun_poly_index = 0;
} }
} /* winrun_flushpoly */ } /* winrun_flushpoly */
READ16_MEMBER(namcos21_state::winrun_poly_reset_r) READ16_MEMBER(namcos21_state::winrun_poly_reset_r)
{ {
winrun_flushpoly(machine()); winrun_flush_poly();
return 0; return 0;
} }
@ -1191,7 +1177,7 @@ WRITE16_MEMBER(namcos21_state::winrun_dsp_render_w)
{ {
logerror( "WINRUN_POLY_OVERFLOW\n" ); logerror( "WINRUN_POLY_OVERFLOW\n" );
} }
} /* winrun_dsp_render_w */ }
WRITE16_MEMBER(namcos21_state::winrun_dsp_pointrom_addr_w) WRITE16_MEMBER(namcos21_state::winrun_dsp_pointrom_addr_w)
{ {
@ -1209,15 +1195,15 @@ READ16_MEMBER(namcos21_state::winrun_dsp_pointrom_data_r)
{ {
UINT16 *ptrom = (UINT16 *)memregion("user2")->base(); UINT16 *ptrom = (UINT16 *)memregion("user2")->base();
return ptrom[m_winrun_pointrom_addr++]; return ptrom[m_winrun_pointrom_addr++];
} /* winrun_dsp_pointrom_data_r */ }
WRITE16_MEMBER(namcos21_state::winrun_dsp_complete_w) WRITE16_MEMBER(namcos21_state::winrun_dsp_complete_w)
{ {
if( data ) if( data )
{ {
winrun_flushpoly(machine()); winrun_flush_poly();
m_dsp->set_input_line(INPUT_LINE_RESET, PULSE_LINE); m_dsp->set_input_line(INPUT_LINE_RESET, PULSE_LINE);
namcos21_ClearPolyFrameBuffer(machine()); clear_poly_framebuffer();
} }
} }
@ -1271,7 +1257,7 @@ WRITE16_MEMBER(namcos21_state::winrun_dspbios_w)
memcpy( mem, m_winrun_dspbios, 0x2000 ); memcpy( mem, m_winrun_dspbios, 0x2000 );
m_winrun_dsp_alive = 1; m_winrun_dsp_alive = 1;
} }
} /* winrun_dspbios_w */ }
//380000 : read : dsp status? 1 = busy //380000 : read : dsp status? 1 = busy
//380000 : write(0x01) - done before dsp comram init //380000 : write(0x01) - done before dsp comram init
@ -2254,19 +2240,18 @@ ROM_START( winrun91 )
ROM_LOAD("r911-avo3.11e", 0x180000, 0x80000,CRC(76e22f92) SHA1(0e1b8d35a5b9c20cc3192d935f0c9da1e69679d2) ) ROM_LOAD("r911-avo3.11e", 0x180000, 0x80000,CRC(76e22f92) SHA1(0e1b8d35a5b9c20cc3192d935f0c9da1e69679d2) )
ROM_END ROM_END
static void namcos21_init( running_machine &machine, int game_type ) void namcos21_state::init(int game_type)
{ {
namcos21_state *state = machine.driver_data<namcos21_state>(); m_gametype = game_type;
state->m_gametype = game_type; m_pointram = auto_alloc_array(machine(), UINT8, PTRAM_SIZE);
state->m_pointram = auto_alloc_array(machine, UINT8, PTRAM_SIZE); m_mpDataROM = (UINT16 *)memregion( "user1" )->base();
state->m_mpDataROM = (UINT16 *)state->memregion( "user1" )->base(); init_dsp();
InitDSP(machine); m_mbNeedsKickstart = 20;
state->m_mbNeedsKickstart = 20;
if( game_type==NAMCOS21_CYBERSLED ) if( game_type==NAMCOS21_CYBERSLED )
{ {
state->m_mbNeedsKickstart = 200; m_mbNeedsKickstart = 200;
} }
} /* namcos21_init */ }
DRIVER_INIT_MEMBER(namcos21_state,winrun) DRIVER_INIT_MEMBER(namcos21_state,winrun)
{ {
@ -2286,18 +2271,18 @@ DRIVER_INIT_MEMBER(namcos21_state,winrun)
DRIVER_INIT_MEMBER(namcos21_state,aircomb) DRIVER_INIT_MEMBER(namcos21_state,aircomb)
{ {
namcos21_init( machine(), NAMCOS21_AIRCOMBAT ); init(NAMCOS21_AIRCOMBAT);
} }
DRIVER_INIT_MEMBER(namcos21_state,starblad) DRIVER_INIT_MEMBER(namcos21_state,starblad)
{ {
namcos21_init( machine(), NAMCOS21_STARBLADE ); init(NAMCOS21_STARBLADE);
} }
DRIVER_INIT_MEMBER(namcos21_state,cybsled) DRIVER_INIT_MEMBER(namcos21_state,cybsled)
{ {
namcos21_init( machine(), NAMCOS21_CYBERSLED ); init(NAMCOS21_CYBERSLED);
} }
DRIVER_INIT_MEMBER(namcos21_state,solvalou) DRIVER_INIT_MEMBER(namcos21_state,solvalou)
@ -2308,7 +2293,7 @@ DRIVER_INIT_MEMBER(namcos21_state,solvalou)
mem[0x20cf4/2+1] = 0x4e71; mem[0x20cf4/2+1] = 0x4e71;
mem[0x20cf4/2+2] = 0x4e71; mem[0x20cf4/2+2] = 0x4e71;
namcos21_init( machine(), NAMCOS21_SOLVALOU ); init(NAMCOS21_SOLVALOU );
} }
DRIVER_INIT_MEMBER(namcos21_state,driveyes) DRIVER_INIT_MEMBER(namcos21_state,driveyes)

15
src/mame/includes/namcos2.h
View File

@ -121,6 +121,15 @@ public:
bool is_system21(); bool is_system21();
int m_gametype; int m_gametype;
emu_timer *m_posirq_timer;
int m_mcu_analog_ctrl;
int m_mcu_analog_data;
int m_mcu_analog_complete;
UINT8 *m_eeprom;
UINT16 m_68k_master_C148[0x20];
UINT16 m_68k_slave_C148[0x20];
UINT16 m_68k_gpu_C148[0x20];
// C123 Tilemap Emulation // C123 Tilemap Emulation
// TODO: merge with namcos1.c implementation and convert to device // TODO: merge with namcos1.c implementation and convert to device
public: public:
@ -210,6 +219,10 @@ public:
INTERRUPT_GEN_MEMBER(namcos2_68k_gpu_vblank); INTERRUPT_GEN_MEMBER(namcos2_68k_gpu_vblank);
TIMER_CALLBACK_MEMBER(namcos2_posirq_tick); TIMER_CALLBACK_MEMBER(namcos2_posirq_tick);
void adjust_posirq_timer( int scanline ); void adjust_posirq_timer( int scanline );
void init_c148();
void reset_all_subcpus(int state);
UINT16 readwrite_c148( address_space &space, offs_t offset, UINT16 data, int bWrite );
int get_posirq_scanline();
DECLARE_WRITE8_MEMBER( namcos2_68k_eeprom_w ); DECLARE_WRITE8_MEMBER( namcos2_68k_eeprom_w );
DECLARE_READ8_MEMBER( namcos2_68k_eeprom_r ); DECLARE_READ8_MEMBER( namcos2_68k_eeprom_r );
@ -338,6 +351,8 @@ public:
tilemap_t *m_tilemap_roz; tilemap_t *m_tilemap_roz;
UINT16 m_gfx_ctrl; UINT16 m_gfx_ctrl;
UINT16 m_serial_comms_ctrl[0x8]; UINT16 m_serial_comms_ctrl[0x8];
unsigned m_finallap_prot_count;
int m_sendval;
optional_device<namco_c45_road_device> m_c45_road; optional_device<namco_c45_road_device> m_c45_road;

32
src/mame/includes/namcos21.h
View File

@ -25,6 +25,19 @@ struct dsp_state
int slaveActive; int slaveActive;
}; };
struct vertex
{
double x,y;
double z;
};
struct edge
{
double x;
double z;
};
class namcos21_state : public namcos2_shared_state class namcos21_state : public namcos2_shared_state
{ {
public: public:
@ -157,8 +170,19 @@ public:
DECLARE_MACHINE_START(namcos21); DECLARE_MACHINE_START(namcos21);
DECLARE_VIDEO_START(namcos21); DECLARE_VIDEO_START(namcos21);
UINT32 screen_update_namcos21(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect); UINT32 screen_update_namcos21(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
void allocate_poly_framebuffer();
void clear_poly_framebuffer();
void copy_visible_poly_framebuffer(bitmap_ind16 &bitmap, const rectangle &clip, int zlo, int zhi);
void renderscanline_flat(const edge *e1, const edge *e2, int sy, unsigned color, int depthcueenable);
void rendertri(const vertex *v0, const vertex *v1, const vertex *v2, unsigned color, int depthcueenable);
void draw_quad(int sx[4], int sy[4], int zcode[4], int color);
INT32 read_pointrom_data(unsigned offset);
void transmit_word_to_slave(UINT16 data);
void transfer_dsp_data();
UINT16 read_word_from_slave_input();
size_t get_input_bytes_advertised_for_slave();
int init_dsp();
void render_slave_output(UINT16 data);
void winrun_flush_poly();
void init(int game_type);
}; };
/*----------- defined in video/namcos21.c -----------*/
extern void namcos21_ClearPolyFrameBuffer( running_machine &machine );
extern void namcos21_DrawQuad( running_machine &machine, int sx[4], int sy[4], int zcode[4], int color );

201
src/mame/machine/namcos2.c
View File

@ -16,19 +16,8 @@ Namco System II
#include "machine/nvram.h" #include "machine/nvram.h"
static void InitC148(void);
static emu_timer *namcos2_posirq_timer;
void (*namcos2_kickstart)(running_machine &machine, int internal); void (*namcos2_kickstart)(running_machine &machine, int internal);
static unsigned mFinalLapProtCount;
static int namcos2_mcu_analog_ctrl;
static int namcos2_mcu_analog_data;
static int namcos2_mcu_analog_complete;
static UINT8 *namcos2_eeprom;
static int sendval;
READ16_MEMBER( namcos2_state::namcos2_finallap_prot_r ) READ16_MEMBER( namcos2_state::namcos2_finallap_prot_r )
{ {
@ -47,24 +36,24 @@ READ16_MEMBER( namcos2_state::namcos2_finallap_prot_r )
break; break;
case 2: case 2:
data = table1[mFinalLapProtCount&7]; data = table1[m_finallap_prot_count&7];
data = (data&0xff00)>>8; data = (data&0xff00)>>8;
break; break;
case 3: case 3:
data = table1[mFinalLapProtCount&7]; data = table1[m_finallap_prot_count&7];
mFinalLapProtCount++; m_finallap_prot_count++;
data = data&0x00ff; data = data&0x00ff;
break; break;
case 0x3fffc/2: case 0x3fffc/2:
data = table0[mFinalLapProtCount&7]; data = table0[m_finallap_prot_count&7];
data = data&0xff00; data = data&0xff00;
break; break;
case 0x3fffe/2: case 0x3fffe/2:
data = table0[mFinalLapProtCount&7]; data = table0[m_finallap_prot_count&7];
mFinalLapProtCount++; m_finallap_prot_count++;
data = (data&0x00ff)<<8; data = (data&0x00ff)<<8;
break; break;
@ -78,30 +67,27 @@ READ16_MEMBER( namcos2_state::namcos2_finallap_prot_r )
/* Perform basic machine initialisation */ /* Perform basic machine initialisation */
/*************************************************************/ /*************************************************************/
#define namcos2_eeprom_size 0x2000 #define m_eeprom_size 0x2000
static void void namcos2_shared_state::reset_all_subcpus(int state)
ResetAllSubCPUs( running_machine &machine, int state )
{ {
namcos2_shared_state *s2state = machine.driver_data<namcos2_shared_state>(); m_slave->set_input_line(INPUT_LINE_RESET, state);
if (m_c68)
s2state->m_slave->set_input_line(INPUT_LINE_RESET, state);
if (s2state->m_c68)
{ {
s2state->m_c68->set_input_line(INPUT_LINE_RESET, state); m_c68->set_input_line(INPUT_LINE_RESET, state);
} }
else else
{ {
s2state->m_mcu->set_input_line(INPUT_LINE_RESET, state); m_mcu->set_input_line(INPUT_LINE_RESET, state);
} }
switch( machine.driver_data<namcos2_shared_state>()->m_gametype ) switch( m_gametype )
{ {
case NAMCOS21_SOLVALOU: case NAMCOS21_SOLVALOU:
case NAMCOS21_STARBLADE: case NAMCOS21_STARBLADE:
case NAMCOS21_AIRCOMBAT: case NAMCOS21_AIRCOMBAT:
case NAMCOS21_CYBERSLED: case NAMCOS21_CYBERSLED:
s2state->m_dspmaster->set_input_line(INPUT_LINE_RESET, state); m_dspmaster->set_input_line(INPUT_LINE_RESET, state);
s2state->m_dspslave->set_input_line(INPUT_LINE_RESET, state); m_dspslave->set_input_line(INPUT_LINE_RESET, state);
break; break;
// case NAMCOS21_WINRUN91: // case NAMCOS21_WINRUN91:
@ -114,21 +100,19 @@ ResetAllSubCPUs( running_machine &machine, int state )
MACHINE_START_MEMBER(namcos2_shared_state,namcos2) MACHINE_START_MEMBER(namcos2_shared_state,namcos2)
{ {
namcos2_kickstart = NULL; namcos2_kickstart = NULL;
namcos2_eeprom = auto_alloc_array(machine(), UINT8, namcos2_eeprom_size); m_eeprom = auto_alloc_array(machine(), UINT8, m_eeprom_size);
machine().device<nvram_device>("nvram")->set_base(namcos2_eeprom, namcos2_eeprom_size); machine().device<nvram_device>("nvram")->set_base(m_eeprom, m_eeprom_size);
namcos2_posirq_timer = machine().scheduler().timer_alloc(timer_expired_delegate(FUNC(namcos2_shared_state::namcos2_posirq_tick),this)); m_posirq_timer = machine().scheduler().timer_alloc(timer_expired_delegate(FUNC(namcos2_shared_state::namcos2_posirq_tick),this));
} }
MACHINE_RESET_MEMBER(namcos2_shared_state,namcos2) MACHINE_RESET_MEMBER(namcos2_shared_state, namcos2)
{ {
// address_space &space = m_maincpu->space(AS_PROGRAM); // address_space &space = m_maincpu->space(AS_PROGRAM);
address_space &audio_space = m_audiocpu->space(AS_PROGRAM); address_space &audio_space = m_audiocpu->space(AS_PROGRAM);
mFinalLapProtCount = 0; m_mcu_analog_ctrl = 0;
namcos2_mcu_analog_ctrl = 0; m_mcu_analog_data = 0xaa;
namcos2_mcu_analog_data = 0xaa; m_mcu_analog_complete = 0;
namcos2_mcu_analog_complete = 0;
sendval = 0;
/* Initialise the bank select in the sound CPU */ /* Initialise the bank select in the sound CPU */
namcos2_sound_bankselect_w(audio_space, 0, 0); /* Page in bank 0 */ namcos2_sound_bankselect_w(audio_space, 0, 0); /* Page in bank 0 */
@ -136,13 +120,13 @@ MACHINE_RESET_MEMBER(namcos2_shared_state,namcos2)
m_audiocpu->set_input_line(INPUT_LINE_RESET, ASSERT_LINE ); m_audiocpu->set_input_line(INPUT_LINE_RESET, ASSERT_LINE );
/* Place CPU2 & CPU3 into the reset condition */ /* Place CPU2 & CPU3 into the reset condition */
ResetAllSubCPUs( machine(), ASSERT_LINE ); reset_all_subcpus(ASSERT_LINE);
/* Initialise interrupt handlers */ /* Initialise interrupt handlers */
InitC148(); init_c148();
/* reset POSIRQ timer */ /* reset POSIRQ timer */
namcos2_posirq_timer->adjust(attotime::never); m_posirq_timer->adjust(attotime::never);
m_player_mux = 0; m_player_mux = 0;
} }
@ -153,12 +137,12 @@ MACHINE_RESET_MEMBER(namcos2_shared_state,namcos2)
WRITE8_MEMBER( namcos2_shared_state::namcos2_68k_eeprom_w ) WRITE8_MEMBER( namcos2_shared_state::namcos2_68k_eeprom_w )
{ {
namcos2_eeprom[offset] = data; m_eeprom[offset] = data;
} }
READ8_MEMBER( namcos2_shared_state::namcos2_68k_eeprom_r ) READ8_MEMBER( namcos2_shared_state::namcos2_68k_eeprom_r )
{ {
return namcos2_eeprom[offset]; return m_eeprom[offset];
} }
@ -301,7 +285,7 @@ READ16_MEMBER( namcos2_state::namcos2_68k_key_r )
case 1: return 0x110; case 1: return 0x110;
case 4: return 0xBE; case 4: return 0xBE;
case 6: return 0x1001; case 6: return 0x1001;
case 7: return (sendval==1)?0xBE:1; case 7: return (m_sendval==1)?0xBE:1;
} }
break; break;
@ -316,14 +300,14 @@ READ16_MEMBER( namcos2_state::namcos2_68k_key_r )
switch(offset) switch(offset)
{ {
case 4: case 4:
if( sendval == 1 ){ if( m_sendval == 1 ){
sendval = 0; m_sendval = 0;
return 0x13F; return 0x13F;
} }
break; break;
case 7: case 7:
if( sendval == 1 ){ if( m_sendval == 1 ){
sendval = 0; m_sendval = 0;
return 0x13F; return 0x13F;
} }
break; break;
@ -408,19 +392,19 @@ WRITE16_MEMBER( namcos2_state::namcos2_68k_key_w )
int gametype = m_gametype; int gametype = m_gametype;
if( gametype == NAMCOS2_MARVEL_LAND && offset == 5 ) if( gametype == NAMCOS2_MARVEL_LAND && offset == 5 )
{ {
if (data == 0x615E) sendval = 1; if (data == 0x615E) m_sendval = 1;
} }
if( gametype == NAMCOS2_ROLLING_THUNDER_2 && offset == 4 ) if( gametype == NAMCOS2_ROLLING_THUNDER_2 && offset == 4 )
{ {
if (data == 0x13EC) sendval = 1; if (data == 0x13EC) m_sendval = 1;
} }
if( gametype == NAMCOS2_ROLLING_THUNDER_2 && offset == 7 ) if( gametype == NAMCOS2_ROLLING_THUNDER_2 && offset == 7 )
{ {
if (data == 0x13EC) sendval = 1; if (data == 0x13EC) m_sendval = 1;
} }
if( gametype == NAMCOS2_MARVEL_LAND && offset == 6 ) if( gametype == NAMCOS2_MARVEL_LAND && offset == 6 )
{ {
if (data == 0x1001) sendval = 0; if (data == 0x1001) m_sendval = 0;
} }
} }
@ -432,10 +416,6 @@ WRITE16_MEMBER( namcos2_state::namcos2_68k_key_w )
#define FRAME_TIME (1.0/60.0) #define FRAME_TIME (1.0/60.0)
#define LINE_LENGTH (FRAME_TIME/NO_OF_LINES) #define LINE_LENGTH (FRAME_TIME/NO_OF_LINES)
static UINT16 namcos2_68k_master_C148[0x20];
static UINT16 namcos2_68k_slave_C148[0x20];
static UINT16 namcos2_68k_gpu_C148[0x20];
bool namcos2_shared_state::is_system21() bool namcos2_shared_state::is_system21()
{ {
@ -453,20 +433,17 @@ bool namcos2_shared_state::is_system21()
} }
} }
static void InitC148(void) void namcos2_shared_state::init_c148()
{ {
int loop; for(int loop = 0; loop < 0x20; loop++)
for(loop = 0; loop < 0x20; loop++)
{ {
namcos2_68k_master_C148[loop] = 0; m_68k_master_C148[loop] = 0;
namcos2_68k_slave_C148[loop] = 0; m_68k_slave_C148[loop] = 0;
namcos2_68k_gpu_C148[loop] = 0; m_68k_gpu_C148[loop] = 0;
} }
} }
static UINT16 UINT16 namcos2_shared_state::readwrite_c148( address_space &space, offs_t offset, UINT16 data, int bWrite )
ReadWriteC148( address_space &space, offs_t offset, UINT16 data, int bWrite )
{ {
offs_t addr = ((offset * 2) + 0x1c0000) & 0x1fe000; offs_t addr = ((offset * 2) + 0x1c0000) & 0x1fe000;
device_t *altcpu = NULL; device_t *altcpu = NULL;
@ -476,21 +453,21 @@ ReadWriteC148( address_space &space, offs_t offset, UINT16 data, int bWrite )
if (&space.device() == space.machine().device("maincpu")) if (&space.device() == space.machine().device("maincpu"))
{ {
pC148Reg = namcos2_68k_master_C148; pC148Reg = m_68k_master_C148;
altcpu = space.machine().device("slave"); altcpu = space.machine().device("slave");
pC148RegAlt = namcos2_68k_slave_C148; pC148RegAlt = m_68k_slave_C148;
} }
else if (&space.device() == space.machine().device("slave")) else if (&space.device() == space.machine().device("slave"))
{ {
pC148Reg = namcos2_68k_slave_C148; pC148Reg = m_68k_slave_C148;
altcpu = space.machine().device("maincpu"); altcpu = space.machine().device("maincpu");
pC148RegAlt = namcos2_68k_master_C148; pC148RegAlt = m_68k_master_C148;
} }
else if (&space.device() == space.machine().device("gpu")) else if (&space.device() == space.machine().device("gpu"))
{ {
pC148Reg = namcos2_68k_gpu_C148; pC148Reg = m_68k_gpu_C148;
altcpu = space.machine().device("maincpu"); altcpu = space.machine().device("maincpu");
pC148RegAlt = namcos2_68k_master_C148; pC148RegAlt = m_68k_master_C148;
} }
if( bWrite ) if( bWrite )
@ -600,13 +577,13 @@ ReadWriteC148( address_space &space, offs_t offset, UINT16 data, int bWrite )
{ {
if (data & 0x01) if (data & 0x01)
{ /* Resume execution */ { /* Resume execution */
ResetAllSubCPUs(space.machine(), CLEAR_LINE); reset_all_subcpus(CLEAR_LINE);
/* Give the new CPU an immediate slice of the action */ /* Give the new CPU an immediate slice of the action */
space.device().execute().yield(); space.device().execute().yield();
} }
else else
{ /* Suspend execution */ { /* Suspend execution */
ResetAllSubCPUs(space.machine(), ASSERT_LINE); reset_all_subcpus(ASSERT_LINE);
} }
} }
break; break;
@ -623,85 +600,85 @@ ReadWriteC148( address_space &space, offs_t offset, UINT16 data, int bWrite )
WRITE16_MEMBER( namcos2_shared_state::namcos2_68k_master_C148_w ) WRITE16_MEMBER( namcos2_shared_state::namcos2_68k_master_C148_w )
{ {
(void)ReadWriteC148(space, offset, data, 1); (void)readwrite_c148(space, offset, data, 1);
} }
READ16_MEMBER( namcos2_shared_state::namcos2_68k_master_C148_r ) READ16_MEMBER( namcos2_shared_state::namcos2_68k_master_C148_r )
{ {
return ReadWriteC148(space, offset, 0, 0); return readwrite_c148(space, offset, 0, 0);
} }
WRITE16_MEMBER( namcos2_shared_state::namcos2_68k_slave_C148_w ) WRITE16_MEMBER( namcos2_shared_state::namcos2_68k_slave_C148_w )
{ {
(void)ReadWriteC148(space, offset, data, 1); (void)readwrite_c148(space, offset, data, 1);
} }
READ16_MEMBER( namcos2_shared_state::namcos2_68k_slave_C148_r ) READ16_MEMBER( namcos2_shared_state::namcos2_68k_slave_C148_r )
{ {
return ReadWriteC148(space, offset, 0, 0); return readwrite_c148(space, offset, 0, 0);
} }
WRITE16_MEMBER( namcos2_shared_state::namcos21_68k_gpu_C148_w ) WRITE16_MEMBER( namcos2_shared_state::namcos21_68k_gpu_C148_w )
{ {
(void)ReadWriteC148(space, offset, data, 1); (void)readwrite_c148(space, offset, data, 1);
} }
READ16_MEMBER( namcos2_shared_state::namcos21_68k_gpu_C148_r ) READ16_MEMBER( namcos2_shared_state::namcos21_68k_gpu_C148_r )
{ {
return ReadWriteC148(space, offset, 0, 0); return readwrite_c148(space, offset, 0, 0);
} }
static int GetPosIRQScanline( running_machine &machine ) int namcos2_shared_state::get_posirq_scanline()
{ {
namcos2_shared_state *state = machine.driver_data<namcos2_shared_state>(); namcos2_state *s2state = machine().driver_data<namcos2_state>();
if (state->is_system21()) return 0; if (is_system21()) return 0;
return downcast<namcos2_state *>(state)->get_pos_irq_scanline(); return s2state->get_pos_irq_scanline();
} }
TIMER_CALLBACK_MEMBER(namcos2_shared_state::namcos2_posirq_tick) TIMER_CALLBACK_MEMBER(namcos2_shared_state::namcos2_posirq_tick)
{ {
if (is_system21()) { if (is_system21()) {
if (namcos2_68k_gpu_C148[NAMCOS2_C148_POSIRQ]) { if (m_68k_gpu_C148[NAMCOS2_C148_POSIRQ]) {
m_screen->update_partial(param); m_screen->update_partial(param);
machine().device("gpu")->execute().set_input_line(namcos2_68k_gpu_C148[NAMCOS2_C148_POSIRQ] , ASSERT_LINE); machine().device("gpu")->execute().set_input_line(m_68k_gpu_C148[NAMCOS2_C148_POSIRQ] , ASSERT_LINE);
} }
return; return;
} }
if (namcos2_68k_master_C148[NAMCOS2_C148_POSIRQ]|namcos2_68k_slave_C148[NAMCOS2_C148_POSIRQ]) { if (m_68k_master_C148[NAMCOS2_C148_POSIRQ]|m_68k_slave_C148[NAMCOS2_C148_POSIRQ]) {
m_screen->update_partial(param); m_screen->update_partial(param);
if (namcos2_68k_master_C148[NAMCOS2_C148_POSIRQ]) m_maincpu->set_input_line(namcos2_68k_master_C148[NAMCOS2_C148_POSIRQ] , ASSERT_LINE); if (m_68k_master_C148[NAMCOS2_C148_POSIRQ]) m_maincpu->set_input_line(m_68k_master_C148[NAMCOS2_C148_POSIRQ] , ASSERT_LINE);
if (namcos2_68k_slave_C148[NAMCOS2_C148_POSIRQ]) m_slave->set_input_line(namcos2_68k_slave_C148[NAMCOS2_C148_POSIRQ] , ASSERT_LINE); if (m_68k_slave_C148[NAMCOS2_C148_POSIRQ]) m_slave->set_input_line(m_68k_slave_C148[NAMCOS2_C148_POSIRQ] , ASSERT_LINE);
} }
} }
void namcos2_shared_state::adjust_posirq_timer( int scanline ) void namcos2_shared_state::adjust_posirq_timer( int scanline )
{ {
namcos2_posirq_timer->adjust(m_screen->time_until_pos(scanline, 80), scanline); m_posirq_timer->adjust(m_screen->time_until_pos(scanline, 80), scanline);
} }
INTERRUPT_GEN_MEMBER(namcos2_shared_state::namcos2_68k_master_vblank) INTERRUPT_GEN_MEMBER(namcos2_shared_state::namcos2_68k_master_vblank)
{ {
if (!is_system21()) adjust_posirq_timer(GetPosIRQScanline(machine())); if (!is_system21()) adjust_posirq_timer(get_posirq_scanline());
device.execute().set_input_line(namcos2_68k_master_C148[NAMCOS2_C148_VBLANKIRQ], HOLD_LINE); device.execute().set_input_line(m_68k_master_C148[NAMCOS2_C148_VBLANKIRQ], HOLD_LINE);
} }
INTERRUPT_GEN_MEMBER(namcos2_shared_state::namcos2_68k_slave_vblank) INTERRUPT_GEN_MEMBER(namcos2_shared_state::namcos2_68k_slave_vblank)
{ {
if (!is_system21()) adjust_posirq_timer(GetPosIRQScanline(machine())); if (!is_system21()) adjust_posirq_timer(get_posirq_scanline());
device.execute().set_input_line(namcos2_68k_slave_C148[NAMCOS2_C148_VBLANKIRQ], HOLD_LINE); device.execute().set_input_line(m_68k_slave_C148[NAMCOS2_C148_VBLANKIRQ], HOLD_LINE);
} }
INTERRUPT_GEN_MEMBER(namcos2_shared_state::namcos2_68k_gpu_vblank) INTERRUPT_GEN_MEMBER(namcos2_shared_state::namcos2_68k_gpu_vblank)
{ {
/* only used by namcos21 */ /* only used by namcos21 */
int scanline = GetPosIRQScanline(machine()); int scanline = get_posirq_scanline();
scanline = 0x50+0x89; /* HACK for Winning Run */ scanline = 0x50+0x89; /* HACK for Winning Run */
//printf( "namcos2_68k_gpu_vblank(%d)\n",namcos2_68k_gpu_C148[NAMCOS2_C148_POSIRQ] ); //printf( "namcos2_68k_gpu_vblank(%d)\n",m_68k_gpu_C148[NAMCOS2_C148_POSIRQ] );
adjust_posirq_timer(scanline); adjust_posirq_timer(scanline);
device.execute().set_input_line(namcos2_68k_gpu_C148[NAMCOS2_C148_VBLANKIRQ], HOLD_LINE); device.execute().set_input_line(m_68k_gpu_C148[NAMCOS2_C148_VBLANKIRQ], HOLD_LINE);
} }
/**************************************************************/ /**************************************************************/
@ -724,7 +701,7 @@ WRITE8_MEMBER( namcos2_shared_state::namcos2_sound_bankselect_w )
WRITE8_MEMBER( namcos2_shared_state::namcos2_mcu_analog_ctrl_w ) WRITE8_MEMBER( namcos2_shared_state::namcos2_mcu_analog_ctrl_w )
{ {
namcos2_mcu_analog_ctrl = data & 0xff; m_mcu_analog_ctrl = data & 0xff;
/* Check if this is a start of conversion */ /* Check if this is a start of conversion */
/* Input ports 2 through 9 are the analog channels */ /* Input ports 2 through 9 are the analog channels */
@ -732,33 +709,33 @@ WRITE8_MEMBER( namcos2_shared_state::namcos2_mcu_analog_ctrl_w )
if(data & 0x40) if(data & 0x40)
{ {
/* Set the conversion complete flag */ /* Set the conversion complete flag */
namcos2_mcu_analog_complete = 2; m_mcu_analog_complete = 2;
/* We convert instantly, good eh! */ /* We convert instantly, good eh! */
switch((data>>2) & 0x07) switch((data>>2) & 0x07)
{ {
case 0: case 0:
namcos2_mcu_analog_data=ioport("AN0")->read(); m_mcu_analog_data=ioport("AN0")->read();
break; break;
case 1: case 1:
namcos2_mcu_analog_data=ioport("AN1")->read(); m_mcu_analog_data=ioport("AN1")->read();
break; break;
case 2: case 2:
namcos2_mcu_analog_data=ioport("AN2")->read(); m_mcu_analog_data=ioport("AN2")->read();
break; break;
case 3: case 3:
namcos2_mcu_analog_data=ioport("AN3")->read(); m_mcu_analog_data=ioport("AN3")->read();
break; break;
case 4: case 4:
namcos2_mcu_analog_data=ioport("AN4")->read(); m_mcu_analog_data=ioport("AN4")->read();
break; break;
case 5: case 5:
namcos2_mcu_analog_data=ioport("AN5")->read(); m_mcu_analog_data=ioport("AN5")->read();
break; break;
case 6: case 6:
namcos2_mcu_analog_data=ioport("AN6")->read(); m_mcu_analog_data=ioport("AN6")->read();
break; break;
case 7: case 7:
namcos2_mcu_analog_data=ioport("AN7")->read(); m_mcu_analog_data=ioport("AN7")->read();
break; break;
default: default:
output_set_value("anunk",data); output_set_value("anunk",data);
@ -769,7 +746,7 @@ WRITE8_MEMBER( namcos2_shared_state::namcos2_mcu_analog_ctrl_w )
if( m_gametype == NAMCOS2_DIRT_FOX || if( m_gametype == NAMCOS2_DIRT_FOX ||
m_gametype == NAMCOS2_DIRT_FOX_JP ) m_gametype == NAMCOS2_DIRT_FOX_JP )
{ {
namcos2_mcu_analog_data ^= 0x80; m_mcu_analog_data ^= 0x80;
} }
#endif #endif
/* If the interrupt enable bit is set trigger an A/D IRQ */ /* If the interrupt enable bit is set trigger an A/D IRQ */
@ -785,11 +762,11 @@ READ8_MEMBER( namcos2_shared_state::namcos2_mcu_analog_ctrl_r )
int data=0; int data=0;
/* ADEF flag is only cleared AFTER a read from control THEN a read from DATA */ /* ADEF flag is only cleared AFTER a read from control THEN a read from DATA */
if(namcos2_mcu_analog_complete==2) namcos2_mcu_analog_complete=1; if(m_mcu_analog_complete==2) m_mcu_analog_complete=1;
if(namcos2_mcu_analog_complete) data|=0x80; if(m_mcu_analog_complete) data|=0x80;
/* Mask on the lower 6 register bits, Irq EN/Channel/Clock */ /* Mask on the lower 6 register bits, Irq EN/Channel/Clock */
data|=namcos2_mcu_analog_ctrl&0x3f; data|=m_mcu_analog_ctrl&0x3f;
/* Return the value */ /* Return the value */
return data; return data;
} }
@ -800,8 +777,8 @@ WRITE8_MEMBER( namcos2_shared_state::namcos2_mcu_analog_port_w )
READ8_MEMBER( namcos2_shared_state::namcos2_mcu_analog_port_r ) READ8_MEMBER( namcos2_shared_state::namcos2_mcu_analog_port_r )
{ {
if(namcos2_mcu_analog_complete==1) namcos2_mcu_analog_complete=0; if(m_mcu_analog_complete==1) m_mcu_analog_complete=0;
return namcos2_mcu_analog_data; return m_mcu_analog_data;
} }
WRITE8_MEMBER( namcos2_shared_state::namcos2_mcu_port_d_w ) WRITE8_MEMBER( namcos2_shared_state::namcos2_mcu_port_d_w )

43
src/mame/video/namcos2.c
View File

@ -7,6 +7,7 @@
static void static void
TilemapCB( running_machine &machine, UINT16 code, int *tile, int *mask ) TilemapCB( running_machine &machine, UINT16 code, int *tile, int *mask )
//void namcos2_shared_state::tilemap_cb(UINT16 code, int *tile, int *mask)
{ {
*mask = code; *mask = code;
@ -23,7 +24,7 @@ TilemapCB( running_machine &machine, UINT16 code, int *tile, int *mask )
*tile = (code&0x07ff)|((code&0xc000)>>3)|((code&0x3800)<<2); *tile = (code&0x07ff)|((code&0xc000)>>3)|((code&0x3800)<<2);
break; break;
} }
} /* TilemapCB */ }
/** /**
* m_gfx_ctrl selects a bank of 128 sprites within spriteram * m_gfx_ctrl selects a bank of 128 sprites within spriteram
@ -39,20 +40,20 @@ TilemapCB( running_machine &machine, UINT16 code, int *tile, int *mask )
READ16_MEMBER( namcos2_state::gfx_ctrl_r ) READ16_MEMBER( namcos2_state::gfx_ctrl_r )
{ {
return m_gfx_ctrl; return m_gfx_ctrl;
} /* namcos2_gfx_ctrl_r */ }
WRITE16_MEMBER( namcos2_state::gfx_ctrl_w ) WRITE16_MEMBER( namcos2_state::gfx_ctrl_w )
{ {
COMBINE_DATA(&m_gfx_ctrl); COMBINE_DATA(&m_gfx_ctrl);
} /* namcos2_gfx_ctrl_w */ }
TILE_GET_INFO_MEMBER( namcos2_state::roz_tile_info ) TILE_GET_INFO_MEMBER( namcos2_state::roz_tile_info )
{ {
int tile = m_rozram[tile_index]; int tile = m_rozram[tile_index];
SET_TILE_INFO_MEMBER(3,tile,0/*color*/,0); SET_TILE_INFO_MEMBER(3,tile,0/*color*/,0);
} /* roz_tile_info */ }
struct RozParam struct roz_param
{ {
UINT32 size; UINT32 size;
UINT32 startx,starty; UINT32 startx,starty;
@ -62,7 +63,7 @@ struct RozParam
}; };
INLINE void INLINE void
DrawRozHelperBlock(const struct RozParam *rozInfo, int destx, int desty, draw_roz_helper_block(const struct roz_param *rozInfo, int destx, int desty,
int srcx, int srcy, int width, int height, int srcx, int srcy, int width, int height,
bitmap_ind16 &destbitmap, bitmap_ind8 &flagsbitmap, bitmap_ind16 &destbitmap, bitmap_ind8 &flagsbitmap,
bitmap_ind16 &srcbitmap, UINT32 size_mask) bitmap_ind16 &srcbitmap, UINT32 size_mask)
@ -109,15 +110,15 @@ DrawRozHelperBlock(const struct RozParam *rozInfo, int destx, int desty,
dest += dest_rowinc; dest += dest_rowinc;
desty++; desty++;
} }
} /* DrawRozHelperBlock */ }
static void static void
DrawRozHelper( draw_roz_helper(
screen_device &screen, screen_device &screen,
bitmap_ind16 &bitmap, bitmap_ind16 &bitmap,
tilemap_t *tmap, tilemap_t *tmap,
const rectangle &clip, const rectangle &clip,
const struct RozParam *rozInfo ) const struct roz_param *rozInfo )
{ {
tmap->set_palette_offset(rozInfo->color ); tmap->set_palette_offset(rozInfo->color );
@ -186,7 +187,7 @@ DrawRozHelper(
// Do the block columns // Do the block columns
for (j = 0; j < column_block_count; j++) for (j = 0; j < column_block_count; j++)
{ {
DrawRozHelperBlock(rozInfo, dx, desty, sx, sy, ROZ_BLOCK_SIZE, draw_roz_helper_block(rozInfo, dx, desty, sx, sy, ROZ_BLOCK_SIZE,
ROZ_BLOCK_SIZE, bitmap, flagsbitmap, srcbitmap, size_mask); ROZ_BLOCK_SIZE, bitmap, flagsbitmap, srcbitmap, size_mask);
// Increment to the next block column // Increment to the next block column
sx += row_block_size_incxx; sx += row_block_size_incxx;
@ -196,7 +197,7 @@ DrawRozHelper(
// Do the extra columns // Do the extra columns
if (column_extra_count) if (column_extra_count)
{ {
DrawRozHelperBlock(rozInfo, dx, desty, sx, sy, column_extra_count, draw_roz_helper_block(rozInfo, dx, desty, sx, sy, column_extra_count,
ROZ_BLOCK_SIZE, bitmap, flagsbitmap, srcbitmap, size_mask); ROZ_BLOCK_SIZE, bitmap, flagsbitmap, srcbitmap, size_mask);
} }
// Increment to the next row block // Increment to the next row block
@ -210,7 +211,7 @@ DrawRozHelper(
// Do the block columns // Do the block columns
for (i = 0; i < column_block_count; i++) for (i = 0; i < column_block_count; i++)
{ {
DrawRozHelperBlock(rozInfo, destx, desty, srcx, srcy, ROZ_BLOCK_SIZE, draw_roz_helper_block(rozInfo, destx, desty, srcx, srcy, ROZ_BLOCK_SIZE,
row_extra_count, bitmap, flagsbitmap, srcbitmap, size_mask); row_extra_count, bitmap, flagsbitmap, srcbitmap, size_mask);
srcx += row_block_size_incxx; srcx += row_block_size_incxx;
srcy += row_block_size_incxy; srcy += row_block_size_incxy;
@ -219,7 +220,7 @@ DrawRozHelper(
// Do the extra columns // Do the extra columns
if (column_extra_count) if (column_extra_count)
{ {
DrawRozHelperBlock(rozInfo, destx, desty, srcx, srcy, column_extra_count, draw_roz_helper_block(rozInfo, destx, desty, srcx, srcy, column_extra_count,
row_extra_count, bitmap, flagsbitmap, srcbitmap, size_mask); row_extra_count, bitmap, flagsbitmap, srcbitmap, size_mask);
} }
} }
@ -233,12 +234,12 @@ DrawRozHelper(
rozInfo->incyx, rozInfo->incyy, rozInfo->incyx, rozInfo->incyy,
rozInfo->wrap,0,0); // wrap, flags, pri rozInfo->wrap,0,0); // wrap, flags, pri
} }
} /* DrawRozHelper */ }
void namcos2_state::draw_roz(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect) void namcos2_state::draw_roz(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
{ {
const int xoffset = 38,yoffset = 0; const int xoffset = 38,yoffset = 0;
struct RozParam rozParam; struct roz_param rozParam;
rozParam.color = (m_gfx_ctrl & 0x0f00); rozParam.color = (m_gfx_ctrl & 0x0f00);
rozParam.incxx = (INT16)m_roz_ctrl[0]; rozParam.incxx = (INT16)m_roz_ctrl[0];
@ -282,7 +283,7 @@ void namcos2_state::draw_roz(screen_device &screen, bitmap_ind16 &bitmap, const
rozParam.incyx<<=8; rozParam.incyx<<=8;
rozParam.incyy<<=8; rozParam.incyy<<=8;
DrawRozHelper( screen, bitmap, m_tilemap_roz, cliprect, &rozParam ); draw_roz_helper( screen, bitmap, m_tilemap_roz, cliprect, &rozParam );
} }
WRITE16_MEMBER( namcos2_state::rozram_word_w ) WRITE16_MEMBER( namcos2_state::rozram_word_w )
@ -314,7 +315,7 @@ READ16_MEMBER( namcos2_state::paletteram_word_r )
if (offset > 0x180b) return 0xff; if (offset > 0x180b) return 0xff;
} }
return m_paletteram[offset]; return m_paletteram[offset];
} /* namcos2_68k_video_palette_r */ }
WRITE16_MEMBER( namcos2_state::paletteram_word_w ) WRITE16_MEMBER( namcos2_state::paletteram_word_w )
{ {
@ -361,7 +362,7 @@ WRITE16_MEMBER( namcos2_state::paletteram_word_w )
{ {
COMBINE_DATA(&m_paletteram[offset]); COMBINE_DATA(&m_paletteram[offset]);
} }
} /* namcos2_68k_video_palette_w */ }
inline void inline void
@ -382,7 +383,7 @@ namcos2_state::update_palette()
offset++; offset++;
} }
} }
} /* update_palette */ }
/**************************************************************************/ /**************************************************************************/
@ -413,7 +414,7 @@ void namcos2_state::apply_clip( rectangle &clip, const rectangle &cliprect )
clip.max_y = get_palette_register(3) - 0x21 - 1; clip.max_y = get_palette_register(3) - 0x21 - 1;
/* intersect with master clip rectangle */ /* intersect with master clip rectangle */
clip &= cliprect; clip &= cliprect;
} /* apply_clip */ }
UINT32 namcos2_state::screen_update(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect) UINT32 namcos2_state::screen_update(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
{ {
@ -482,7 +483,7 @@ void namcos2_state::video_start_luckywld()
{ {
c169_roz_init(1, "gfx5"); c169_roz_init(1, "gfx5");
} }
} /* luckywld */ }
UINT32 namcos2_state::screen_update_luckywld(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect) UINT32 namcos2_state::screen_update_luckywld(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
{ {

116
src/mame/video/namcos21.c
View File

@ -45,61 +45,55 @@ WRITE16_MEMBER(namcos21_state::winrun_gpu_videoram_w)
videoram[(offset+i)&0x7ffff] = color; videoram[(offset+i)&0x7ffff] = color;
} }
} }
} /* winrun_gpu_videoram_w */ }
READ16_MEMBER(namcos21_state::winrun_gpu_videoram_r) READ16_MEMBER(namcos21_state::winrun_gpu_videoram_r)
{ {
UINT8 *videoram = m_videoram; UINT8 *videoram = m_videoram;
return videoram[offset]<<8; return videoram[offset]<<8;
} /* winrun_gpu_videoram_r */ }
static void void namcos21_state::allocate_poly_framebuffer()
AllocatePolyFrameBuffer( running_machine &machine )
{ {
namcos21_state *state = machine.driver_data<namcos21_state>(); m_mpPolyFrameBufferZ = auto_alloc_array(machine(), UINT16, FRAMEBUFFER_SIZE_IN_BYTES/2 );
state->m_mpPolyFrameBufferZ = auto_alloc_array(machine, UINT16, FRAMEBUFFER_SIZE_IN_BYTES/2 ); m_mpPolyFrameBufferPens = auto_alloc_array(machine(), UINT16, FRAMEBUFFER_SIZE_IN_BYTES/2 );
state->m_mpPolyFrameBufferPens = auto_alloc_array(machine, UINT16, FRAMEBUFFER_SIZE_IN_BYTES/2 );
state->m_mpPolyFrameBufferZ2 = auto_alloc_array(machine, UINT16, FRAMEBUFFER_SIZE_IN_BYTES/2 ); m_mpPolyFrameBufferZ2 = auto_alloc_array(machine(), UINT16, FRAMEBUFFER_SIZE_IN_BYTES/2 );
state->m_mpPolyFrameBufferPens2 = auto_alloc_array(machine, UINT16, FRAMEBUFFER_SIZE_IN_BYTES/2 ); m_mpPolyFrameBufferPens2 = auto_alloc_array(machine(), UINT16, FRAMEBUFFER_SIZE_IN_BYTES/2 );
namcos21_ClearPolyFrameBuffer(machine); clear_poly_framebuffer();
namcos21_ClearPolyFrameBuffer(machine); clear_poly_framebuffer();
} /* AllocatePolyFrameBuffer */ }
void void namcos21_state::clear_poly_framebuffer()
namcos21_ClearPolyFrameBuffer( running_machine &machine )
{ {
namcos21_state *state = machine.driver_data<namcos21_state>();
int i;
UINT16 *temp2; UINT16 *temp2;
/* swap work and visible framebuffers */ /* swap work and visible framebuffers */
temp2 = state->m_mpPolyFrameBufferZ; temp2 = m_mpPolyFrameBufferZ;
state->m_mpPolyFrameBufferZ = state->m_mpPolyFrameBufferZ2; m_mpPolyFrameBufferZ = m_mpPolyFrameBufferZ2;
state->m_mpPolyFrameBufferZ2 = temp2; m_mpPolyFrameBufferZ2 = temp2;
temp2 = state->m_mpPolyFrameBufferPens; temp2 = m_mpPolyFrameBufferPens;
state->m_mpPolyFrameBufferPens = state->m_mpPolyFrameBufferPens2; m_mpPolyFrameBufferPens = m_mpPolyFrameBufferPens2;
state->m_mpPolyFrameBufferPens2 = temp2; m_mpPolyFrameBufferPens2 = temp2;
/* wipe work zbuffer */ /* wipe work zbuffer */
for( i=0; i<NAMCOS21_POLY_FRAME_WIDTH*NAMCOS21_POLY_FRAME_HEIGHT; i++ ) for( int i = 0; i < NAMCOS21_POLY_FRAME_WIDTH*NAMCOS21_POLY_FRAME_HEIGHT; i++ )
{ {
state->m_mpPolyFrameBufferZ[i] = 0x7fff; m_mpPolyFrameBufferZ[i] = 0x7fff;
} }
} /* namcos21_ClearPolyFrameBuffer */ }
static void void namcos21_state::copy_visible_poly_framebuffer(bitmap_ind16 &bitmap, const rectangle &clip, int zlo, int zhi)
CopyVisiblePolyFrameBuffer( running_machine &machine, bitmap_ind16 &bitmap, const rectangle &clip, int zlo, int zhi )
{ {
namcos21_state *state = machine.driver_data<namcos21_state>(); /* blit the visible framebuffer */ /* blit the visible framebuffer */
int sy; int sy;
for( sy=clip.min_y; sy<=clip.max_y; sy++ ) for( sy=clip.min_y; sy<=clip.max_y; sy++ )
{ {
UINT16 *dest = &bitmap.pix16(sy); UINT16 *dest = &bitmap.pix16(sy);
const UINT16 *pPen = state->m_mpPolyFrameBufferPens2+NAMCOS21_POLY_FRAME_WIDTH*sy; const UINT16 *pPen = m_mpPolyFrameBufferPens2+NAMCOS21_POLY_FRAME_WIDTH*sy;
const UINT16 *pZ = state->m_mpPolyFrameBufferZ2+NAMCOS21_POLY_FRAME_WIDTH*sy; const UINT16 *pZ = m_mpPolyFrameBufferZ2+NAMCOS21_POLY_FRAME_WIDTH*sy;
int sx; int sx;
for( sx=clip.min_x; sx<=clip.max_x; sx++ ) for( sx=clip.min_x; sx<=clip.max_x; sx++ )
{ {
@ -111,7 +105,7 @@ CopyVisiblePolyFrameBuffer( running_machine &machine, bitmap_ind16 &bitmap, cons
} }
} }
} }
} /* CopyVisiblePolyFrameBuffer */ }
VIDEO_START_MEMBER(namcos21_state,namcos21) VIDEO_START_MEMBER(namcos21_state,namcos21)
{ {
@ -119,7 +113,7 @@ VIDEO_START_MEMBER(namcos21_state,namcos21)
{ {
m_videoram = auto_alloc_array(machine(), UINT8, 0x80000); m_videoram = auto_alloc_array(machine(), UINT8, 0x80000);
} }
AllocatePolyFrameBuffer(machine()); allocate_poly_framebuffer();
c355_obj_init( c355_obj_init(
0, /* gfx bank */ 0, /* gfx bank */
0xf, /* reverse palette mapping */ 0xf, /* reverse palette mapping */
@ -158,7 +152,7 @@ UINT32 namcos21_state::screen_update_namcos21(screen_device &screen, bitmap_ind1
c355_obj_draw(screen, bitmap, cliprect, 14 ); //driver's eyes c355_obj_draw(screen, bitmap, cliprect, 14 ); //driver's eyes
} }
CopyVisiblePolyFrameBuffer( machine(), bitmap, cliprect, 0x7fc0, 0x7ffe ); copy_visible_poly_framebuffer(bitmap, cliprect, 0x7fc0, 0x7ffe);
if( m_gametype != NAMCOS21_WINRUN91 ) if( m_gametype != NAMCOS21_WINRUN91 )
{ /* draw low priority 2d sprites */ { /* draw low priority 2d sprites */
@ -166,7 +160,7 @@ UINT32 namcos21_state::screen_update_namcos21(screen_device &screen, bitmap_ind1
c355_obj_draw(screen, bitmap, cliprect, 1 ); c355_obj_draw(screen, bitmap, cliprect, 1 );
} }
CopyVisiblePolyFrameBuffer( machine(), bitmap, cliprect, 0, 0x7fbf ); copy_visible_poly_framebuffer(bitmap, cliprect, 0, 0x7fbf);
if( m_gametype != NAMCOS21_WINRUN91 ) if( m_gametype != NAMCOS21_WINRUN91 )
@ -211,22 +205,9 @@ UINT32 namcos21_state::screen_update_namcos21(screen_device &screen, bitmap_ind1
/*********************************************************************************************/ /*********************************************************************************************/
struct vertex
{
double x,y;
double z;
};
struct edge
{
double x;
double z;
};
#define SWAP(T,A,B) { const T *temp = A; A = B; B = temp; } #define SWAP(T,A,B) { const T *temp = A; A = B; B = temp; }
static void void namcos21_state::renderscanline_flat(const edge *e1, const edge *e2, int sy, unsigned color, int depthcueenable)
renderscanline_flat( namcos21_state *state, const edge *e1, const edge *e2, int sy, unsigned color, int depthcueenable )
{ {
if( e1->x > e2->x ) if( e1->x > e2->x )
{ {
@ -234,8 +215,8 @@ renderscanline_flat( namcos21_state *state, const edge *e1, const edge *e2, int
} }
{ {
UINT16 *pDest = state->m_mpPolyFrameBufferPens + sy*NAMCOS21_POLY_FRAME_WIDTH; UINT16 *pDest = m_mpPolyFrameBufferPens + sy*NAMCOS21_POLY_FRAME_WIDTH;
UINT16 *pZBuf = state->m_mpPolyFrameBufferZ + sy*NAMCOS21_POLY_FRAME_WIDTH; UINT16 *pZBuf = m_mpPolyFrameBufferZ + sy*NAMCOS21_POLY_FRAME_WIDTH;
int x0 = (int)e1->x; int x0 = (int)e1->x;
int x1 = (int)e2->x; int x1 = (int)e2->x;
int w = x1-x0; int w = x1-x0;
@ -264,12 +245,12 @@ renderscanline_flat( namcos21_state *state, const edge *e1, const edge *e2, int
if( depthcueenable && zz>0 ) if( depthcueenable && zz>0 )
{ {
int depth = 0; int depth = 0;
if( state->m_gametype == NAMCOS21_WINRUN91 ) if( m_gametype == NAMCOS21_WINRUN91 )
{ {
depth = (zz>>10)*0x100; depth = (zz>>10)*0x100;
pen += depth; pen += depth;
} }
else if( state->m_gametype == NAMCOS21_DRIVERS_EYES ) else if( m_gametype == NAMCOS21_DRIVERS_EYES )
{ {
depth = (zz>>10)*0x100; depth = (zz>>10)*0x100;
pen -= depth; pen -= depth;
@ -287,16 +268,9 @@ renderscanline_flat( namcos21_state *state, const edge *e1, const edge *e2, int
} }
} }
} }
} /* renderscanline_flat */ }
static void void namcos21_state::rendertri(const vertex *v0, const vertex *v1, const vertex *v2, unsigned color, int depthcueenable)
rendertri(
namcos21_state *state,
const vertex *v0,
const vertex *v1,
const vertex *v2,
unsigned color,
int depthcueenable )
{ {
int dy,ystart,yend,crop; int dy,ystart,yend,crop;
@ -363,7 +337,7 @@ rendertri(
for( y=ystart; y<yend; y++ ) for( y=ystart; y<yend; y++ )
{ {
renderscanline_flat( state, &e1, &e2, y, color, depthcueenable ); renderscanline_flat(&e1, &e2, y, color, depthcueenable);
e2.x += dx2dy; e2.x += dx2dy;
e2.z += dz2dy; e2.z += dz2dy;
@ -397,7 +371,7 @@ rendertri(
} }
for( y=ystart; y<yend; y++ ) for( y=ystart; y<yend; y++ )
{ {
renderscanline_flat( state, &e1, &e2, y, color, depthcueenable ); renderscanline_flat(&e1, &e2, y, color, depthcueenable);
e2.x += dx2dy; e2.x += dx2dy;
e2.z += dz2dy; e2.z += dz2dy;
@ -407,12 +381,10 @@ rendertri(
} }
} }
} }
} /* rendertri */ }
void void namcos21_state::draw_quad(int sx[4], int sy[4], int zcode[4], int color)
namcos21_DrawQuad( running_machine &machine, int sx[4], int sy[4], int zcode[4], int color )
{ {
namcos21_state *state = machine.driver_data<namcos21_state>();
vertex a,b,c,d; vertex a,b,c,d;
int depthcueenable = 1; int depthcueenable = 1;
/* /*
@ -421,11 +393,11 @@ namcos21_DrawQuad( running_machine &machine, int sx[4], int sy[4], int zcode[4],
0x4000..0x5fff polygon palette bank1 (0x10 sets of 0x200 colors or 0x20 sets of 0x100 colors) 0x4000..0x5fff polygon palette bank1 (0x10 sets of 0x200 colors or 0x20 sets of 0x100 colors)
0x6000..0x7fff polygon palette bank2 (0x10 sets of 0x200 colors or 0x20 sets of 0x100 colors) 0x6000..0x7fff polygon palette bank2 (0x10 sets of 0x200 colors or 0x20 sets of 0x100 colors)
*/ */
if( state->m_gametype == NAMCOS21_WINRUN91 ) if( m_gametype == NAMCOS21_WINRUN91 )
{ {
color = 0x4000|(color&0xff); color = 0x4000|(color&0xff);
} }
else if ( state->m_gametype == NAMCOS21_DRIVERS_EYES ) else if ( m_gametype == NAMCOS21_DRIVERS_EYES )
{ {
color = 0x3f00|(color&0xff); color = 0x3f00|(color&0xff);
} }
@ -465,6 +437,6 @@ namcos21_DrawQuad( running_machine &machine, int sx[4], int sy[4], int zcode[4],
d.y = sy[3]; d.y = sy[3];
d.z = zcode[3]; d.z = zcode[3];
rendertri( state, &a, &b, &c, color, depthcueenable ); rendertri(&a, &b, &c, color, depthcueenable);
rendertri( state, &c, &d, &a, color, depthcueenable ); rendertri(&c, &d, &a, color, depthcueenable);
} /* namcos21_DrawQuad */ }