mirror of
https://github.com/holub/mame
synced 2025-07-04 09:28:51 +03:00
namcos2 and namcos21: moved most remaining functions into classes (nw).
This commit is contained in:
Ivan Vangelista
parent
bc00aadc06
commit
54c3e62516
@ -309,10 +309,9 @@ CPU68 PCB:
|
||||
#define ENABLE_LOGGING 0
|
||||
|
||||
|
||||
static INT32
|
||||
ReadPointROMData( running_machine &machine, unsigned offset )
|
||||
INT32 namcos21_state::read_pointrom_data(unsigned offset)
|
||||
{
|
||||
const INT32 *pPointData = (INT32 *)machine.root_device().memregion( "user2" )->base();
|
||||
const INT32 *pPointData = (INT32 *)memregion( "user2" )->base();
|
||||
INT32 result = pPointData[offset];
|
||||
return result;
|
||||
}
|
||||
@ -378,25 +377,22 @@ READ16_MEMBER(namcos21_state::dspcuskey_r)
|
||||
return result;
|
||||
}
|
||||
|
||||
static void
|
||||
TransmitWordToSlave( namcos21_state *state, UINT16 data )
|
||||
void namcos21_state::transmit_word_to_slave(UINT16 data)
|
||||
{
|
||||
unsigned offs = state->m_mpDspState->slaveInputStart+state->m_mpDspState->slaveBytesAvailable++;
|
||||
state->m_mpDspState->slaveInputBuffer[offs%DSP_BUF_MAX] = data;
|
||||
if (ENABLE_LOGGING) logerror( "+%04x(#%04x)\n", data, state->m_mpDspState->slaveBytesAvailable );
|
||||
state->m_mpDspState->slaveActive = 1;
|
||||
if( state->m_mpDspState->slaveBytesAvailable >= DSP_BUF_MAX )
|
||||
unsigned offs = m_mpDspState->slaveInputStart+m_mpDspState->slaveBytesAvailable++;
|
||||
m_mpDspState->slaveInputBuffer[offs%DSP_BUF_MAX] = data;
|
||||
if (ENABLE_LOGGING) logerror( "+%04x(#%04x)\n", data, m_mpDspState->slaveBytesAvailable );
|
||||
m_mpDspState->slaveActive = 1;
|
||||
if( m_mpDspState->slaveBytesAvailable >= DSP_BUF_MAX )
|
||||
{
|
||||
logerror( "IDC overflow\n" );
|
||||
exit(1);
|
||||
}
|
||||
} /* TransmitWordToSlave */
|
||||
}
|
||||
|
||||
static void
|
||||
TransferDspData( running_machine &machine )
|
||||
void namcos21_state::transfer_dsp_data()
|
||||
{
|
||||
namcos21_state *state = machine.driver_data<namcos21_state>();
|
||||
UINT16 addr = state->m_mpDspState->masterSourceAddr;
|
||||
UINT16 addr = m_mpDspState->masterSourceAddr;
|
||||
int mode = addr&0x8000;
|
||||
addr&=0x7fff;
|
||||
if( addr )
|
||||
@ -405,13 +401,13 @@ TransferDspData( running_machine &machine )
|
||||
{
|
||||
int i;
|
||||
UINT16 old = addr;
|
||||
UINT16 code = state->m_dspram16[addr++];
|
||||
UINT16 code = m_dspram16[addr++];
|
||||
if( code == 0xffff )
|
||||
{
|
||||
if( mode )
|
||||
{
|
||||
addr = state->m_dspram16[addr];
|
||||
state->m_mpDspState->masterSourceAddr = addr;
|
||||
addr = m_dspram16[addr];
|
||||
m_mpDspState->masterSourceAddr = addr;
|
||||
if (ENABLE_LOGGING) logerror( "LOOP:0x%04x\n", addr );
|
||||
addr&=0x7fff;
|
||||
if( old==addr )
|
||||
@ -421,59 +417,59 @@ TransferDspData( running_machine &machine )
|
||||
}
|
||||
else
|
||||
{
|
||||
state->m_mpDspState->masterSourceAddr = 0;
|
||||
m_mpDspState->masterSourceAddr = 0;
|
||||
return;
|
||||
}
|
||||
}
|
||||
else if( mode==0 )
|
||||
{ /* direct data transfer */
|
||||
if (ENABLE_LOGGING) logerror( "DATA TFR(0x%x)\n", code );
|
||||
TransmitWordToSlave( state, code );
|
||||
transmit_word_to_slave(code);
|
||||
for( i=0; i<code; i++ )
|
||||
{
|
||||
UINT16 data = state->m_dspram16[addr++];
|
||||
TransmitWordToSlave( state, data );
|
||||
UINT16 data = m_dspram16[addr++];
|
||||
transmit_word_to_slave(data);
|
||||
}
|
||||
}
|
||||
else if( code==0x18 || code==0x1a )
|
||||
{
|
||||
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++ )
|
||||
{
|
||||
UINT16 data = state->m_dspram16[addr++];
|
||||
TransmitWordToSlave( state, data );
|
||||
UINT16 data = m_dspram16[addr++];
|
||||
transmit_word_to_slave(data);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
INT32 masterAddr = ReadPointROMData(machine, code);
|
||||
INT32 masterAddr = read_pointrom_data(code);
|
||||
if (ENABLE_LOGGING) logerror( "OBJ TFR(0x%x)\n", code );
|
||||
{
|
||||
UINT16 len = state->m_dspram16[addr++];
|
||||
UINT16 len = m_dspram16[addr++];
|
||||
for(;;)
|
||||
{
|
||||
int subAddr = ReadPointROMData(machine, masterAddr++);
|
||||
int subAddr = read_pointrom_data(masterAddr++);
|
||||
if( subAddr==0xffffff )
|
||||
{
|
||||
break;
|
||||
}
|
||||
else
|
||||
{
|
||||
int primWords = (UINT16)ReadPointROMData(machine, subAddr++);
|
||||
int primWords = (UINT16)read_pointrom_data(subAddr++);
|
||||
if( primWords>2 )
|
||||
{
|
||||
TransmitWordToSlave( state, 0 ); /* pad1 */
|
||||
TransmitWordToSlave( state, len+1 );
|
||||
transmit_word_to_slave(0); /* pad1 */
|
||||
transmit_word_to_slave(len+1);
|
||||
for( i=0; i<len; i++ )
|
||||
{ /* transform */
|
||||
TransmitWordToSlave( state, state->m_dspram16[addr+i] );
|
||||
transmit_word_to_slave(m_dspram16[addr+i]);
|
||||
}
|
||||
TransmitWordToSlave( state, 0 ); /* pad2 */
|
||||
TransmitWordToSlave( state, primWords+1 );
|
||||
transmit_word_to_slave(0); /* pad2 */
|
||||
transmit_word_to_slave(primWords+1);
|
||||
for( i=0; i<primWords; i++ )
|
||||
{
|
||||
TransmitWordToSlave( state, (UINT16)ReadPointROMData(machine, subAddr+i) );
|
||||
transmit_word_to_slave((UINT16)read_pointrom_data(subAddr+i));
|
||||
}
|
||||
}
|
||||
else
|
||||
@ -487,34 +483,34 @@ TransferDspData( running_machine &machine )
|
||||
}
|
||||
} /* for(;;) */
|
||||
}
|
||||
} /* TransferDspData */
|
||||
}
|
||||
|
||||
|
||||
|
||||
void
|
||||
namcos21_kickstart( running_machine &machine, int internal )
|
||||
void namcos21_kickstart(running_machine &machine, int internal)
|
||||
{
|
||||
namcos21_state *state = machine.driver_data<namcos21_state>();
|
||||
|
||||
/* patch dsp watchdog */
|
||||
switch( state->m_gametype )
|
||||
{
|
||||
case NAMCOS21_AIRCOMBAT:
|
||||
state->m_master_dsp_code[0x008e] = 0x808f;
|
||||
break;
|
||||
case NAMCOS21_SOLVALOU:
|
||||
state->m_master_dsp_code[0x008b] = 0x808c;
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
case NAMCOS21_AIRCOMBAT:
|
||||
state->m_master_dsp_code[0x008e] = 0x808f;
|
||||
break;
|
||||
case NAMCOS21_SOLVALOU:
|
||||
state->m_master_dsp_code[0x008b] = 0x808c;
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
if( internal )
|
||||
{
|
||||
if( state->m_mbNeedsKickstart==0 ) return;
|
||||
state->m_mbNeedsKickstart--;
|
||||
state->m_mbNeedsKickstart--;
|
||||
if( state->m_mbNeedsKickstart ) return;
|
||||
}
|
||||
|
||||
namcos21_ClearPolyFrameBuffer(machine);
|
||||
state->clear_poly_framebuffer();
|
||||
state->m_mpDspState->masterSourceAddr = 0;
|
||||
state->m_mpDspState->slaveOutputSize = 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);
|
||||
}
|
||||
|
||||
static UINT16
|
||||
ReadWordFromSlaveInput( address_space &space )
|
||||
UINT16 namcos21_state::read_word_from_slave_input()
|
||||
{
|
||||
namcos21_state *state = space.machine().driver_data<namcos21_state>();
|
||||
UINT16 data = 0;
|
||||
if( state->m_mpDspState->slaveBytesAvailable>0 )
|
||||
if( m_mpDspState->slaveBytesAvailable>0 )
|
||||
{
|
||||
data = state->m_mpDspState->slaveInputBuffer[state->m_mpDspState->slaveInputStart++];
|
||||
state->m_mpDspState->slaveInputStart %= DSP_BUF_MAX;
|
||||
state->m_mpDspState->slaveBytesAvailable--;
|
||||
if( state->m_mpDspState->slaveBytesAdvertised>0 )
|
||||
data = m_mpDspState->slaveInputBuffer[m_mpDspState->slaveInputStart++];
|
||||
m_mpDspState->slaveInputStart %= DSP_BUF_MAX;
|
||||
m_mpDspState->slaveBytesAvailable--;
|
||||
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;
|
||||
} /* ReadWordFromSlaveInput */
|
||||
}
|
||||
|
||||
static size_t
|
||||
GetInputBytesAdvertisedForSlave( running_machine &machine )
|
||||
size_t namcos21_state::get_input_bytes_advertised_for_slave()
|
||||
{
|
||||
namcos21_state *state = machine.driver_data<namcos21_state>();
|
||||
if( state->m_mpDspState->slaveBytesAdvertised < state->m_mpDspState->slaveBytesAvailable )
|
||||
if( m_mpDspState->slaveBytesAdvertised < 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;
|
||||
} /* GetInputBytesAdvertisedForSlave */
|
||||
return m_mpDspState->slaveBytesAdvertised;
|
||||
}
|
||||
|
||||
READ16_MEMBER(namcos21_state::dspram16_r)
|
||||
{
|
||||
return m_dspram16[offset];
|
||||
} /* dspram16_r */
|
||||
}
|
||||
|
||||
WRITE16_MEMBER(namcos21_state::dspram16_w)
|
||||
{
|
||||
@ -572,7 +564,7 @@ WRITE16_MEMBER(namcos21_state::dspram16_w)
|
||||
offset == 1+(m_mpDspState->masterSourceAddr&0x7fff) )
|
||||
{
|
||||
if (ENABLE_LOGGING) logerror( "IDC-CONTINUE\n" );
|
||||
TransferDspData(machine());
|
||||
transfer_dsp_data();
|
||||
}
|
||||
else if (m_gametype == NAMCOS21_SOLVALOU &&
|
||||
offset == 0x103 &&
|
||||
@ -581,15 +573,13 @@ WRITE16_MEMBER(namcos21_state::dspram16_w)
|
||||
space.device().execute().yield();
|
||||
}
|
||||
}
|
||||
} /* dspram16_w */
|
||||
}
|
||||
|
||||
/************************************************************************************/
|
||||
|
||||
static int
|
||||
InitDSP( running_machine &machine )
|
||||
int namcos21_state::init_dsp()
|
||||
{
|
||||
namcos21_state *state = machine.driver_data<namcos21_state>();
|
||||
UINT16 *pMem = (UINT16 *)state->memregion("dspmaster")->base();
|
||||
UINT16 *pMem = (UINT16 *)memregion("dspmaster")->base();
|
||||
/**
|
||||
* DSP BIOS tests "CPU ID" on startup
|
||||
* "JAPAN (C)1990 NAMCO LTD. by H.F "
|
||||
@ -598,7 +588,7 @@ InitDSP( running_machine &machine )
|
||||
pMem[0x8000] = 0xFF80;
|
||||
pMem[0x8001] = 0x0000;
|
||||
|
||||
state->m_mpDspState = auto_alloc_clear(machine, dsp_state);
|
||||
m_mpDspState = auto_alloc_clear(machine(), dsp_state);
|
||||
|
||||
return 0;
|
||||
}
|
||||
@ -609,16 +599,16 @@ InitDSP( running_machine &machine )
|
||||
|
||||
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_mbPointRomDataAvailable = 1;
|
||||
return (UINT16)data;
|
||||
} /* dsp_port0_r */
|
||||
}
|
||||
|
||||
WRITE16_MEMBER(namcos21_state::dsp_port0_w)
|
||||
{ /* unused? */
|
||||
if (ENABLE_LOGGING) logerror( "PTRAM_LO(0x%04x)\n", data );
|
||||
} /* dsp_port0_w */
|
||||
}
|
||||
|
||||
READ16_MEMBER(namcos21_state::dsp_port1_r)
|
||||
{
|
||||
@ -628,44 +618,44 @@ READ16_MEMBER(namcos21_state::dsp_port1_r)
|
||||
return m_mPointRomMSB;
|
||||
}
|
||||
return 0x8000; /* IDC ack? */
|
||||
} /* dsp_port1_r */
|
||||
}
|
||||
|
||||
WRITE16_MEMBER(namcos21_state::dsp_port1_w)
|
||||
{ /* unused? */
|
||||
if (ENABLE_LOGGING) logerror( "PTRAM_HI(0x%04x)\n", data );
|
||||
} /* dsp_port1_w */
|
||||
}
|
||||
|
||||
READ16_MEMBER(namcos21_state::dsp_port2_r)
|
||||
{ /* IDC TRANSMIT ENABLE? */
|
||||
return 0;
|
||||
} /* dsp_port2_r */
|
||||
}
|
||||
|
||||
WRITE16_MEMBER(namcos21_state::dsp_port2_w)
|
||||
{
|
||||
if (ENABLE_LOGGING) logerror( "IDC ADDR INIT(0x%04x)\n", data );
|
||||
m_mpDspState->masterSourceAddr = data;
|
||||
TransferDspData(machine());
|
||||
} /* dsp_port2_w */
|
||||
transfer_dsp_data();
|
||||
}
|
||||
|
||||
READ16_MEMBER(namcos21_state::dsp_port3_idc_rcv_enable_r)
|
||||
{ /* IDC RECEIVE ENABLE? */
|
||||
return 0;
|
||||
} /* dsp_port3_idc_rcv_enable_r */
|
||||
}
|
||||
|
||||
WRITE16_MEMBER(namcos21_state::dsp_port3_w)
|
||||
{
|
||||
m_pointrom_idx<<=16;
|
||||
m_pointrom_idx|=data;
|
||||
} /* dsp_port3_w */
|
||||
}
|
||||
|
||||
WRITE16_MEMBER(namcos21_state::dsp_port4_w)
|
||||
{ /* receives $0B<<4 prior to IDC setup */
|
||||
} /* dsp_port4_w */
|
||||
}
|
||||
|
||||
READ16_MEMBER(namcos21_state::dsp_port8_r)
|
||||
{ /* SMU status */
|
||||
return 1;
|
||||
} /* dsp_port8_r */
|
||||
}
|
||||
|
||||
|
||||
WRITE16_MEMBER(namcos21_state::dsp_port8_w)
|
||||
@ -676,17 +666,17 @@ WRITE16_MEMBER(namcos21_state::dsp_port8_w)
|
||||
m_mpDspState->masterFinished = 1;
|
||||
}
|
||||
m_irq_enable = data;
|
||||
} /* dsp_port8_w */
|
||||
}
|
||||
|
||||
READ16_MEMBER(namcos21_state::dsp_port9_r)
|
||||
{ /* render-device-busy; used for direct-draw */
|
||||
return 0;
|
||||
} /* dsp_port9_r */
|
||||
}
|
||||
|
||||
READ16_MEMBER(namcos21_state::dsp_porta_r)
|
||||
{ /* config */
|
||||
return 0;
|
||||
} /* dsp_porta_r */
|
||||
}
|
||||
|
||||
WRITE16_MEMBER(namcos21_state::dsp_porta_w)
|
||||
{
|
||||
@ -696,12 +686,12 @@ WRITE16_MEMBER(namcos21_state::dsp_porta_w)
|
||||
/* direct-draw begin: 0 */
|
||||
/* INT1 begin: 1 */
|
||||
// if (ENABLE_LOGGING) logerror( "dsp_porta_w(0x%04x)\n", data );
|
||||
} /* dsp_porta_w */
|
||||
}
|
||||
|
||||
READ16_MEMBER(namcos21_state::dsp_portb_r)
|
||||
{ /* config */
|
||||
return 1;
|
||||
} /* dsp_portb_r */
|
||||
}
|
||||
|
||||
WRITE16_MEMBER(namcos21_state::dsp_portb_w)
|
||||
{
|
||||
@ -722,7 +712,7 @@ WRITE16_MEMBER(namcos21_state::dsp_portb_w)
|
||||
}
|
||||
if( color&0x8000 )
|
||||
{
|
||||
namcos21_DrawQuad( machine(), sx, sy, zcode, color );
|
||||
draw_quad(sx, sy, zcode, color);
|
||||
}
|
||||
else
|
||||
{
|
||||
@ -734,7 +724,7 @@ WRITE16_MEMBER(namcos21_state::dsp_portb_w)
|
||||
logerror( "unexpected masterDirectDrawSize=%d!\n",m_mpDspState->masterDirectDrawSize );
|
||||
}
|
||||
m_mpDspState->masterDirectDrawSize = 0;
|
||||
} /* dsp_portb_w */
|
||||
}
|
||||
|
||||
WRITE16_MEMBER(namcos21_state::dsp_portc_w)
|
||||
{
|
||||
@ -746,12 +736,12 @@ WRITE16_MEMBER(namcos21_state::dsp_portc_w)
|
||||
{
|
||||
logerror( "portc overflow\n" );
|
||||
}
|
||||
} /* dsp_portc_w */
|
||||
}
|
||||
|
||||
READ16_MEMBER(namcos21_state::dsp_portf_r)
|
||||
{ /* informs BIOS that this is Master DSP */
|
||||
return 0;
|
||||
} /* dsp_portf_r */
|
||||
}
|
||||
|
||||
WRITE16_MEMBER(namcos21_state::dsp_xf_w)
|
||||
{
|
||||
@ -787,22 +777,20 @@ ADDRESS_MAP_END
|
||||
|
||||
/************************************************************************************/
|
||||
|
||||
static void
|
||||
RenderSlaveOutput( running_machine &machine, UINT16 data )
|
||||
void namcos21_state::render_slave_output(UINT16 data)
|
||||
{
|
||||
namcos21_state *state = machine.driver_data<namcos21_state>();
|
||||
if( state->m_mpDspState->slaveOutputSize >= 4096 )
|
||||
if( 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 */
|
||||
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++;
|
||||
if( count && state->m_mpDspState->slaveOutputSize > count )
|
||||
if( count && m_mpDspState->slaveOutputSize > count )
|
||||
{
|
||||
UINT16 color = *pSource++;
|
||||
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];
|
||||
zcode[j] = pSource[3*j+2];
|
||||
}
|
||||
namcos21_DrawQuad( machine, sx, sy, zcode, color&0x7fff );
|
||||
draw_quad(sx, sy, zcode, color&0x7fff);
|
||||
}
|
||||
else
|
||||
{
|
||||
int quad_idx = color*6;
|
||||
for(;;)
|
||||
{
|
||||
UINT8 code = state->m_pointram[quad_idx++];
|
||||
color = state->m_pointram[quad_idx++]|(code<<8);
|
||||
UINT8 code = m_pointram[quad_idx++];
|
||||
color = m_pointram[quad_idx++]|(code<<8);
|
||||
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];
|
||||
sy[j] = NAMCOS21_POLY_FRAME_HEIGHT/2 + (INT16)pSource[vi*3+1];
|
||||
zcode[j] = pSource[vi*3+2];
|
||||
}
|
||||
namcos21_DrawQuad( machine, sx, sy, zcode, color&0x7fff );
|
||||
draw_quad(sx, sy, zcode, color&0x7fff);
|
||||
if( code&0x80 )
|
||||
{ /* end-of-quadlist marker */
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
state->m_mpDspState->slaveOutputSize = 0;
|
||||
m_mpDspState->slaveOutputSize = 0;
|
||||
}
|
||||
else if( count==0 )
|
||||
{
|
||||
@ -847,22 +835,22 @@ RenderSlaveOutput( running_machine &machine, UINT16 data )
|
||||
exit(1);
|
||||
}
|
||||
}
|
||||
} /* RenderSlaveOutput */
|
||||
}
|
||||
|
||||
READ16_MEMBER(namcos21_state::slave_port0_r)
|
||||
{
|
||||
return ReadWordFromSlaveInput(space);
|
||||
} /* slave_port0_r */
|
||||
return read_word_from_slave_input();
|
||||
}
|
||||
|
||||
WRITE16_MEMBER(namcos21_state::slave_port0_w)
|
||||
{
|
||||
RenderSlaveOutput( machine(), data );
|
||||
render_slave_output(data);
|
||||
}
|
||||
|
||||
READ16_MEMBER(namcos21_state::slave_port2_r)
|
||||
{
|
||||
return GetInputBytesAdvertisedForSlave(machine());
|
||||
} /* slave_port2_r */
|
||||
return get_input_bytes_advertised_for_slave();
|
||||
}
|
||||
|
||||
READ16_MEMBER(namcos21_state::slave_port3_r)
|
||||
{ /* render-device queue size */
|
||||
@ -874,12 +862,12 @@ READ16_MEMBER(namcos21_state::slave_port3_r)
|
||||
|
||||
WRITE16_MEMBER(namcos21_state::slave_port3_w)
|
||||
{ /* 0=busy, 1=ready? */
|
||||
} /* slave_port3_w */
|
||||
}
|
||||
|
||||
WRITE16_MEMBER(namcos21_state::slave_XF_output_w)
|
||||
{
|
||||
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)
|
||||
{ /* informs BIOS that this is Slave DSP */
|
||||
@ -957,12 +945,12 @@ WRITE16_MEMBER(namcos21_state::pointram_control_w)
|
||||
logerror( "\n" );
|
||||
#endif
|
||||
m_pointram_idx = 0; /* HACK */
|
||||
} /* pointram_control_w */
|
||||
}
|
||||
|
||||
READ16_MEMBER(namcos21_state::pointram_data_r)
|
||||
{
|
||||
return m_pointram[m_pointram_idx];
|
||||
} /* pointram_data_r */
|
||||
}
|
||||
|
||||
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_idx &= (PTRAM_SIZE-1);
|
||||
}
|
||||
} /* pointram_data_w */
|
||||
}
|
||||
|
||||
|
||||
READ16_MEMBER(namcos21_state::namcos21_depthcue_r)
|
||||
@ -1123,19 +1111,17 @@ READ16_MEMBER(namcos21_state::winrun_cuskey_r)
|
||||
break;
|
||||
}
|
||||
return 0;
|
||||
} /* winrun_cuskey_r */
|
||||
}
|
||||
|
||||
WRITE16_MEMBER(namcos21_state::winrun_cuskey_w)
|
||||
{
|
||||
} /* winrun_cuskey_w */
|
||||
}
|
||||
|
||||
static void
|
||||
winrun_flushpoly( running_machine &machine )
|
||||
void namcos21_state::winrun_flush_poly()
|
||||
{
|
||||
namcos21_state *state = machine.driver_data<namcos21_state>();
|
||||
if( state->m_winrun_poly_index>0 )
|
||||
if( m_winrun_poly_index>0 )
|
||||
{
|
||||
const UINT16 *pSource = state->m_winrun_poly_buf;
|
||||
const UINT16 *pSource = m_winrun_poly_buf;
|
||||
UINT16 color;
|
||||
int sx[4], sy[4], zcode[4];
|
||||
int j;
|
||||
@ -1148,36 +1134,36 @@ winrun_flushpoly( running_machine &machine )
|
||||
sy[j] = NAMCOS21_POLY_FRAME_HEIGHT/2 + (INT16)*pSource++;
|
||||
zcode[j] = *pSource++;
|
||||
}
|
||||
namcos21_DrawQuad( machine, sx, sy, zcode, color&0x7fff );
|
||||
draw_quad(sx, sy, zcode, color&0x7fff);
|
||||
}
|
||||
else
|
||||
{
|
||||
int quad_idx = color*6;
|
||||
for(;;)
|
||||
{
|
||||
UINT8 code = state->m_pointram[quad_idx++];
|
||||
color = state->m_pointram[quad_idx++];
|
||||
UINT8 code = m_pointram[quad_idx++];
|
||||
color = m_pointram[quad_idx++];
|
||||
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];
|
||||
sy[j] = NAMCOS21_POLY_FRAME_HEIGHT/2 + (INT16)pSource[vi*3+1];
|
||||
zcode[j] = pSource[vi*3+2];
|
||||
}
|
||||
namcos21_DrawQuad( machine, sx, sy, zcode, color&0x7fff );
|
||||
draw_quad(sx, sy, zcode, color&0x7fff);
|
||||
if( code&0x80 )
|
||||
{ /* end-of-quadlist marker */
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
state->m_winrun_poly_index = 0;
|
||||
m_winrun_poly_index = 0;
|
||||
}
|
||||
} /* winrun_flushpoly */
|
||||
|
||||
READ16_MEMBER(namcos21_state::winrun_poly_reset_r)
|
||||
{
|
||||
winrun_flushpoly(machine());
|
||||
winrun_flush_poly();
|
||||
return 0;
|
||||
}
|
||||
|
||||
@ -1191,7 +1177,7 @@ WRITE16_MEMBER(namcos21_state::winrun_dsp_render_w)
|
||||
{
|
||||
logerror( "WINRUN_POLY_OVERFLOW\n" );
|
||||
}
|
||||
} /* winrun_dsp_render_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();
|
||||
return ptrom[m_winrun_pointrom_addr++];
|
||||
} /* winrun_dsp_pointrom_data_r */
|
||||
}
|
||||
|
||||
WRITE16_MEMBER(namcos21_state::winrun_dsp_complete_w)
|
||||
{
|
||||
if( data )
|
||||
{
|
||||
winrun_flushpoly(machine());
|
||||
winrun_flush_poly();
|
||||
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 );
|
||||
m_winrun_dsp_alive = 1;
|
||||
}
|
||||
} /* winrun_dspbios_w */
|
||||
}
|
||||
|
||||
//380000 : read : dsp status? 1 = busy
|
||||
//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_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>();
|
||||
state->m_gametype = game_type;
|
||||
state->m_pointram = auto_alloc_array(machine, UINT8, PTRAM_SIZE);
|
||||
state->m_mpDataROM = (UINT16 *)state->memregion( "user1" )->base();
|
||||
InitDSP(machine);
|
||||
state->m_mbNeedsKickstart = 20;
|
||||
m_gametype = game_type;
|
||||
m_pointram = auto_alloc_array(machine(), UINT8, PTRAM_SIZE);
|
||||
m_mpDataROM = (UINT16 *)memregion( "user1" )->base();
|
||||
init_dsp();
|
||||
m_mbNeedsKickstart = 20;
|
||||
if( game_type==NAMCOS21_CYBERSLED )
|
||||
{
|
||||
state->m_mbNeedsKickstart = 200;
|
||||
m_mbNeedsKickstart = 200;
|
||||
}
|
||||
} /* namcos21_init */
|
||||
}
|
||||
|
||||
DRIVER_INIT_MEMBER(namcos21_state,winrun)
|
||||
{
|
||||
@ -2286,18 +2271,18 @@ DRIVER_INIT_MEMBER(namcos21_state,winrun)
|
||||
|
||||
DRIVER_INIT_MEMBER(namcos21_state,aircomb)
|
||||
{
|
||||
namcos21_init( machine(), NAMCOS21_AIRCOMBAT );
|
||||
init(NAMCOS21_AIRCOMBAT);
|
||||
}
|
||||
|
||||
DRIVER_INIT_MEMBER(namcos21_state,starblad)
|
||||
{
|
||||
namcos21_init( machine(), NAMCOS21_STARBLADE );
|
||||
init(NAMCOS21_STARBLADE);
|
||||
}
|
||||
|
||||
|
||||
DRIVER_INIT_MEMBER(namcos21_state,cybsled)
|
||||
{
|
||||
namcos21_init( machine(), NAMCOS21_CYBERSLED );
|
||||
init(NAMCOS21_CYBERSLED);
|
||||
}
|
||||
|
||||
DRIVER_INIT_MEMBER(namcos21_state,solvalou)
|
||||
@ -2308,7 +2293,7 @@ DRIVER_INIT_MEMBER(namcos21_state,solvalou)
|
||||
mem[0x20cf4/2+1] = 0x4e71;
|
||||
mem[0x20cf4/2+2] = 0x4e71;
|
||||
|
||||
namcos21_init( machine(), NAMCOS21_SOLVALOU );
|
||||
init(NAMCOS21_SOLVALOU );
|
||||
}
|
||||
|
||||
DRIVER_INIT_MEMBER(namcos21_state,driveyes)
|
||||
|
||||
@ -121,6 +121,15 @@ public:
|
||||
bool is_system21();
|
||||
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
|
||||
// TODO: merge with namcos1.c implementation and convert to device
|
||||
public:
|
||||
@ -210,6 +219,10 @@ public:
|
||||
INTERRUPT_GEN_MEMBER(namcos2_68k_gpu_vblank);
|
||||
TIMER_CALLBACK_MEMBER(namcos2_posirq_tick);
|
||||
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_READ8_MEMBER( namcos2_68k_eeprom_r );
|
||||
@ -338,6 +351,8 @@ public:
|
||||
tilemap_t *m_tilemap_roz;
|
||||
UINT16 m_gfx_ctrl;
|
||||
UINT16 m_serial_comms_ctrl[0x8];
|
||||
unsigned m_finallap_prot_count;
|
||||
int m_sendval;
|
||||
|
||||
optional_device<namco_c45_road_device> m_c45_road;
|
||||
|
||||
|
||||
@ -25,6 +25,19 @@ struct dsp_state
|
||||
int slaveActive;
|
||||
};
|
||||
|
||||
struct vertex
|
||||
{
|
||||
double x,y;
|
||||
double z;
|
||||
};
|
||||
|
||||
struct edge
|
||||
{
|
||||
double x;
|
||||
double z;
|
||||
};
|
||||
|
||||
|
||||
class namcos21_state : public namcos2_shared_state
|
||||
{
|
||||
public:
|
||||
@ -157,8 +170,19 @@ public:
|
||||
DECLARE_MACHINE_START(namcos21);
|
||||
DECLARE_VIDEO_START(namcos21);
|
||||
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 );
|
||||
|
||||
@ -16,19 +16,8 @@ Namco System II
|
||||
#include "machine/nvram.h"
|
||||
|
||||
|
||||
static void InitC148(void);
|
||||
|
||||
static emu_timer *namcos2_posirq_timer;
|
||||
|
||||
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 )
|
||||
{
|
||||
@ -47,24 +36,24 @@ READ16_MEMBER( namcos2_state::namcos2_finallap_prot_r )
|
||||
break;
|
||||
|
||||
case 2:
|
||||
data = table1[mFinalLapProtCount&7];
|
||||
data = table1[m_finallap_prot_count&7];
|
||||
data = (data&0xff00)>>8;
|
||||
break;
|
||||
|
||||
case 3:
|
||||
data = table1[mFinalLapProtCount&7];
|
||||
mFinalLapProtCount++;
|
||||
data = table1[m_finallap_prot_count&7];
|
||||
m_finallap_prot_count++;
|
||||
data = data&0x00ff;
|
||||
break;
|
||||
|
||||
case 0x3fffc/2:
|
||||
data = table0[mFinalLapProtCount&7];
|
||||
data = table0[m_finallap_prot_count&7];
|
||||
data = data&0xff00;
|
||||
break;
|
||||
|
||||
case 0x3fffe/2:
|
||||
data = table0[mFinalLapProtCount&7];
|
||||
mFinalLapProtCount++;
|
||||
data = table0[m_finallap_prot_count&7];
|
||||
m_finallap_prot_count++;
|
||||
data = (data&0x00ff)<<8;
|
||||
break;
|
||||
|
||||
@ -78,30 +67,27 @@ READ16_MEMBER( namcos2_state::namcos2_finallap_prot_r )
|
||||
/* Perform basic machine initialisation */
|
||||
/*************************************************************/
|
||||
|
||||
#define namcos2_eeprom_size 0x2000
|
||||
#define m_eeprom_size 0x2000
|
||||
|
||||
static void
|
||||
ResetAllSubCPUs( running_machine &machine, int state )
|
||||
void namcos2_shared_state::reset_all_subcpus(int state)
|
||||
{
|
||||
namcos2_shared_state *s2state = machine.driver_data<namcos2_shared_state>();
|
||||
|
||||
s2state->m_slave->set_input_line(INPUT_LINE_RESET, state);
|
||||
if (s2state->m_c68)
|
||||
m_slave->set_input_line(INPUT_LINE_RESET, state);
|
||||
if (m_c68)
|
||||
{
|
||||
s2state->m_c68->set_input_line(INPUT_LINE_RESET, state);
|
||||
m_c68->set_input_line(INPUT_LINE_RESET, state);
|
||||
}
|
||||
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_STARBLADE:
|
||||
case NAMCOS21_AIRCOMBAT:
|
||||
case NAMCOS21_CYBERSLED:
|
||||
s2state->m_dspmaster->set_input_line(INPUT_LINE_RESET, state);
|
||||
s2state->m_dspslave->set_input_line(INPUT_LINE_RESET, state);
|
||||
m_dspmaster->set_input_line(INPUT_LINE_RESET, state);
|
||||
m_dspslave->set_input_line(INPUT_LINE_RESET, state);
|
||||
break;
|
||||
|
||||
// case NAMCOS21_WINRUN91:
|
||||
@ -114,21 +100,19 @@ ResetAllSubCPUs( running_machine &machine, int state )
|
||||
MACHINE_START_MEMBER(namcos2_shared_state,namcos2)
|
||||
{
|
||||
namcos2_kickstart = NULL;
|
||||
namcos2_eeprom = auto_alloc_array(machine(), UINT8, namcos2_eeprom_size);
|
||||
machine().device<nvram_device>("nvram")->set_base(namcos2_eeprom, namcos2_eeprom_size);
|
||||
namcos2_posirq_timer = machine().scheduler().timer_alloc(timer_expired_delegate(FUNC(namcos2_shared_state::namcos2_posirq_tick),this));
|
||||
m_eeprom = auto_alloc_array(machine(), UINT8, m_eeprom_size);
|
||||
machine().device<nvram_device>("nvram")->set_base(m_eeprom, m_eeprom_size);
|
||||
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 &audio_space = m_audiocpu->space(AS_PROGRAM);
|
||||
|
||||
mFinalLapProtCount = 0;
|
||||
namcos2_mcu_analog_ctrl = 0;
|
||||
namcos2_mcu_analog_data = 0xaa;
|
||||
namcos2_mcu_analog_complete = 0;
|
||||
sendval = 0;
|
||||
m_mcu_analog_ctrl = 0;
|
||||
m_mcu_analog_data = 0xaa;
|
||||
m_mcu_analog_complete = 0;
|
||||
|
||||
/* Initialise the bank select in the sound CPU */
|
||||
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 );
|
||||
|
||||
/* Place CPU2 & CPU3 into the reset condition */
|
||||
ResetAllSubCPUs( machine(), ASSERT_LINE );
|
||||
reset_all_subcpus(ASSERT_LINE);
|
||||
|
||||
/* Initialise interrupt handlers */
|
||||
InitC148();
|
||||
init_c148();
|
||||
|
||||
/* reset POSIRQ timer */
|
||||
namcos2_posirq_timer->adjust(attotime::never);
|
||||
m_posirq_timer->adjust(attotime::never);
|
||||
|
||||
m_player_mux = 0;
|
||||
}
|
||||
@ -153,12 +137,12 @@ MACHINE_RESET_MEMBER(namcos2_shared_state,namcos2)
|
||||
|
||||
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 )
|
||||
{
|
||||
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 4: return 0xBE;
|
||||
case 6: return 0x1001;
|
||||
case 7: return (sendval==1)?0xBE:1;
|
||||
case 7: return (m_sendval==1)?0xBE:1;
|
||||
}
|
||||
break;
|
||||
|
||||
@ -316,14 +300,14 @@ READ16_MEMBER( namcos2_state::namcos2_68k_key_r )
|
||||
switch(offset)
|
||||
{
|
||||
case 4:
|
||||
if( sendval == 1 ){
|
||||
sendval = 0;
|
||||
if( m_sendval == 1 ){
|
||||
m_sendval = 0;
|
||||
return 0x13F;
|
||||
}
|
||||
break;
|
||||
case 7:
|
||||
if( sendval == 1 ){
|
||||
sendval = 0;
|
||||
if( m_sendval == 1 ){
|
||||
m_sendval = 0;
|
||||
return 0x13F;
|
||||
}
|
||||
break;
|
||||
@ -408,19 +392,19 @@ WRITE16_MEMBER( namcos2_state::namcos2_68k_key_w )
|
||||
int gametype = m_gametype;
|
||||
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 (data == 0x13EC) sendval = 1;
|
||||
if (data == 0x13EC) m_sendval = 1;
|
||||
}
|
||||
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 (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 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()
|
||||
{
|
||||
@ -453,20 +433,17 @@ bool namcos2_shared_state::is_system21()
|
||||
}
|
||||
}
|
||||
|
||||
static void InitC148(void)
|
||||
void namcos2_shared_state::init_c148()
|
||||
{
|
||||
int loop;
|
||||
|
||||
for(loop = 0; loop < 0x20; loop++)
|
||||
for(int loop = 0; loop < 0x20; loop++)
|
||||
{
|
||||
namcos2_68k_master_C148[loop] = 0;
|
||||
namcos2_68k_slave_C148[loop] = 0;
|
||||
namcos2_68k_gpu_C148[loop] = 0;
|
||||
m_68k_master_C148[loop] = 0;
|
||||
m_68k_slave_C148[loop] = 0;
|
||||
m_68k_gpu_C148[loop] = 0;
|
||||
}
|
||||
}
|
||||
|
||||
static UINT16
|
||||
ReadWriteC148( address_space &space, offs_t offset, UINT16 data, int bWrite )
|
||||
UINT16 namcos2_shared_state::readwrite_c148( address_space &space, offs_t offset, UINT16 data, int bWrite )
|
||||
{
|
||||
offs_t addr = ((offset * 2) + 0x1c0000) & 0x1fe000;
|
||||
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"))
|
||||
{
|
||||
pC148Reg = namcos2_68k_master_C148;
|
||||
pC148Reg = m_68k_master_C148;
|
||||
altcpu = space.machine().device("slave");
|
||||
pC148RegAlt = namcos2_68k_slave_C148;
|
||||
pC148RegAlt = m_68k_slave_C148;
|
||||
}
|
||||
else if (&space.device() == space.machine().device("slave"))
|
||||
{
|
||||
pC148Reg = namcos2_68k_slave_C148;
|
||||
pC148Reg = m_68k_slave_C148;
|
||||
altcpu = space.machine().device("maincpu");
|
||||
pC148RegAlt = namcos2_68k_master_C148;
|
||||
pC148RegAlt = m_68k_master_C148;
|
||||
}
|
||||
else if (&space.device() == space.machine().device("gpu"))
|
||||
{
|
||||
pC148Reg = namcos2_68k_gpu_C148;
|
||||
pC148Reg = m_68k_gpu_C148;
|
||||
altcpu = space.machine().device("maincpu");
|
||||
pC148RegAlt = namcos2_68k_master_C148;
|
||||
pC148RegAlt = m_68k_master_C148;
|
||||
}
|
||||
|
||||
if( bWrite )
|
||||
@ -600,13 +577,13 @@ ReadWriteC148( address_space &space, offs_t offset, UINT16 data, int bWrite )
|
||||
{
|
||||
if (data & 0x01)
|
||||
{ /* Resume execution */
|
||||
ResetAllSubCPUs(space.machine(), CLEAR_LINE);
|
||||
reset_all_subcpus(CLEAR_LINE);
|
||||
/* Give the new CPU an immediate slice of the action */
|
||||
space.device().execute().yield();
|
||||
}
|
||||
else
|
||||
{ /* Suspend execution */
|
||||
ResetAllSubCPUs(space.machine(), ASSERT_LINE);
|
||||
reset_all_subcpus(ASSERT_LINE);
|
||||
}
|
||||
}
|
||||
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 )
|
||||
{
|
||||
(void)ReadWriteC148(space, offset, data, 1);
|
||||
(void)readwrite_c148(space, offset, data, 1);
|
||||
}
|
||||
|
||||
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 )
|
||||
{
|
||||
(void)ReadWriteC148(space, offset, data, 1);
|
||||
(void)readwrite_c148(space, offset, data, 1);
|
||||
}
|
||||
|
||||
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 )
|
||||
{
|
||||
(void)ReadWriteC148(space, offset, data, 1);
|
||||
(void)readwrite_c148(space, offset, data, 1);
|
||||
}
|
||||
|
||||
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>();
|
||||
if (state->is_system21()) return 0;
|
||||
return downcast<namcos2_state *>(state)->get_pos_irq_scanline();
|
||||
namcos2_state *s2state = machine().driver_data<namcos2_state>();
|
||||
if (is_system21()) return 0;
|
||||
return s2state->get_pos_irq_scanline();
|
||||
}
|
||||
|
||||
TIMER_CALLBACK_MEMBER(namcos2_shared_state::namcos2_posirq_tick)
|
||||
{
|
||||
if (is_system21()) {
|
||||
if (namcos2_68k_gpu_C148[NAMCOS2_C148_POSIRQ]) {
|
||||
if (m_68k_gpu_C148[NAMCOS2_C148_POSIRQ]) {
|
||||
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;
|
||||
}
|
||||
|
||||
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);
|
||||
if (namcos2_68k_master_C148[NAMCOS2_C148_POSIRQ]) m_maincpu->set_input_line(namcos2_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_master_C148[NAMCOS2_C148_POSIRQ]) m_maincpu->set_input_line(m_68k_master_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 )
|
||||
{
|
||||
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)
|
||||
{
|
||||
if (!is_system21()) adjust_posirq_timer(GetPosIRQScanline(machine()));
|
||||
device.execute().set_input_line(namcos2_68k_master_C148[NAMCOS2_C148_VBLANKIRQ], HOLD_LINE);
|
||||
if (!is_system21()) adjust_posirq_timer(get_posirq_scanline());
|
||||
device.execute().set_input_line(m_68k_master_C148[NAMCOS2_C148_VBLANKIRQ], HOLD_LINE);
|
||||
}
|
||||
|
||||
INTERRUPT_GEN_MEMBER(namcos2_shared_state::namcos2_68k_slave_vblank)
|
||||
{
|
||||
if (!is_system21()) adjust_posirq_timer(GetPosIRQScanline(machine()));
|
||||
device.execute().set_input_line(namcos2_68k_slave_C148[NAMCOS2_C148_VBLANKIRQ], HOLD_LINE);
|
||||
if (!is_system21()) adjust_posirq_timer(get_posirq_scanline());
|
||||
device.execute().set_input_line(m_68k_slave_C148[NAMCOS2_C148_VBLANKIRQ], HOLD_LINE);
|
||||
}
|
||||
|
||||
INTERRUPT_GEN_MEMBER(namcos2_shared_state::namcos2_68k_gpu_vblank)
|
||||
{
|
||||
/* only used by namcos21 */
|
||||
int scanline = GetPosIRQScanline(machine());
|
||||
int scanline = get_posirq_scanline();
|
||||
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);
|
||||
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 )
|
||||
{
|
||||
namcos2_mcu_analog_ctrl = data & 0xff;
|
||||
m_mcu_analog_ctrl = data & 0xff;
|
||||
|
||||
/* Check if this is a start of conversion */
|
||||
/* 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)
|
||||
{
|
||||
/* Set the conversion complete flag */
|
||||
namcos2_mcu_analog_complete = 2;
|
||||
m_mcu_analog_complete = 2;
|
||||
/* We convert instantly, good eh! */
|
||||
switch((data>>2) & 0x07)
|
||||
{
|
||||
case 0:
|
||||
namcos2_mcu_analog_data=ioport("AN0")->read();
|
||||
m_mcu_analog_data=ioport("AN0")->read();
|
||||
break;
|
||||
case 1:
|
||||
namcos2_mcu_analog_data=ioport("AN1")->read();
|
||||
m_mcu_analog_data=ioport("AN1")->read();
|
||||
break;
|
||||
case 2:
|
||||
namcos2_mcu_analog_data=ioport("AN2")->read();
|
||||
m_mcu_analog_data=ioport("AN2")->read();
|
||||
break;
|
||||
case 3:
|
||||
namcos2_mcu_analog_data=ioport("AN3")->read();
|
||||
m_mcu_analog_data=ioport("AN3")->read();
|
||||
break;
|
||||
case 4:
|
||||
namcos2_mcu_analog_data=ioport("AN4")->read();
|
||||
m_mcu_analog_data=ioport("AN4")->read();
|
||||
break;
|
||||
case 5:
|
||||
namcos2_mcu_analog_data=ioport("AN5")->read();
|
||||
m_mcu_analog_data=ioport("AN5")->read();
|
||||
break;
|
||||
case 6:
|
||||
namcos2_mcu_analog_data=ioport("AN6")->read();
|
||||
m_mcu_analog_data=ioport("AN6")->read();
|
||||
break;
|
||||
case 7:
|
||||
namcos2_mcu_analog_data=ioport("AN7")->read();
|
||||
m_mcu_analog_data=ioport("AN7")->read();
|
||||
break;
|
||||
default:
|
||||
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 ||
|
||||
m_gametype == NAMCOS2_DIRT_FOX_JP )
|
||||
{
|
||||
namcos2_mcu_analog_data ^= 0x80;
|
||||
m_mcu_analog_data ^= 0x80;
|
||||
}
|
||||
#endif
|
||||
/* 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;
|
||||
|
||||
/* 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(namcos2_mcu_analog_complete) data|=0x80;
|
||||
if(m_mcu_analog_complete==2) m_mcu_analog_complete=1;
|
||||
if(m_mcu_analog_complete) data|=0x80;
|
||||
|
||||
/* 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 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 )
|
||||
{
|
||||
if(namcos2_mcu_analog_complete==1) namcos2_mcu_analog_complete=0;
|
||||
return namcos2_mcu_analog_data;
|
||||
if(m_mcu_analog_complete==1) m_mcu_analog_complete=0;
|
||||
return m_mcu_analog_data;
|
||||
}
|
||||
|
||||
WRITE8_MEMBER( namcos2_shared_state::namcos2_mcu_port_d_w )
|
||||
|
||||
@ -7,6 +7,7 @@
|
||||
|
||||
static void
|
||||
TilemapCB( running_machine &machine, UINT16 code, int *tile, int *mask )
|
||||
//void namcos2_shared_state::tilemap_cb(UINT16 code, int *tile, int *mask)
|
||||
{
|
||||
*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);
|
||||
break;
|
||||
}
|
||||
} /* TilemapCB */
|
||||
}
|
||||
|
||||
/**
|
||||
* 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 )
|
||||
{
|
||||
return m_gfx_ctrl;
|
||||
} /* namcos2_gfx_ctrl_r */
|
||||
}
|
||||
|
||||
WRITE16_MEMBER( namcos2_state::gfx_ctrl_w )
|
||||
{
|
||||
COMBINE_DATA(&m_gfx_ctrl);
|
||||
} /* namcos2_gfx_ctrl_w */
|
||||
}
|
||||
|
||||
TILE_GET_INFO_MEMBER( namcos2_state::roz_tile_info )
|
||||
{
|
||||
int tile = m_rozram[tile_index];
|
||||
SET_TILE_INFO_MEMBER(3,tile,0/*color*/,0);
|
||||
} /* roz_tile_info */
|
||||
}
|
||||
|
||||
struct RozParam
|
||||
struct roz_param
|
||||
{
|
||||
UINT32 size;
|
||||
UINT32 startx,starty;
|
||||
@ -62,7 +63,7 @@ struct RozParam
|
||||
};
|
||||
|
||||
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,
|
||||
bitmap_ind16 &destbitmap, bitmap_ind8 &flagsbitmap,
|
||||
bitmap_ind16 &srcbitmap, UINT32 size_mask)
|
||||
@ -109,15 +110,15 @@ DrawRozHelperBlock(const struct RozParam *rozInfo, int destx, int desty,
|
||||
dest += dest_rowinc;
|
||||
desty++;
|
||||
}
|
||||
} /* DrawRozHelperBlock */
|
||||
}
|
||||
|
||||
static void
|
||||
DrawRozHelper(
|
||||
draw_roz_helper(
|
||||
screen_device &screen,
|
||||
bitmap_ind16 &bitmap,
|
||||
tilemap_t *tmap,
|
||||
const rectangle &clip,
|
||||
const struct RozParam *rozInfo )
|
||||
const struct roz_param *rozInfo )
|
||||
{
|
||||
tmap->set_palette_offset(rozInfo->color );
|
||||
|
||||
@ -186,7 +187,7 @@ DrawRozHelper(
|
||||
// Do the block columns
|
||||
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);
|
||||
// Increment to the next block column
|
||||
sx += row_block_size_incxx;
|
||||
@ -196,7 +197,7 @@ DrawRozHelper(
|
||||
// Do the extra columns
|
||||
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);
|
||||
}
|
||||
// Increment to the next row block
|
||||
@ -210,7 +211,7 @@ DrawRozHelper(
|
||||
// Do the block columns
|
||||
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);
|
||||
srcx += row_block_size_incxx;
|
||||
srcy += row_block_size_incxy;
|
||||
@ -219,7 +220,7 @@ DrawRozHelper(
|
||||
// Do the extra columns
|
||||
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);
|
||||
}
|
||||
}
|
||||
@ -233,12 +234,12 @@ DrawRozHelper(
|
||||
rozInfo->incyx, rozInfo->incyy,
|
||||
rozInfo->wrap,0,0); // wrap, flags, pri
|
||||
}
|
||||
} /* DrawRozHelper */
|
||||
}
|
||||
|
||||
void namcos2_state::draw_roz(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
|
||||
{
|
||||
const int xoffset = 38,yoffset = 0;
|
||||
struct RozParam rozParam;
|
||||
struct roz_param rozParam;
|
||||
|
||||
rozParam.color = (m_gfx_ctrl & 0x0f00);
|
||||
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.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 )
|
||||
@ -314,7 +315,7 @@ READ16_MEMBER( namcos2_state::paletteram_word_r )
|
||||
if (offset > 0x180b) return 0xff;
|
||||
}
|
||||
return m_paletteram[offset];
|
||||
} /* namcos2_68k_video_palette_r */
|
||||
}
|
||||
|
||||
WRITE16_MEMBER( namcos2_state::paletteram_word_w )
|
||||
{
|
||||
@ -361,7 +362,7 @@ WRITE16_MEMBER( namcos2_state::paletteram_word_w )
|
||||
{
|
||||
COMBINE_DATA(&m_paletteram[offset]);
|
||||
}
|
||||
} /* namcos2_68k_video_palette_w */
|
||||
}
|
||||
|
||||
|
||||
inline void
|
||||
@ -382,7 +383,7 @@ namcos2_state::update_palette()
|
||||
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;
|
||||
/* intersect with master clip rectangle */
|
||||
clip &= cliprect;
|
||||
} /* apply_clip */
|
||||
}
|
||||
|
||||
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");
|
||||
}
|
||||
} /* luckywld */
|
||||
}
|
||||
|
||||
UINT32 namcos2_state::screen_update_luckywld(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
|
||||
{
|
||||
|
||||
@ -45,61 +45,55 @@ WRITE16_MEMBER(namcos21_state::winrun_gpu_videoram_w)
|
||||
videoram[(offset+i)&0x7ffff] = color;
|
||||
}
|
||||
}
|
||||
} /* winrun_gpu_videoram_w */
|
||||
}
|
||||
|
||||
READ16_MEMBER(namcos21_state::winrun_gpu_videoram_r)
|
||||
{
|
||||
UINT8 *videoram = m_videoram;
|
||||
return videoram[offset]<<8;
|
||||
} /* winrun_gpu_videoram_r */
|
||||
}
|
||||
|
||||
static void
|
||||
AllocatePolyFrameBuffer( running_machine &machine )
|
||||
void namcos21_state::allocate_poly_framebuffer()
|
||||
{
|
||||
namcos21_state *state = machine.driver_data<namcos21_state>();
|
||||
state->m_mpPolyFrameBufferZ = auto_alloc_array(machine, UINT16, FRAMEBUFFER_SIZE_IN_BYTES/2 );
|
||||
state->m_mpPolyFrameBufferPens = auto_alloc_array(machine, UINT16, FRAMEBUFFER_SIZE_IN_BYTES/2 );
|
||||
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_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_mpPolyFrameBufferZ2 = 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);
|
||||
namcos21_ClearPolyFrameBuffer(machine);
|
||||
} /* AllocatePolyFrameBuffer */
|
||||
clear_poly_framebuffer();
|
||||
clear_poly_framebuffer();
|
||||
}
|
||||
|
||||
void
|
||||
namcos21_ClearPolyFrameBuffer( running_machine &machine )
|
||||
void namcos21_state::clear_poly_framebuffer()
|
||||
{
|
||||
namcos21_state *state = machine.driver_data<namcos21_state>();
|
||||
int i;
|
||||
UINT16 *temp2;
|
||||
|
||||
/* swap work and visible framebuffers */
|
||||
temp2 = state->m_mpPolyFrameBufferZ;
|
||||
state->m_mpPolyFrameBufferZ = state->m_mpPolyFrameBufferZ2;
|
||||
state->m_mpPolyFrameBufferZ2 = temp2;
|
||||
temp2 = m_mpPolyFrameBufferZ;
|
||||
m_mpPolyFrameBufferZ = m_mpPolyFrameBufferZ2;
|
||||
m_mpPolyFrameBufferZ2 = temp2;
|
||||
|
||||
temp2 = state->m_mpPolyFrameBufferPens;
|
||||
state->m_mpPolyFrameBufferPens = state->m_mpPolyFrameBufferPens2;
|
||||
state->m_mpPolyFrameBufferPens2 = temp2;
|
||||
temp2 = m_mpPolyFrameBufferPens;
|
||||
m_mpPolyFrameBufferPens = m_mpPolyFrameBufferPens2;
|
||||
m_mpPolyFrameBufferPens2 = temp2;
|
||||
|
||||
/* 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
|
||||
CopyVisiblePolyFrameBuffer( running_machine &machine, bitmap_ind16 &bitmap, const rectangle &clip, int zlo, int zhi )
|
||||
void namcos21_state::copy_visible_poly_framebuffer(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;
|
||||
for( sy=clip.min_y; sy<=clip.max_y; sy++ )
|
||||
{
|
||||
UINT16 *dest = &bitmap.pix16(sy);
|
||||
const UINT16 *pPen = state->m_mpPolyFrameBufferPens2+NAMCOS21_POLY_FRAME_WIDTH*sy;
|
||||
const UINT16 *pZ = state->m_mpPolyFrameBufferZ2+NAMCOS21_POLY_FRAME_WIDTH*sy;
|
||||
const UINT16 *pPen = m_mpPolyFrameBufferPens2+NAMCOS21_POLY_FRAME_WIDTH*sy;
|
||||
const UINT16 *pZ = m_mpPolyFrameBufferZ2+NAMCOS21_POLY_FRAME_WIDTH*sy;
|
||||
int 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)
|
||||
{
|
||||
@ -119,7 +113,7 @@ VIDEO_START_MEMBER(namcos21_state,namcos21)
|
||||
{
|
||||
m_videoram = auto_alloc_array(machine(), UINT8, 0x80000);
|
||||
}
|
||||
AllocatePolyFrameBuffer(machine());
|
||||
allocate_poly_framebuffer();
|
||||
c355_obj_init(
|
||||
0, /* gfx bank */
|
||||
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
|
||||
}
|
||||
|
||||
CopyVisiblePolyFrameBuffer( machine(), bitmap, cliprect, 0x7fc0, 0x7ffe );
|
||||
copy_visible_poly_framebuffer(bitmap, cliprect, 0x7fc0, 0x7ffe);
|
||||
|
||||
if( m_gametype != NAMCOS21_WINRUN91 )
|
||||
{ /* 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 );
|
||||
}
|
||||
|
||||
CopyVisiblePolyFrameBuffer( machine(), bitmap, cliprect, 0, 0x7fbf );
|
||||
copy_visible_poly_framebuffer(bitmap, cliprect, 0, 0x7fbf);
|
||||
|
||||
|
||||
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; }
|
||||
|
||||
static void
|
||||
renderscanline_flat( namcos21_state *state, const edge *e1, const edge *e2, int sy, unsigned color, int depthcueenable )
|
||||
void namcos21_state::renderscanline_flat(const edge *e1, const edge *e2, int sy, unsigned color, int depthcueenable)
|
||||
{
|
||||
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 *pZBuf = state->m_mpPolyFrameBufferZ + sy*NAMCOS21_POLY_FRAME_WIDTH;
|
||||
UINT16 *pDest = m_mpPolyFrameBufferPens + sy*NAMCOS21_POLY_FRAME_WIDTH;
|
||||
UINT16 *pZBuf = m_mpPolyFrameBufferZ + sy*NAMCOS21_POLY_FRAME_WIDTH;
|
||||
int x0 = (int)e1->x;
|
||||
int x1 = (int)e2->x;
|
||||
int w = x1-x0;
|
||||
@ -264,12 +245,12 @@ renderscanline_flat( namcos21_state *state, const edge *e1, const edge *e2, int
|
||||
if( depthcueenable && zz>0 )
|
||||
{
|
||||
int depth = 0;
|
||||
if( state->m_gametype == NAMCOS21_WINRUN91 )
|
||||
if( m_gametype == NAMCOS21_WINRUN91 )
|
||||
{
|
||||
depth = (zz>>10)*0x100;
|
||||
pen += depth;
|
||||
}
|
||||
else if( state->m_gametype == NAMCOS21_DRIVERS_EYES )
|
||||
else if( m_gametype == NAMCOS21_DRIVERS_EYES )
|
||||
{
|
||||
depth = (zz>>10)*0x100;
|
||||
pen -= depth;
|
||||
@ -287,16 +268,9 @@ renderscanline_flat( namcos21_state *state, const edge *e1, const edge *e2, int
|
||||
}
|
||||
}
|
||||
}
|
||||
} /* renderscanline_flat */
|
||||
}
|
||||
|
||||
static void
|
||||
rendertri(
|
||||
namcos21_state *state,
|
||||
const vertex *v0,
|
||||
const vertex *v1,
|
||||
const vertex *v2,
|
||||
unsigned color,
|
||||
int depthcueenable )
|
||||
void namcos21_state::rendertri(const vertex *v0, const vertex *v1, const vertex *v2, unsigned color, int depthcueenable)
|
||||
{
|
||||
int dy,ystart,yend,crop;
|
||||
|
||||
@ -363,7 +337,7 @@ rendertri(
|
||||
|
||||
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.z += dz2dy;
|
||||
@ -397,7 +371,7 @@ rendertri(
|
||||
}
|
||||
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.z += dz2dy;
|
||||
@ -407,12 +381,10 @@ rendertri(
|
||||
}
|
||||
}
|
||||
}
|
||||
} /* rendertri */
|
||||
}
|
||||
|
||||
void
|
||||
namcos21_DrawQuad( running_machine &machine, int sx[4], int sy[4], int zcode[4], int color )
|
||||
void namcos21_state::draw_quad(int sx[4], int sy[4], int zcode[4], int color)
|
||||
{
|
||||
namcos21_state *state = machine.driver_data<namcos21_state>();
|
||||
vertex a,b,c,d;
|
||||
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)
|
||||
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);
|
||||
}
|
||||
else if ( state->m_gametype == NAMCOS21_DRIVERS_EYES )
|
||||
else if ( m_gametype == NAMCOS21_DRIVERS_EYES )
|
||||
{
|
||||
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.z = zcode[3];
|
||||
|
||||
rendertri( state, &a, &b, &c, color, depthcueenable );
|
||||
rendertri( state, &c, &d, &a, color, depthcueenable );
|
||||
} /* namcos21_DrawQuad */
|
||||
rendertri(&a, &b, &c, color, depthcueenable);
|
||||
rendertri(&c, &d, &a, color, depthcueenable);
|
||||
}
|
||||
|
||||
Loading…
Reference in New Issue
Block a user