Previous

199869 Revisions

Next

r20471 Friday 25th January, 2013 at 20:12:20 UTC by hap
cleanup: class m_m to m_

[src/mame/drivers]	namcos22.c
[src/mame/includes]	namcos22.h
[src/mame/video]	namcos22.c

trunk/src/mame/drivers/namcos22.c

r20470	r20471
1362	1362
1363	1363	READ16_MEMBER(namcos22_state::pdp_status_r)
1364	1364	{
1365		return m_mMasterBIOZ;
	1365	return m_MasterBIOZ;
1366	1366	} /* pdp_status_r */
1367	1367
1368	1368	void namcos22_state::WriteToPointRAM(offs_t offs, UINT32 data )
1369	1369	{
1370	1370	offs &= 0xffffff; /* 24 bit addressing */
1371		if( m_mbSuperSystem22 )
	1371	if( m_bSuperSystem22 )
1372	1372	{
1373	1373	if( offs>=0xf80000 && offs<=0xf9ffff )
1374		m_mpPointRAM[offs-0xf80000] = data & 0x00ffffff;
	1374	m_pPointRAM[offs-0xf80000] = data & 0x00ffffff;
1375	1375	}
1376	1376	else
1377	1377	{
1378	1378	if( offs>=0xf00000 && offs<=0xf1ffff )
1379		m_mpPointRAM[offs-0xf00000] = data & 0x00ffffff;
	1379	m_pPointRAM[offs-0xf00000] = data & 0x00ffffff;
1380	1380	}
1381	1381	} /* WriteToPointRAM */
1382	1382
r20470	r20471
1394	1394	READ16_MEMBER(namcos22_state::pdp_begin_r)
1395	1395	{
1396	1396	/* this feature appears to be only used on Super System22 hardware */
1397		if( m_mbSuperSystem22 )
	1397	if( m_bSuperSystem22 )
1398	1398	{
1399	1399	UINT16 offs = m_polygonram[0x20000/4-1];
1400		m_mMasterBIOZ = 1;
	1400	m_MasterBIOZ = 1;
1401	1401	for(;;)
1402	1402	{
1403	1403	UINT16 start = offs;
r20470	r20471
1495	1495	return 0;
1496	1496	}
1497	1497	} /* for(;;) */
1498		} /* m_mbSuperSystem22 */
	1498	} /* m_bSuperSystem22 */
1499	1499	return 0;
1500	1500	} /* pdp_begin_r */
1501	1501
1502	1502	READ16_MEMBER(namcos22_state::slave_external_ram_r)
1503	1503	{
1504		return m_mpSlaveExternalRAM[offset];
	1504	return m_pSlaveExternalRAM[offset];
1505	1505	}
1506	1506
1507	1507	WRITE16_MEMBER(namcos22_state::slave_external_ram_w)
1508	1508	{
1509		COMBINE_DATA( &m_mpSlaveExternalRAM[offset] );
	1509	COMBINE_DATA( &m_pSlaveExternalRAM[offset] );
1510	1510	}
1511	1511
1512	1512	static void HaltSlaveDSP( running_machine &machine )
r20470	r20471
1540	1540
1541	1541	WRITE16_MEMBER(namcos22_state::point_ram_idx_w)
1542	1542	{
1543		m_mPointAddr<<=16;
1544		m_mPointAddr |= data;
	1543	m_PointAddr<<=16;
	1544	m_PointAddr |= data;
1545	1545	}
1546	1546
1547	1547	WRITE16_MEMBER(namcos22_state::point_ram_loword_iw)
1548	1548	{
1549		m_mPointData |= data;
1550		WriteToPointRAM(m_mPointAddr++, m_mPointData );
	1549	m_PointData |= data;
	1550	WriteToPointRAM(m_PointAddr++, m_PointData );
1551	1551	}
1552	1552
1553	1553	WRITE16_MEMBER(namcos22_state::point_ram_hiword_w)
1554	1554	{
1555		m_mPointData = (data<<16);
	1555	m_PointData = (data<<16);
1556	1556	}
1557	1557
1558	1558	READ16_MEMBER(namcos22_state::point_ram_loword_r)
1559	1559	{
1560		return namcos22_point_rom_r(machine(), m_mPointAddr)&0xffff;
	1560	return namcos22_point_rom_r(machine(), m_PointAddr)&0xffff;
1561	1561	}
1562	1562
1563	1563	READ16_MEMBER(namcos22_state::point_ram_hiword_ir)
1564	1564	{
1565		return namcos22_point_rom_r(machine(), m_mPointAddr++)>>16;
	1565	return namcos22_point_rom_r(machine(), m_PointAddr++)>>16;
1566	1566	}
1567	1567
1568	1568	WRITE16_MEMBER(namcos22_state::dsp_unk2_w)
r20470	r20471
1585	1585
1586	1586	READ16_MEMBER(namcos22_state::dsp_unk_port3_r)
1587	1587	{
1588		m_mMasterBIOZ = 0;
1589		m_mDspUploadState = eDSP_UPLOAD_READY;
	1588	m_MasterBIOZ = 0;
	1589	m_DspUploadState = eDSP_UPLOAD_READY;
1590	1590	return 0;
1591	1591	}
1592	1592
1593	1593	WRITE16_MEMBER(namcos22_state::upload_code_to_slave_dsp_w)
1594	1594	{
1595		switch( m_mDspUploadState )
	1595	switch( m_DspUploadState )
1596	1596	{
1597	1597	case eDSP_UPLOAD_READY:
1598	1598	logerror( "UPLOAD_READY; cmd = 0x%x\n", data );
r20470	r20471
1602	1602	HaltSlaveDSP(machine());
1603	1603	break;
1604	1604	case 1:
1605		m_mDspUploadState = eDSP_UPLOAD_DEST;
	1605	m_DspUploadState = eDSP_UPLOAD_DEST;
1606	1606	break;
1607	1607	case 2:
1608	1608	/* custom IC poke */
r20470	r20471
1624	1624	break;
1625	1625
1626	1626	case eDSP_UPLOAD_DEST:
1627		m_mUploadDestIdx = data;
1628		m_mDspUploadState = eDSP_UPLOAD_DATA;
	1627	m_UploadDestIdx = data;
	1628	m_DspUploadState = eDSP_UPLOAD_DATA;
1629	1629	break;
1630	1630
1631	1631	case eDSP_UPLOAD_DATA:
1632		m_mpSlaveExternalRAM[m_mUploadDestIdx&0x1fff] = data;
1633		m_mUploadDestIdx++;
	1632	m_pSlaveExternalRAM[m_UploadDestIdx&0x1fff] = data;
	1633	m_UploadDestIdx++;
1634	1634	break;
1635	1635
1636	1636	default:
r20470	r20471
1661	1661
1662	1662	READ16_MEMBER(namcos22_state::master_external_ram_r)
1663	1663	{
1664		return m_mpMasterExternalRAM[offset];
	1664	return m_pMasterExternalRAM[offset];
1665	1665	}
1666	1666
1667	1667	WRITE16_MEMBER(namcos22_state::master_external_ram_w)
1668	1668	{
1669		COMBINE_DATA( &m_mpMasterExternalRAM[offset] );
	1669	COMBINE_DATA( &m_pMasterExternalRAM[offset] );
1670	1670	}
1671	1671
1672	1672	WRITE16_MEMBER(namcos22_state::slave_serial_io_w)
1673	1673	{
1674		m_mSerialDataSlaveToMasterNext = data;
	1674	m_SerialDataSlaveToMasterNext = data;
1675	1675	logerror( "slave_serial_io_w(%04x)\n", data );
1676	1676	}
1677	1677
1678	1678	READ16_MEMBER(namcos22_state::master_serial_io_r)
1679	1679	{
1680	1680	logerror( "master_serial_io_r() == %04x\n",
1681		m_mSerialDataSlaveToMasterCurrent );
1682		return m_mSerialDataSlaveToMasterCurrent;
	1681	m_SerialDataSlaveToMasterCurrent );
	1682	return m_SerialDataSlaveToMasterCurrent;
1683	1683	}
1684	1684
1685	1685	TIMER_DEVICE_CALLBACK_MEMBER(namcos22_state::dsp_master_serial_irq)
1686	1686	{
1687	1687	int scanline = param;
1688	1688
1689		if( m_mbEnableDspIrqs )
	1689	if( m_bEnableDspIrqs )
1690	1690	{
1691		m_mSerialDataSlaveToMasterCurrent = m_mSerialDataSlaveToMasterNext;
	1691	m_SerialDataSlaveToMasterCurrent = m_SerialDataSlaveToMasterNext;
1692	1692
1693	1693	if(scanline == 480)
1694	1694	m_master->set_input_line(TMS32025_INT0, HOLD_LINE);
r20470	r20471
1704	1704	{
1705	1705	int scanline = param;
1706	1706
1707		if( m_mbEnableDspIrqs )
	1707	if( m_bEnableDspIrqs )
1708	1708	{
1709	1709	if((scanline % 2) == 0)
1710	1710	{
r20470	r20471
1761	1761	*/
1762	1762	WRITE16_MEMBER(namcos22_state::dsp_unk8_w)
1763	1763	{
1764		m_mRenderBufSize = 0;
	1764	m_RenderBufSize = 0;
1765	1765	}
1766	1766
1767	1767	WRITE16_MEMBER(namcos22_state::master_render_device_w)
1768	1768	{
1769		if( m_mRenderBufSize<MAX_RENDER_CMD_SEQ )
	1769	if( m_RenderBufSize<MAX_RENDER_CMD_SEQ )
1770	1770	{
1771		m_mRenderBufData[m_mRenderBufSize++] = data;
1772		if( m_mRenderBufSize == MAX_RENDER_CMD_SEQ )
	1771	m_RenderBufData[m_RenderBufSize++] = data;
	1772	if( m_RenderBufSize == MAX_RENDER_CMD_SEQ )
1773	1773	{
1774		namcos22_draw_direct_poly( machine(), m_mRenderBufData );
	1774	namcos22_draw_direct_poly( machine(), m_RenderBufData );
1775	1775	}
1776	1776	}
1777	1777	}
r20470	r20471
2146	2146	m_master->set_input_line(INPUT_LINE_RESET, ASSERT_LINE); /* master DSP */
2147	2147	m_slave->set_input_line(INPUT_LINE_RESET, ASSERT_LINE); /* slave DSP */
2148	2148	namcos22_enable_slave_simulation(machine(), 0);
2149		m_mbEnableDspIrqs = 0;
	2149	m_bEnableDspIrqs = 0;
2150	2150	}
2151	2151	else if( newreg == 1 )
2152	2152	{ /* enable dsp and rendering subsystem */
2153	2153	m_master->set_input_line(INPUT_LINE_RESET, CLEAR_LINE);
2154	2154	namcos22_enable_slave_simulation(machine(), 1);
2155		m_mbEnableDspIrqs = 1;
	2155	m_bEnableDspIrqs = 1;
2156	2156	}
2157	2157	else if( newreg == 0xff )
2158	2158	{ /* used to upload game-specific code to master/slave dsps */
2159	2159	m_master->set_input_line(INPUT_LINE_RESET, CLEAR_LINE);
2160		m_mbEnableDspIrqs = 0;
	2160	m_bEnableDspIrqs = 0;
2161	2161	}
2162	2162	}
2163	2163	}
r20470	r20471
2274	2274	m_master->set_input_line(INPUT_LINE_RESET, ASSERT_LINE); /* master DSP */
2275	2275	m_slave->set_input_line(INPUT_LINE_RESET, ASSERT_LINE); /* slave DSP */
2276	2276	namcos22_enable_slave_simulation(machine(), 0);
2277		m_mbEnableDspIrqs = 0;
	2277	m_bEnableDspIrqs = 0;
2278	2278	}
2279	2279	else if( newreg == 1 )
2280	2280	{ /* enable dsp and rendering subsystem */
2281	2281	m_master->set_input_line(INPUT_LINE_RESET, CLEAR_LINE);
2282	2282	namcos22_enable_slave_simulation(machine(), 1);
2283		m_mbEnableDspIrqs = 1;
	2283	m_bEnableDspIrqs = 1;
2284	2284	}
2285	2285	else if( newreg == 0xff )
2286	2286	{ /* used to upload game-specific code to master/slave dsps */
2287	2287	m_master->set_input_line(INPUT_LINE_RESET, CLEAR_LINE);
2288		m_mbEnableDspIrqs = 0;
	2288	m_bEnableDspIrqs = 0;
2289	2289	}
2290	2290	}
2291	2291	}
r20470	r20471
2403	2403	*/
2404	2404	READ32_MEMBER(namcos22_state::namcos22_portbit_r)
2405	2405	{
2406		UINT32 data = m_mSys22PortBits;
2407		m_mSys22PortBits>>=1;
	2406	UINT32 data = m_Sys22PortBits;
	2407	m_Sys22PortBits>>=1;
2408	2408	return data&0x10001;
2409	2409	}
2410	2410	WRITE32_MEMBER(namcos22_state::namcos22_portbit_w)
2411	2411	{
2412	2412	unsigned dat50000008 = AnalogAsDigital(machine());
2413	2413	unsigned dat5000000a = 0xffff;
2414		m_mSys22PortBits = (dat50000008<<16)|dat5000000a;
	2414	m_Sys22PortBits = (dat50000008<<16)|dat5000000a;
2415	2415	}
2416	2416
2417	2417	READ32_MEMBER(namcos22_state::namcos22_dipswitch_r)
r20470	r20471
2462	2462
2463	2463	READ32_MEMBER(namcos22_state::alpinesa_prot_r)
2464	2464	{
2465		return m_mAlpineSurferProtData;
	2465	return m_AlpineSurferProtData;
2466	2466	} /* alpinesa_prot_r */
2467	2467
2468	2468	WRITE32_MEMBER(namcos22_state::alpinesa_prot_w)
r20470	r20471
2470	2470	switch( data )
2471	2471	{
2472	2472	case 0:
2473		m_mAlpineSurferProtData = 0;
	2473	m_AlpineSurferProtData = 0;
2474	2474	break;
2475	2475	case 1:
2476		m_mAlpineSurferProtData = 1;
	2476	m_AlpineSurferProtData = 1;
2477	2477	break;
2478	2478	case 3:
2479		m_mAlpineSurferProtData = 2;
	2479	m_AlpineSurferProtData = 2;
2480	2480	break;
2481	2481	default:
2482	2482	break;
r20470	r20471
5688	5688	state->m_old_coin_state = 0;
5689	5689	state->m_credits1 = state->m_credits2 = 0;
5690	5690
5691		state->m_mpPointRAM = auto_alloc_array(machine, UINT32, 0x20000);
	5691	state->m_pPointRAM = auto_alloc_array(machine, UINT32, 0x20000);
5692	5692	}
5693	5693
5694	5694	static void alpine_init_common( running_machine &machine, int game_type )

trunk/src/mame/video/namcos22.c

r20470	r20471
151	151	strcat(msg1,msg2);
152	152	}
153	153	if (1) // + other non-super regs
154		if (!state->m_mbSuperSystem22)
	154	if (!state->m_bSuperSystem22)
155	155	{
156	156	strcat(msg1,"\n");
157	157	for (i=8;i<=0x20;i+=8)
r20470	r20471
163	163	popmessage("%s",msg1);
164	164	#endif
165	165
166		if( state->m_mbSuperSystem22 )
	166	if( state->m_bSuperSystem22 )
167	167	{
168	168	/*
169	169	0 1 2 3  4 5 6 7  8 9 a b  c d e f 10       14       18       1c
r20470	r20471
330	330	INLINE unsigned texel( namcos22_state *state, unsigned x, unsigned y )
331	331	{
332	332	unsigned offs = ((y&0xfff0)<<4)|((x&0xff0)>>4);
333		unsigned tile = state->m_mpTextureTileMap16[offs];
334		return state->m_mpTextureTileData[(tile<<8)|state->m_mXYAttrToPixel[state->m_mpTextureTileMapAttr[offs]][x&0xf][y&0xf]];
	333	unsigned tile = state->m_pTextureTileMap16[offs];
	334	return state->m_pTextureTileData[(tile<<8)|state->m_XYAttrToPixel[state->m_pTextureTileMapAttr[offs]][x&0xf][y&0xf]];
335	335	} /* texel */
336	336
337	337
r20470	r20471
415	415	// slight differences between super and non-super, do the branch here for optimization
416	416	// normal: 1 fader, no alpha, shading after fog
417	417	// super:  2 faders, alpha, shading before fog
418		if (state->m_mbSuperSystem22)
	418	if (state->m_bSuperSystem22)
419	419	{
420	420	for( x=extent->startx; x<extent->stopx; x++ )
421	421	{
r20470	r20471
530	530	extra->flags = flags;
531	531	extra->cz_adjust = cz_adjust;
532	532	extra->cmode = cmode;
533		extra->prioverchar = (state->m_mbSuperSystem22 << 1) | ((cmode & 7) == 1);
	533	extra->prioverchar = (state->m_bSuperSystem22 << 1) | ((cmode & 7) == 1);
534	534
535	535	/* non-direct case: project and z-clip */
536	536	if (!direct)
r20470	r20471
576	576	}
577	577	}
578	578
579		if( state->m_mbSuperSystem22 )
	579	if( state->m_bSuperSystem22 )
580	580	{
581	581	// global fade
582	582	if (mixer.flags&1)
r20470	r20471
840	840	{
841	841	namcos22_state *state = machine.driver_data<namcos22_state>();
842	842	int x,y;
843		if( state->m_mbSuperSystem22 )
	843	if( state->m_bSuperSystem22 )
844	844	{ /* super system 22 */
845	845	const UINT8 *rlut = (const UINT8 *)&state->m_gamma[0x100/4];
846	846	const UINT8 *glut = (const UINT8 *)&state->m_gamma[0x200/4];
r20470	r20471
1194	1194	GetPolyData( namcos22_state *state, INT32 addr )
1195	1195	{
1196	1196	UINT32 result;
1197		if( addr<0 || addr>=state->m_mPtRomSize )
	1197	if( addr<0 || addr>=state->m_PtRomSize )
1198	1198	{
1199	1199	// point ram, only used in ram test?
1200		if( state->m_mbSuperSystem22 )
	1200	if( state->m_bSuperSystem22 )
1201	1201	{
1202	1202	if( addr>=0xf80000 && addr<=0xf9ffff )
1203		result = state->m_mpPointRAM[addr-0xf80000];
	1203	result = state->m_pPointRAM[addr-0xf80000];
1204	1204	else return -1;
1205	1205	}
1206	1206	else
1207	1207	{
1208	1208	if( addr>=0xf00000 && addr<=0xf1ffff )
1209		result = state->m_mpPointRAM[addr-0xf00000];
	1209	result = state->m_pPointRAM[addr-0xf00000];
1210	1210	else return -1;
1211	1211	}
1212	1212	}
1213	1213	else
1214	1214	{
1215		result = (state->m_mpPolyH[addr]<<16)|(state->m_mpPolyM[addr]<<8)|state->m_mpPolyL[addr];
	1215	result = (state->m_pPolyH[addr]<<16)|(state->m_pPolyM[addr]<<8)|state->m_pPolyL[addr];
1216	1216	}
1217	1217	if( result&0x00800000 )
1218	1218	result |= 0xff000000; /* sign extend */
r20470	r20471
1328	1328	if( attr&4 ) ix = 15-ix;
1329	1329	if( attr&2 ) iy = 15-iy;
1330	1330	if( attr&8 ){ temp = ix; ix = iy; iy = temp; }
1331		state->m_mXYAttrToPixel[attr][x][y] = (iy<<4)|ix;
	1331	state->m_XYAttrToPixel[attr][x][y] = (iy<<4)|ix;
1332	1332	}
1333	1333	}
1334	1334	}
r20470	r20471
1346	1346	case NAMCOS22_CYBER_COMMANDO:
1347	1347	for( i=0; i<0x100000; i++ )
1348	1348	{
1349		int tile = state->m_mpTextureTileMap16[i];
1350		int attr = state->m_mpTextureTileMapAttr[i];
	1349	int tile = state->m_pTextureTileMap16[i];
	1350	int attr = state->m_pTextureTileMapAttr[i];
1351	1351	if( (attr&0x1)==0 )
1352	1352	{
1353	1353	tile = (tile&0x3fff)|0x8000;
1354		state->m_mpTextureTileMap16[i] = tile;
	1354	state->m_pTextureTileMap16[i] = tile;
1355	1355	}
1356	1356	}
1357	1357	break;
r20470	r20471
1366	1366	{
1367	1367	if (machine.video().skip_this_frame()) return;
1368	1368	namcos22_state *state = machine.driver_data<namcos22_state>();
1369		int polys_enabled = state->m_mbSuperSystem22 ? nthbyte(state->m_gamma,0x1f)&1 : 1;
	1369	int polys_enabled = state->m_bSuperSystem22 ? nthbyte(state->m_gamma,0x1f)&1 : 1;
1370	1370	if (!polys_enabled) return;
1371	1371	/**
1372	1372	* word#0:
r20470	r20471
1396	1396	UINT32 zsortvalue24 = ((pSource[1]&0xfff)<<12)|(pSource[0]&0xfff);
1397	1397	struct SceneNode *node = NewSceneNode(machine, zsortvalue24, eSCENENODE_QUAD3D);
1398	1398	int i, cztype = pSource[3]&3;
1399		if( state->m_mbSuperSystem22 )
	1399	if( state->m_bSuperSystem22 )
1400	1400	{
1401	1401	cztype ^= 3; // ? not sure, but this makes testmode look like on a pcb (only 1 pcb checked)
1402	1402	node->data.quad3d.cmode       = (pSource[2]&0x00f0)>>4;
r20470	r20471
1414	1414	for( i=0; i<4; i++ )
1415	1415	{
1416	1416	Poly3dVertex *p = &node->data.quad3d.v[i];
1417		if( state->m_mbSuperSystem22 )
	1417	if( state->m_bSuperSystem22 )
1418	1418	{
1419	1419	p->u = pSource[0] >> 4;
1420	1420	p->v = pSource[1] >> 4;
r20470	r20471
1435	1435	zf /= 2.0;
1436	1436	exponent++;
1437	1437	}
1438		if( state->m_mbSuperSystem22 )
	1438	if( state->m_bSuperSystem22 )
1439	1439	p->z = zf;
1440	1440	else
1441	1441	p->z = 1.0f/zf;
r20470	r20471
1475	1475	UINT8 *pUnpackedTileAttr = auto_alloc_array(machine, UINT8, 0x080000*2);
1476	1476	{
1477	1477	InitXYAttrToPixel(state);
1478		state->m_mpTextureTileMapAttr = pUnpackedTileAttr;
	1478	state->m_pTextureTileMapAttr = pUnpackedTileAttr;
1479	1479	for( i=0; i<0x80000; i++ )
1480	1480	{
1481	1481	*pUnpackedTileAttr++ = (*pPackedTileAttr)>>4;
1482	1482	*pUnpackedTileAttr++ = (*pPackedTileAttr)&0xf;
1483	1483	pPackedTileAttr++;
1484	1484	}
1485		state->m_mpTextureTileMap16 = (UINT16 *)pTilemapROM;
1486		state->m_mpTextureTileData = (UINT8 *)pTextureROM;
	1485	state->m_pTextureTileMap16 = (UINT16 *)pTilemapROM;
	1486	state->m_pTextureTileData = (UINT8 *)pTextureROM;
1487	1487	PatchTexture(state);
1488	1488	}
1489	1489	}
r20470	r20471
2085	2085	state->m_bgtilemap->set_scrolly(0, scroll_y & 0x3ff );
2086	2086	state->m_bgtilemap->set_palette_offset(mixer.palBase*256 );
2087	2087
2088		if (state->m_mbSuperSystem22)
	2088	if (state->m_bSuperSystem22)
2089	2089	{
2090	2090	state->m_bgtilemap->draw(*state->m_mix_bitmap, cliprect, 0, 4, 4);
2091	2091	namcos22s_mix_textlayer(machine, bitmap, cliprect, 4);
r20470	r20471
2156	2156	int packetFormat )
2157	2157	{
2158	2158	namcos22_state *state = machine.driver_data<namcos22_state>();
2159		int absolutePriority = state->m_mAbsolutePriority;
	2159	int absolutePriority = state->m_AbsolutePriority;
2160	2160	INT32 zsortvalue24;
2161	2161	float zmin = 0.0f;
2162	2162	float zmax = 0.0f;
r20470	r20471
2196	2196	if( i==0 || pVerTex->z > zmax ) zmax = pVerTex->z;
2197	2197	if( i==0 || pVerTex->z < zmin ) zmin = pVerTex->z;
2198	2198
2199		if( state->m_mLitSurfaceCount )
	2199	if( state->m_LitSurfaceCount )
2200	2200	{
2201	2201	// lighting (prelim)
2202		bri = state->m_mLitSurfaceInfo[state->m_mLitSurfaceIndex%state->m_mLitSurfaceCount];
2203		if( state->m_mSurfaceNormalFormat == 0x6666 )
	2202	bri = state->m_LitSurfaceInfo[state->m_LitSurfaceIndex%state->m_LitSurfaceCount];
	2203	if( state->m_SurfaceNormalFormat == 0x6666 )
2204	2204	{
2205	2205	if( i==3 )
2206		state->m_mLitSurfaceIndex++;
	2206	state->m_LitSurfaceIndex++;
2207	2207	}
2208		else if( state->m_mSurfaceNormalFormat == 0x4000 )
2209		state->m_mLitSurfaceIndex++;
	2208	else if( state->m_SurfaceNormalFormat == 0x4000 )
	2209	state->m_LitSurfaceIndex++;
2210	2210	else
2211		logerror( "unknown normal format: 0x%x\n", state->m_mSurfaceNormalFormat );
	2211	logerror( "unknown normal format: 0x%x\n", state->m_SurfaceNormalFormat );
2212	2212	}
2213	2213	else if( packetFormat & 0x40 )
2214	2214	{
r20470	r20471
2255	2255	absolutePriority += (polygonShiftValue22&0x1c0000)>>18;
2256	2256	}
2257	2257
2258		if( state->m_mObjectShiftValue22 & 0x200000 )
2259		zsortvalue24 = state->m_mObjectShiftValue22 & 0x1fffff;
	2258	if( state->m_ObjectShiftValue22 & 0x200000 )
	2259	zsortvalue24 = state->m_ObjectShiftValue22 & 0x1fffff;
2260	2260	else
2261	2261	{
2262		zsortvalue24 += Signed18( state->m_mObjectShiftValue22 );
2263		absolutePriority += (state->m_mObjectShiftValue22&0x1c0000)>>18;
	2262	zsortvalue24 += Signed18( state->m_ObjectShiftValue22 );
	2263	absolutePriority += (state->m_ObjectShiftValue22&0x1c0000)>>18;
2264	2264	}
2265	2265
2266	2266	if (zsortvalue24 < 0) zsortvalue24 = 0;
r20470	r20471
2310	2310	dotproduct = nx*mCamera.lx + ny*mCamera.ly + nz*mCamera.lz;
2311	2311	if( dotproduct<0.0f )
2312	2312	dotproduct = 0.0f;
2313		state->m_mLitSurfaceInfo[state->m_mLitSurfaceCount++] = mCamera.ambient + mCamera.power*dotproduct;
	2313	state->m_LitSurfaceInfo[state->m_LitSurfaceCount++] = mCamera.ambient + mCamera.power*dotproduct;
2314	2314	}
2315	2315	} /* RegisterNormals */
2316	2316
r20470	r20471
2381	2381	000000  000000  007fff // normal vector
2382	2382	*/
2383	2383	//              numAdditionalNormals = GetPolyData(state, addr+2);
2384		state->m_mSurfaceNormalFormat = GetPolyData(state, addr+3);
2385		state->m_mLitSurfaceCount = 0;
2386		state->m_mLitSurfaceIndex = 0;
	2384	state->m_SurfaceNormalFormat = GetPolyData(state, addr+3);
	2385	state->m_LitSurfaceCount = 0;
	2386	state->m_LitSurfaceIndex = 0;
2387	2387	RegisterNormals( state, addr+4, m );
2388	2388	break;
2389	2389
r20470	r20471
2410	2410	{
2411	2411	namcos22_state *state = machine.driver_data<namcos22_state>();
2412	2412	unsigned addr1 = GetPolyData(state, code);
2413		state->m_mLitSurfaceCount = 0;
2414		state->m_mLitSurfaceIndex = 0;
	2413	state->m_LitSurfaceCount = 0;
	2414	state->m_LitSurfaceIndex = 0;
2415	2415	for(;;)
2416	2416	{
2417	2417	INT32 addr2 = GetPolyData(state, addr1++);
r20470	r20471
2512	2512	mCamera.ly       = DSP_FIXED_TO_FLOAT(pSource[0x3]);
2513	2513	mCamera.lz       = DSP_FIXED_TO_FLOAT(pSource[0x4]);
2514	2514
2515		state->m_mAbsolutePriority = pSource[0x3]>>16;
	2515	state->m_AbsolutePriority = pSource[0x3]>>16;
2516	2516	mCamera.vx      = (INT16)(pSource[5]>>16);
2517	2517	mCamera.vy      = (INT16)pSource[5];
2518	2518	mCamera.zoom    = DspFloatToNativeFloat(pSource[6]);
2519	2519	mCamera.vw      = DspFloatToNativeFloat(pSource[7])*mCamera.zoom;
2520	2520	mCamera.vh      = DspFloatToNativeFloat(pSource[9])*mCamera.zoom;
2521	2521
2522		state->m_mViewMatrix[0][0] = DSP_FIXED_TO_FLOAT(pSource[0x0c]);
2523		state->m_mViewMatrix[1][0] = DSP_FIXED_TO_FLOAT(pSource[0x0d]);
2524		state->m_mViewMatrix[2][0] = DSP_FIXED_TO_FLOAT(pSource[0x0e]);
	2522	state->m_ViewMatrix[0][0] = DSP_FIXED_TO_FLOAT(pSource[0x0c]);
	2523	state->m_ViewMatrix[1][0] = DSP_FIXED_TO_FLOAT(pSource[0x0d]);
	2524	state->m_ViewMatrix[2][0] = DSP_FIXED_TO_FLOAT(pSource[0x0e]);
2525	2525
2526		state->m_mViewMatrix[0][1] = DSP_FIXED_TO_FLOAT(pSource[0x0f]);
2527		state->m_mViewMatrix[1][1] = DSP_FIXED_TO_FLOAT(pSource[0x10]);
2528		state->m_mViewMatrix[2][1] = DSP_FIXED_TO_FLOAT(pSource[0x11]);
	2526	state->m_ViewMatrix[0][1] = DSP_FIXED_TO_FLOAT(pSource[0x0f]);
	2527	state->m_ViewMatrix[1][1] = DSP_FIXED_TO_FLOAT(pSource[0x10]);
	2528	state->m_ViewMatrix[2][1] = DSP_FIXED_TO_FLOAT(pSource[0x11]);
2529	2529
2530		state->m_mViewMatrix[0][2] = DSP_FIXED_TO_FLOAT(pSource[0x12]);
2531		state->m_mViewMatrix[1][2] = DSP_FIXED_TO_FLOAT(pSource[0x13]);
2532		state->m_mViewMatrix[2][2] = DSP_FIXED_TO_FLOAT(pSource[0x14]);
	2530	state->m_ViewMatrix[0][2] = DSP_FIXED_TO_FLOAT(pSource[0x12]);
	2531	state->m_ViewMatrix[1][2] = DSP_FIXED_TO_FLOAT(pSource[0x13]);
	2532	state->m_ViewMatrix[2][2] = DSP_FIXED_TO_FLOAT(pSource[0x14]);
2533	2533
2534		TransformNormal( &mCamera.lx, &mCamera.ly, &mCamera.lz, state->m_mViewMatrix );
	2534	TransformNormal( &mCamera.lx, &mCamera.ly, &mCamera.lz, state->m_ViewMatrix );
2535	2535	} /* HandleBB0003 */
2536	2536
2537	2537	static void
2538	2538	Handle200002( running_machine &machine, bitmap_rgb32 &bitmap, const INT32 *pSource )
2539	2539	{
2540	2540	namcos22_state *state = machine.driver_data<namcos22_state>();
2541		if( state->m_mPrimitiveID>=0x45 )
	2541	if( state->m_PrimitiveID>=0x45 )
2542	2542	{
2543	2543	float m[4][4]; /* row major */
2544	2544
r20470	r20471
2560	2560	m[3][1] = pSource[0xb]; /* ypos */
2561	2561	m[3][2] = pSource[0xc]; /* zpos */
2562	2562
2563		matrix3d_Multiply( m, state->m_mViewMatrix );
2564		BlitPolyObject( machine, bitmap, state->m_mPrimitiveID, m );
	2563	matrix3d_Multiply( m, state->m_ViewMatrix );
	2564	BlitPolyObject( machine, bitmap, state->m_PrimitiveID, m );
2565	2565	}
2566		else if( state->m_mPrimitiveID !=0 && state->m_mPrimitiveID !=2 )
	2566	else if( state->m_PrimitiveID !=0 && state->m_PrimitiveID !=2 )
2567	2567	{
2568		logerror( "Handle200002:unk code=0x%x\n", state->m_mPrimitiveID );
	2568	logerror( "Handle200002:unk code=0x%x\n", state->m_PrimitiveID );
2569	2569	// ridgerac title screen waving flag: 0x5
2570	2570	}
2571	2571	} /* Handle200002 */
r20470	r20471
2573	2573	static void
2574	2574	Handle300000( namcos22_state *state, const INT32 *pSource )
2575	2575	{
2576		state->m_mViewMatrix[0][0] = DSP_FIXED_TO_FLOAT(pSource[1]);
2577		state->m_mViewMatrix[1][0] = DSP_FIXED_TO_FLOAT(pSource[2]);
2578		state->m_mViewMatrix[2][0] = DSP_FIXED_TO_FLOAT(pSource[3]);
	2576	state->m_ViewMatrix[0][0] = DSP_FIXED_TO_FLOAT(pSource[1]);
	2577	state->m_ViewMatrix[1][0] = DSP_FIXED_TO_FLOAT(pSource[2]);
	2578	state->m_ViewMatrix[2][0] = DSP_FIXED_TO_FLOAT(pSource[3]);
2579	2579
2580		state->m_mViewMatrix[0][1] = DSP_FIXED_TO_FLOAT(pSource[4]);
2581		state->m_mViewMatrix[1][1] = DSP_FIXED_TO_FLOAT(pSource[5]);
2582		state->m_mViewMatrix[2][1] = DSP_FIXED_TO_FLOAT(pSource[6]);
	2580	state->m_ViewMatrix[0][1] = DSP_FIXED_TO_FLOAT(pSource[4]);
	2581	state->m_ViewMatrix[1][1] = DSP_FIXED_TO_FLOAT(pSource[5]);
	2582	state->m_ViewMatrix[2][1] = DSP_FIXED_TO_FLOAT(pSource[6]);
2583	2583
2584		state->m_mViewMatrix[0][2] = DSP_FIXED_TO_FLOAT(pSource[7]);
2585		state->m_mViewMatrix[1][2] = DSP_FIXED_TO_FLOAT(pSource[8]);
2586		state->m_mViewMatrix[2][2] = DSP_FIXED_TO_FLOAT(pSource[9]);
	2584	state->m_ViewMatrix[0][2] = DSP_FIXED_TO_FLOAT(pSource[7]);
	2585	state->m_ViewMatrix[1][2] = DSP_FIXED_TO_FLOAT(pSource[8]);
	2586	state->m_ViewMatrix[2][2] = DSP_FIXED_TO_FLOAT(pSource[9]);
2587	2587	} /* Handle300000 */
2588	2588
2589	2589	static void
r20470	r20471
2600	2600	00000000 00000000 00000000
2601	2601	*/
2602	2602	state->m_cz_adjust = (pSource[1] & 0x00800000) ? pSource[1] | 0xff000000 : pSource[1] & 0x00ffffff;
2603		state->m_mObjectShiftValue22 = pSource[2];
	2603	state->m_ObjectShiftValue22 = pSource[2];
2604	2604	} /* Handle233002 */
2605	2605
2606	2606	static void
r20470	r20471
2610	2610	const INT32 *pSource = 0x300 + (INT32 *)state->m_polygonram.target();
2611	2611	INT16 len;
2612	2612
2613		matrix3d_Identity( state->m_mViewMatrix );
	2613	matrix3d_Identity( state->m_ViewMatrix );
2614	2614
2615		if( state->m_mbSuperSystem22 )
	2615	if( state->m_bSuperSystem22 )
2616	2616	{
2617	2617	pSource += 4; /* FFFE 0400 */
2618	2618	}
r20470	r20471
2624	2624	for(;;)
2625	2625	{
2626	2626	INT16 next;
2627		state->m_mPrimitiveID = *pSource++;
	2627	state->m_PrimitiveID = *pSource++;
2628	2628	len  = (INT16)*pSource++;
2629	2629
2630	2630	switch( len )
r20470	r20471
2673	2673	DrawPolygons( running_machine &machine, bitmap_rgb32 &bitmap )
2674	2674	{
2675	2675	namcos22_state *state = machine.driver_data<namcos22_state>();
2676		if( state->m_mbDSPisActive )
	2676	if( state->m_bDSPisActive )
2677	2677	{
2678	2678	SimulateSlaveDSP( machine, bitmap );
2679	2679	poly_wait(state->m_poly, "DrawPolygons");
r20470	r20471
2684	2684	namcos22_enable_slave_simulation( running_machine &machine, int enable )
2685	2685	{
2686	2686	namcos22_state *state = machine.driver_data<namcos22_state>();
2687		state->m_mbDSPisActive = enable;
	2687	state->m_bDSPisActive = enable;
2688	2688	}
2689	2689
2690	2690	/*********************************************************************************************/
r20470	r20471
2731	2731	m_bgtilemap = &machine().tilemap().create(tilemap_get_info_delegate(FUNC(namcos22_state::TextTilemapGetInfo),this),TILEMAP_SCAN_ROWS,16,16,64,64 );
2732	2732	m_bgtilemap->set_transparent_pen(0xf);
2733	2733
2734		m_mbDSPisActive = 0;
	2734	m_bDSPisActive = 0;
2735	2735	memset( m_polygonram, 0xcc, 0x20000 );
2736	2736
2737	2737	for (code = 0; code < machine().gfx[GFX_TEXTURE_TILE]->elements(); code++)
r20470	r20471
2739	2739
2740	2740	Prepare3dTexture(machine(), memregion("textilemap")->base(), machine().gfx[GFX_TEXTURE_TILE]->get_data(0) );
2741	2741	m_dirtypal = auto_alloc_array(machine(), UINT8, NAMCOS22_PALETTE_SIZE/4);
2742		m_mPtRomSize = memregion("pointrom")->bytes()/3;
2743		m_mpPolyL = memregion("pointrom")->base();
2744		m_mpPolyM = m_mpPolyL + m_mPtRomSize;
2745		m_mpPolyH = m_mpPolyM + m_mPtRomSize;
	2742	m_PtRomSize = memregion("pointrom")->bytes()/3;
	2743	m_pPolyL = memregion("pointrom")->base();
	2744	m_pPolyM = m_pPolyL + m_PtRomSize;
	2745	m_pPolyH = m_pPolyM + m_PtRomSize;
2746	2746
2747	2747	m_poly = poly_alloc(machine(), 4000, sizeof(poly_extra_data), 0);
2748	2748	machine().add_notifier(MACHINE_NOTIFY_RESET, machine_notify_delegate(FUNC(namcos22_reset), &machine()));
r20470	r20471
2753	2753
2754	2754	VIDEO_START_MEMBER(namcos22_state,namcos22)
2755	2755	{
2756		m_mbSuperSystem22 = 0;
	2756	m_bSuperSystem22 = 0;
2757	2757	VIDEO_START_CALL_MEMBER(common);
2758	2758	}
2759	2759
2760	2760	VIDEO_START_MEMBER(namcos22_state,namcos22s)
2761	2761	{
2762		m_mbSuperSystem22 = 1;
	2762	m_bSuperSystem22 = 1;
2763	2763
2764	2764	// init spotram
2765	2765	m_spotram = auto_alloc_array(machine(), UINT16, SPOTRAM_SIZE);
r20470	r20471
2913	2913	break;
2914	2914
2915	2915	case 2:
2916		m_mUpperWordLatch = value>>16;
	2916	m_UpperWordLatch = value>>16;
2917	2917	value &= 0xffff;
2918	2918	break;
2919	2919
r20470	r20471
2940	2940
2941	2941	case 2:
2942	2942	COMBINE_DATA( &lo );
2943		hi = m_mUpperWordLatch;
	2943	hi = m_UpperWordLatch;
2944	2944	break;
2945	2945
2946	2946	default:

trunk/src/mame/includes/namcos22.h

r20470	r20471
43	43	m_shareram(*this,"shareram"),
44	44	m_system_controller(*this,"syscontrol"),
45	45	m_nvmem(*this,"nvmem"),
46		m_mpSlaveExternalRAM(*this,"slaveextram"),
47		m_mpMasterExternalRAM(*this,"masterextram"),
	46	m_pSlaveExternalRAM(*this,"slaveextram"),
	47	m_pMasterExternalRAM(*this,"masterextram"),
48	48	m_cgram(*this,"cgram"),
49	49	m_textram(*this,"textram"),
50	50	m_polygonram(*this,"polygonram"),
r20470	r20471
65	65	required_shared_ptr<UINT32> m_shareram;
66	66	required_shared_ptr<UINT32> m_system_controller;
67	67	required_shared_ptr<UINT32> m_nvmem;
68		required_shared_ptr<UINT16> m_mpSlaveExternalRAM;
69		required_shared_ptr<UINT16> m_mpMasterExternalRAM;
	68	required_shared_ptr<UINT16> m_pSlaveExternalRAM;
	69	required_shared_ptr<UINT16> m_pMasterExternalRAM;
70	70	required_shared_ptr<UINT32> m_cgram;
71	71	required_shared_ptr<UINT32> m_textram;
72	72	required_shared_ptr<UINT32> m_polygonram;
r20470	r20471
77	77	required_shared_ptr<UINT32> m_tilemapattr;
78	78	optional_shared_ptr<UINT32> m_czram;
79	79
80		int m_mbEnableDspIrqs;
	80	int m_bEnableDspIrqs;
81	81	attotime m_ar_tb_reload[2];
82	82	emu_timer *m_ar_tb_interrupt[2];
83		UINT16 m_mMasterBIOZ;
84		UINT32 *m_mpPointRAM;
	83	UINT16 m_MasterBIOZ;
	84	UINT32 *m_pPointRAM;
85	85	UINT32 m_old_coin_state;
86	86	UINT32 m_credits1;
87	87	UINT32 m_credits2;
88		UINT32 m_mPointAddr;
89		UINT32 m_mPointData;
90		UINT16 m_mSerialDataSlaveToMasterNext;
91		UINT16 m_mSerialDataSlaveToMasterCurrent;
92		int m_mRenderBufSize;
93		UINT16 m_mRenderBufData[MAX_RENDER_CMD_SEQ];
94		UINT32 m_mSys22PortBits;
	88	UINT32 m_PointAddr;
	89	UINT32 m_PointData;
	90	UINT16 m_SerialDataSlaveToMasterNext;
	91	UINT16 m_SerialDataSlaveToMasterCurrent;
	92	int m_RenderBufSize;
	93	UINT16 m_RenderBufData[MAX_RENDER_CMD_SEQ];
	94	UINT32 m_Sys22PortBits;
95	95	int m_irq_state;
96		int m_mDspUploadState;
97		int m_mUploadDestIdx;
98		UINT32 m_mAlpineSurferProtData;
	96	int m_DspUploadState;
	97	int m_UploadDestIdx;
	98	UINT32 m_AlpineSurferProtData;
99	99	int m_motor_status;
100	100	emu_timer *m_motor_timer;
101	101	int m_p4;
102	102	UINT16 m_su_82;
103	103	UINT16 m_keycus_id;
104	104	int m_gametype;
105		int m_mbSuperSystem22;
	105	int m_bSuperSystem22;
106	106	int m_chipselect;
107	107	int m_spot_enable;
108	108	int m_spot_read_address;
r20470	r20471
113	113	UINT32 m_cz_was_written[4];
114	114	int m_cz_adjust;
115	115	poly_manager *m_poly;
116		UINT16 *m_mpTextureTileMap16;
117		UINT8 *m_mpTextureTileMapAttr;
118		UINT8 *m_mpTextureTileData;
119		UINT8 m_mXYAttrToPixel[16][16][16];
	116	UINT16 *m_pTextureTileMap16;
	117	UINT8 *m_pTextureTileMapAttr;
	118	UINT8 *m_pTextureTileData;
	119	UINT8 m_XYAttrToPixel[16][16][16];
120	120	UINT16 m_dspram_bank;
121		UINT16 m_mUpperWordLatch;
122		int m_mbDSPisActive;
123		INT32 m_mAbsolutePriority;
124		INT32 m_mObjectShiftValue22;
125		UINT16 m_mPrimitiveID;
126		float m_mViewMatrix[4][4];
127		UINT8 m_mLitSurfaceInfo[MAX_LIT_SURFACES];
128		INT32 m_mSurfaceNormalFormat;
129		unsigned m_mLitSurfaceCount;
130		unsigned m_mLitSurfaceIndex;
131		int m_mPtRomSize;
132		const UINT8 *m_mpPolyH;
133		const UINT8 *m_mpPolyM;
134		const UINT8 *m_mpPolyL;
	121	UINT16 m_UpperWordLatch;
	122	int m_bDSPisActive;
	123	INT32 m_AbsolutePriority;
	124	INT32 m_ObjectShiftValue22;
	125	UINT16 m_PrimitiveID;
	126	float m_ViewMatrix[4][4];
	127	UINT8 m_LitSurfaceInfo[MAX_LIT_SURFACES];
	128	INT32 m_SurfaceNormalFormat;
	129	unsigned m_LitSurfaceCount;
	130	unsigned m_LitSurfaceIndex;
	131	int m_PtRomSize;
	132	const UINT8 *m_pPolyH;
	133	const UINT8 *m_pPolyM;
	134	const UINT8 *m_pPolyL;
135	135	UINT8 *m_dirtypal;
136	136	bitmap_ind16 *m_mix_bitmap;
137	137	tilemap_t *m_bgtilemap;

Previous

199869 Revisions

Next

---

© 1997-2024 The MAME Team