Previous

199869 Revisions

Next

r17991 Tuesday 18th September, 2012 at 11:00:03 UTC by Miodrag Milanović
Modernized nubus graphics cards screen updates (no whatsnew)

[src/mess/video]

nubus_48gc.c nubus_48gc.h nubus_cb264.c nubus_cb264.h nubus_m2hires.c nubus_m2hires.h nubus_radiustpd.c nubus_radiustpd.h nubus_spec8.c nubus_spec8.h nubus_specpdq.c nubus_specpdq.h nubus_vikbw.c nubus_vikbw.h nubus_wsportrait.c nubus_wsportrait.h

trunk/src/mess/video/nubus_wsportrait.c

r17990	r17991
19	19
20	20	#define VRAM_SIZE   (0x80000)   // 512k max
21	21
22		static SCREEN_UPDATE_RGB32( wsportrait );
23
24	22	MACHINE_CONFIG_FRAGMENT( wsportrait )
25	23	MCFG_SCREEN_ADD( WSPORTRAIT_SCREEN_NAME, RASTER)
26		MCFG_SCREEN_UPDATE_STATIC(wsportrait)
	24	MCFG_SCREEN_UPDATE_DEVICE(DEVICE_SELF, nubus_wsportrait_device, screen_update)
27	25	MCFG_SCREEN_SIZE(1024,960)
28	26	MCFG_SCREEN_REFRESH_RATE(75.0)
29	27	MCFG_SCREEN_VISIBLE_AREA(0, 640-1, 0, 870-1)
r17990	r17991
140	138
141	139	***************************************************************************/
142	140
143		static SCREEN_UPDATE_RGB32( wsportrait )
	141	UINT32 nubus_wsportrait_device::screen_update(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect)
144	142	{
145	143	UINT32 *scanline;
146	144	int x, y;
147		nubus_wsportrait_device *card = downcast<nubus_wsportrait_device *>(screen.owner());
148	145	UINT8 pixels, *vram;
149	146
150	147	// first time?  kick off the VBL timer
151		if (!card->m_screen)
	148	if (!m_screen)
152	149	{
153		card->m_screen = &screen;
154		card->m_timer->adjust(card->m_screen->time_until_pos(869, 0), 0);
	150	m_screen = &screen;
	151	m_timer->adjust(m_screen->time_until_pos(869, 0), 0);
155	152	}
156	153
157		vram = card->m_vram + 0x80;
	154	vram = m_vram + 0x80;
158	155
159		switch (card->m_mode)
	156	switch (m_mode)
160	157	{
161	158	case 0: // 1 bpp?
162	159	for (y = 0; y < 870; y++)
r17990	r17991
166	163	{
167	164	pixels = vram[(y * 128) + (BYTE4_XOR_BE(x))];
168	165
169		*scanline++ = card->m_palette[((pixels>>7)&0x1)];
170		*scanline++ = card->m_palette[((pixels>>6)&0x1)];
171		*scanline++ = card->m_palette[((pixels>>5)&0x1)];
172		*scanline++ = card->m_palette[((pixels>>4)&0x1)];
173		*scanline++ = card->m_palette[((pixels>>3)&0x1)];
174		*scanline++ = card->m_palette[((pixels>>2)&0x1)];
175		*scanline++ = card->m_palette[((pixels>>1)&0x1)];
176		*scanline++ = card->m_palette[(pixels&1)];
	166	*scanline++ = m_palette[((pixels>>7)&0x1)];
	167	*scanline++ = m_palette[((pixels>>6)&0x1)];
	168	*scanline++ = m_palette[((pixels>>5)&0x1)];
	169	*scanline++ = m_palette[((pixels>>4)&0x1)];
	170	*scanline++ = m_palette[((pixels>>3)&0x1)];
	171	*scanline++ = m_palette[((pixels>>2)&0x1)];
	172	*scanline++ = m_palette[((pixels>>1)&0x1)];
	173	*scanline++ = m_palette[(pixels&1)];
177	174	}
178	175	}
179	176	break;
r17990	r17991
186	183	{
187	184	pixels = vram[(y * 256) + (BYTE4_XOR_BE(x))];
188	185
189		*scanline++ = card->m_palette[((pixels>>6)&3)];
190		*scanline++ = card->m_palette[((pixels>>4)&3)];
191		*scanline++ = card->m_palette[((pixels>>2)&3)];
192		*scanline++ = card->m_palette[(pixels&3)];
	186	*scanline++ = m_palette[((pixels>>6)&3)];
	187	*scanline++ = m_palette[((pixels>>4)&3)];
	188	*scanline++ = m_palette[((pixels>>2)&3)];
	189	*scanline++ = m_palette[(pixels&3)];
193	190	}
194	191	}
195	192	break;
r17990	r17991
203	200	{
204	201	pixels = vram[(y * 512) + (BYTE4_XOR_BE(x))];
205	202
206		*scanline++ = card->m_palette[((pixels&0xf0)>>4)];
207		*scanline++ = card->m_palette[(pixels&0xf)];
	203	*scanline++ = m_palette[((pixels&0xf0)>>4)];
	204	*scanline++ = m_palette[(pixels&0xf)];
208	205	}
209	206	}
210	207	break;
211	208
212	209	default:
213		fatalerror("wsportrait: unknown video mode %d\n", card->m_mode);
	210	fatalerror("wsportrait: unknown video mode %d\n", m_mode);
214	211	break;
215	212	}
216	213	return 0;

trunk/src/mess/video/nubus_cb264.c

r17990	r17991
19	19
20	20	#define VRAM_SIZE   (0x200000)   // 2 megs, maxed out
21	21
22		static SCREEN_UPDATE_RGB32( cb264 );
23
24	22	MACHINE_CONFIG_FRAGMENT( cb264 )
25	23	MCFG_SCREEN_ADD( CB264_SCREEN_NAME, RASTER)
26		MCFG_SCREEN_UPDATE_STATIC(cb264)
	24	MCFG_SCREEN_UPDATE_DEVICE(DEVICE_SELF, nubus_cb264_device, screen_update)
27	25	MCFG_SCREEN_RAW_PARAMS(25175000, 800, 0, 640, 525, 0, 480)
28	26	MCFG_SCREEN_SIZE(1024,768)
29	27	MCFG_SCREEN_VISIBLE_AREA(0, 640-1, 0, 480-1)
r17990	r17991
127	125
128	126	***************************************************************************/
129	127
130		static SCREEN_UPDATE_RGB32( cb264 )
	128	UINT32 nubus_cb264_device::screen_update(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect)
131	129	{
132	130	UINT32 *scanline, *base;
133	131	int x, y;
134		nubus_cb264_device *card = downcast<nubus_cb264_device *>(screen.owner());
135	132	UINT8 pixels;
136	133
137		if (!card->m_cb264_vbl_disable)
	134	if (!m_cb264_vbl_disable)
138	135	{
139		card->raise_slot_irq();
	136	raise_slot_irq();
140	137	}
141	138
142		switch (card->m_cb264_mode)
	139	switch (m_cb264_mode)
143	140	{
144	141	case 0: // 1 bpp
145	142	for (y = 0; y < 480; y++)
r17990	r17991
147	144	scanline = &bitmap.pix32(y);
148	145	for (x = 0; x < 640/8; x++)
149	146	{
150		pixels = card->m_vram[(y * 1024) + (BYTE4_XOR_BE(x))];
	147	pixels = m_vram[(y * 1024) + (BYTE4_XOR_BE(x))];
151	148
152		*scanline++ = card->m_palette[pixels&0x80];
153		*scanline++ = card->m_palette[(pixels<<1)&0x80];
154		*scanline++ = card->m_palette[(pixels<<2)&0x80];
155		*scanline++ = card->m_palette[(pixels<<3)&0x80];
156		*scanline++ = card->m_palette[(pixels<<4)&0x80];
157		*scanline++ = card->m_palette[(pixels<<5)&0x80];
158		*scanline++ = card->m_palette[(pixels<<6)&0x80];
159		*scanline++ = card->m_palette[(pixels<<7)&0x80];
	149	*scanline++ = m_palette[pixels&0x80];
	150	*scanline++ = m_palette[(pixels<<1)&0x80];
	151	*scanline++ = m_palette[(pixels<<2)&0x80];
	152	*scanline++ = m_palette[(pixels<<3)&0x80];
	153	*scanline++ = m_palette[(pixels<<4)&0x80];
	154	*scanline++ = m_palette[(pixels<<5)&0x80];
	155	*scanline++ = m_palette[(pixels<<6)&0x80];
	156	*scanline++ = m_palette[(pixels<<7)&0x80];
160	157	}
161	158	}
162	159	break;
r17990	r17991
167	164	scanline = &bitmap.pix32(y);
168	165	for (x = 0; x < 640/4; x++)
169	166	{
170		pixels = card->m_vram[(y * 1024) + (BYTE4_XOR_BE(x))];
	167	pixels = m_vram[(y * 1024) + (BYTE4_XOR_BE(x))];
171	168
172		*scanline++ = card->m_palette[pixels&0xc0];
173		*scanline++ = card->m_palette[(pixels<<2)&0xc0];
174		*scanline++ = card->m_palette[(pixels<<4)&0xc0];
175		*scanline++ = card->m_palette[(pixels<<6)&0xc0];
	169	*scanline++ = m_palette[pixels&0xc0];
	170	*scanline++ = m_palette[(pixels<<2)&0xc0];
	171	*scanline++ = m_palette[(pixels<<4)&0xc0];
	172	*scanline++ = m_palette[(pixels<<6)&0xc0];
176	173	}
177	174	}
178	175	break;
r17990	r17991
184	181
185	182	for (x = 0; x < 640/2; x++)
186	183	{
187		pixels = card->m_vram[(y * 1024) + (BYTE4_XOR_BE(x))];
	184	pixels = m_vram[(y * 1024) + (BYTE4_XOR_BE(x))];
188	185
189		*scanline++ = card->m_palette[pixels&0xf0];
190		*scanline++ = card->m_palette[(pixels<<4)&0xf0];
	186	*scanline++ = m_palette[pixels&0xf0];
	187	*scanline++ = m_palette[(pixels<<4)&0xf0];
191	188	}
192	189	}
193	190	break;
r17990	r17991
199	196
200	197	for (x = 0; x < 640; x++)
201	198	{
202		pixels = card->m_vram[(y * 1024) + (BYTE4_XOR_BE(x))];
203		*scanline++ = card->m_palette[pixels];
	199	pixels = m_vram[(y * 1024) + (BYTE4_XOR_BE(x))];
	200	*scanline++ = m_palette[pixels];
204	201	}
205	202	}
206	203	break;
r17990	r17991
208	205	case 4:   // 24 bpp
209	206	case 7: // ???
210	207	{
211		UINT32 *vram32 = (UINT32 *)card->m_vram;
	208	UINT32 *vram32 = (UINT32 *)m_vram;
212	209
213	210	for (y = 0; y < 480; y++)
214	211	{
r17990	r17991
223	220	break;
224	221
225	222	default:
226		fatalerror("cb264: unknown video mode %d\n", card->m_cb264_mode);
	223	fatalerror("cb264: unknown video mode %d\n", m_cb264_mode);
227	224	break;
228	225	}
229	226

trunk/src/mess/video/nubus_wsportrait.h

r17990	r17991
25	25	virtual machine_config_constructor device_mconfig_additions() const;
26	26	virtual const rom_entry *device_rom_region() const;
27	27
	28	UINT32 screen_update(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect);
28	29	protected:
29	30	// device-level overrides
30	31	virtual void device_start();

trunk/src/mess/video/nubus_cb264.h

r17990	r17991
25	25	virtual machine_config_constructor device_mconfig_additions() const;
26	26	virtual const rom_entry *device_rom_region() const;
27	27
	28	UINT32 screen_update(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect);
28	29	protected:
29	30	// device-level overrides
30	31	virtual void device_start();

trunk/src/mess/video/nubus_vikbw.c

r17990	r17991
16	16
17	17	#define VRAM_SIZE   (0x18000)  // 1024x768 @ 1bpp is 98,304 bytes (0x18000)
18	18
19		static SCREEN_UPDATE_RGB32( vikbw );
20
21	19	MACHINE_CONFIG_FRAGMENT( vikbw )
22	20	MCFG_SCREEN_ADD( VIKBW_SCREEN_NAME, RASTER)
23		MCFG_SCREEN_UPDATE_STATIC(vikbw)
	21	MCFG_SCREEN_UPDATE_DEVICE(DEVICE_SELF, nubus_vikbw_device, screen_update)
24	22	MCFG_SCREEN_SIZE(1024,768)
25	23	MCFG_SCREEN_VISIBLE_AREA(0, 1024-1, 0, 768-1)
26	24	MCFG_SCREEN_REFRESH_RATE(70)
r17990	r17991
122	120
123	121	***************************************************************************/
124	122
125		static SCREEN_UPDATE_RGB32( vikbw )
	123	UINT32 nubus_vikbw_device::screen_update(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect)
126	124	{
127	125	UINT32 *scanline;
128	126	int x, y;
129		nubus_vikbw_device *card = downcast<nubus_vikbw_device *>(screen.owner());
130	127	UINT8 pixels;
131	128
132		if (!card->m_vbl_disable)
	129	if (!m_vbl_disable)
133	130	{
134		card->raise_slot_irq();
	131	raise_slot_irq();
135	132	}
136	133
137	134	for (y = 0; y < 768; y++)
r17990	r17991
139	136	scanline = &bitmap.pix32(y);
140	137	for (x = 0; x < 1024/8; x++)
141	138	{
142		pixels = card->m_vram[(y * 128) + (BYTE4_XOR_BE(x))];
	139	pixels = m_vram[(y * 128) + (BYTE4_XOR_BE(x))];
143	140
144		*scanline++ = card->m_palette[(pixels>>7)&1];
145		*scanline++ = card->m_palette[(pixels>>6)&1];
146		*scanline++ = card->m_palette[(pixels>>5)&1];
147		*scanline++ = card->m_palette[(pixels>>4)&1];
148		*scanline++ = card->m_palette[(pixels>>3)&1];
149		*scanline++ = card->m_palette[(pixels>>2)&1];
150		*scanline++ = card->m_palette[(pixels>>1)&1];
151		*scanline++ = card->m_palette[(pixels&1)];
	141	*scanline++ = m_palette[(pixels>>7)&1];
	142	*scanline++ = m_palette[(pixels>>6)&1];
	143	*scanline++ = m_palette[(pixels>>5)&1];
	144	*scanline++ = m_palette[(pixels>>4)&1];
	145	*scanline++ = m_palette[(pixels>>3)&1];
	146	*scanline++ = m_palette[(pixels>>2)&1];
	147	*scanline++ = m_palette[(pixels>>1)&1];
	148	*scanline++ = m_palette[(pixels&1)];
152	149	}
153	150	}
154	151

trunk/src/mess/video/nubus_vikbw.h

r17990	r17991
24	24	// optional information overrides
25	25	virtual machine_config_constructor device_mconfig_additions() const;
26	26	virtual const rom_entry *device_rom_region() const;
27
	27
	28	UINT32 screen_update(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect);
28	29	protected:
29	30	// device-level overrides
30	31	virtual void device_start();

trunk/src/mess/video/nubus_specpdq.c

r17990	r17991
31	31
32	32	#define VRAM_SIZE   (0x400000)
33	33
34		static SCREEN_UPDATE_RGB32( specpdq );
35
36	34	MACHINE_CONFIG_FRAGMENT( specpdq )
37	35	MCFG_SCREEN_ADD( SPECPDQ_SCREEN_NAME, RASTER)
38		MCFG_SCREEN_UPDATE_STATIC(specpdq)
	36	MCFG_SCREEN_UPDATE_DEVICE(DEVICE_SELF, nubus_specpdq_device, screen_update)
39	37	MCFG_SCREEN_RAW_PARAMS(25175000, 800, 0, 640, 525, 0, 480)
40	38	MCFG_SCREEN_SIZE(1280,1024)
41	39	MCFG_SCREEN_VISIBLE_AREA(0, 1152-1, 0, 844-1)
r17990	r17991
153	151
154	152	***************************************************************************/
155	153
156		static SCREEN_UPDATE_RGB32( specpdq )
	154	UINT32 nubus_specpdq_device::screen_update(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect)
157	155	{
158	156	UINT32 *scanline;
159	157	int x, y;
160		nubus_specpdq_device *card = downcast<nubus_specpdq_device *>(screen.owner());
161	158	UINT8 pixels, *vram;
162	159
163	160	// first time?  kick off the VBL timer
164		if (!card->m_screen)
	161	if (!m_screen)
165	162	{
166		card->m_screen = &screen;
167		card->m_timer->adjust(card->m_screen->time_until_pos(843, 0), 0);
	163	m_screen = &screen;
	164	m_timer->adjust(m_screen->time_until_pos(843, 0), 0);
168	165	}
169		vram = card->m_vram + 0x9000;
	166	vram = m_vram + 0x9000;
170	167
171		switch (card->m_mode)
	168	switch (m_mode)
172	169	{
173	170	case 0: // 1 bpp
174	171	for (y = 0; y < 844; y++)
r17990	r17991
178	175	{
179	176	pixels = vram[(y * 512) + (BYTE4_XOR_BE(x))];
180	177
181		*scanline++ = card->m_palette[(pixels&0x80)];
182		*scanline++ = card->m_palette[((pixels<<1)&0x80)];
183		*scanline++ = card->m_palette[((pixels<<2)&0x80)];
184		*scanline++ = card->m_palette[((pixels<<3)&0x80)];
185		*scanline++ = card->m_palette[((pixels<<4)&0x80)];
186		*scanline++ = card->m_palette[((pixels<<5)&0x80)];
187		*scanline++ = card->m_palette[((pixels<<6)&0x80)];
188		*scanline++ = card->m_palette[((pixels<<7)&0x80)];
	178	*scanline++ = m_palette[(pixels&0x80)];
	179	*scanline++ = m_palette[((pixels<<1)&0x80)];
	180	*scanline++ = m_palette[((pixels<<2)&0x80)];
	181	*scanline++ = m_palette[((pixels<<3)&0x80)];
	182	*scanline++ = m_palette[((pixels<<4)&0x80)];
	183	*scanline++ = m_palette[((pixels<<5)&0x80)];
	184	*scanline++ = m_palette[((pixels<<6)&0x80)];
	185	*scanline++ = m_palette[((pixels<<7)&0x80)];
189	186	}
190	187	}
191	188	break;
r17990	r17991
198	195	{
199	196	pixels = vram[(y * 512) + (BYTE4_XOR_BE(x))];
200	197
201		*scanline++ = card->m_palette[(pixels&0xc0)];
202		*scanline++ = card->m_palette[((pixels<<2)&0xc0)];
203		*scanline++ = card->m_palette[((pixels<<4)&0xc0)];
204		*scanline++ = card->m_palette[((pixels<<6)&0xc0)];
	198	*scanline++ = m_palette[(pixels&0xc0)];
	199	*scanline++ = m_palette[((pixels<<2)&0xc0)];
	200	*scanline++ = m_palette[((pixels<<4)&0xc0)];
	201	*scanline++ = m_palette[((pixels<<6)&0xc0)];
205	202	}
206	203	}
207	204	break;
r17990	r17991
215	212	{
216	213	pixels = vram[(y * 1024) + (BYTE4_XOR_BE(x))];
217	214
218		*scanline++ = card->m_palette[(pixels&0xf0)];
219		*scanline++ = card->m_palette[((pixels<<4)&0xf0)];
	215	*scanline++ = m_palette[(pixels&0xf0)];
	216	*scanline++ = m_palette[((pixels<<4)&0xf0)];
220	217	}
221	218	}
222	219	break;
r17990	r17991
229	226	for (x = 0; x < 1152; x++)
230	227	{
231	228	pixels = vram[(y * 1152) + (BYTE4_XOR_BE(x))];
232		*scanline++ = card->m_palette[pixels];
	229	*scanline++ = m_palette[pixels];
233	230	}
234	231	}
235	232	break;
236	233
237	234	default:
238		fatalerror("specpdq: unknown video mode %d\n", card->m_mode);
	235	fatalerror("specpdq: unknown video mode %d\n", m_mode);
239	236	break;
240	237	}
241	238	return 0;

trunk/src/mess/video/nubus_specpdq.h

r17990	r17991
26	26	virtual const rom_entry *device_rom_region() const;
27	27	virtual void device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr);
28	28
	29	UINT32 screen_update(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect);
29	30	protected:
30	31	// device-level overrides
31	32	virtual void device_start();

trunk/src/mess/video/nubus_48gc.c

r17990	r17991
14	14
15	15	#define VRAM_SIZE   (0x200000)   // 2 megs, maxed out
16	16
17		static SCREEN_UPDATE_RGB32( mac_48gc );
18
19	17	MACHINE_CONFIG_FRAGMENT( macvideo_48gc )
20	18	MCFG_SCREEN_ADD( GC48_SCREEN_NAME, RASTER)
21		MCFG_SCREEN_UPDATE_STATIC( mac_48gc )
	19	MCFG_SCREEN_UPDATE_DEVICE(DEVICE_SELF, jmfb_device, screen_update)
22	20	MCFG_SCREEN_RAW_PARAMS(25175000, 800, 0, 640, 525, 0, 480)
23	21	//  MCFG_SCREEN_SIZE(1152, 870)
24	22	//  MCFG_SCREEN_VISIBLE_AREA(0, 1152-1, 0, 870-1)
r17990	r17991
141	139
142	140	***************************************************************************/
143	141
144		static SCREEN_UPDATE_RGB32( mac_48gc )
	142	UINT32 jmfb_device::screen_update(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect)
145	143	{
146		jmfb_device *card = downcast<jmfb_device *>(screen.owner());
147	144	UINT32 *scanline, *base;
148	145	int x, y;
149		UINT8 *vram8 = (UINT8 *)card->m_vram;
	146	UINT8 *vram8 = (UINT8 *)m_vram;
150	147	UINT8 pixels;
151	148
152		if (!card->m_vbl_disable)
	149	if (!m_vbl_disable)
153	150	{
154		card->raise_slot_irq();
	151	raise_slot_irq();
155	152	}
156	153
157	154	vram8 += 0xa00;
158	155
159		switch (card->m_mode)
	156	switch (m_mode)
160	157	{
161	158	case 0:   // 1bpp
162		for (y = 0; y < card->m_yres; y++)
	159	for (y = 0; y < m_yres; y++)
163	160	{
164	161	scanline = &bitmap.pix32(y);
165		for (x = 0; x < card->m_xres/8; x++)
	162	for (x = 0; x < m_xres/8; x++)
166	163	{
167		pixels = vram8[(y * card->m_stride) + (BYTE4_XOR_BE(x))];
	164	pixels = vram8[(y * m_stride) + (BYTE4_XOR_BE(x))];
168	165
169		*scanline++ = card->m_palette[(pixels>>7)&1];
170		*scanline++ = card->m_palette[(pixels>>6)&1];
171		*scanline++ = card->m_palette[(pixels>>5)&1];
172		*scanline++ = card->m_palette[(pixels>>4)&1];
173		*scanline++ = card->m_palette[(pixels>>3)&1];
174		*scanline++ = card->m_palette[(pixels>>2)&1];
175		*scanline++ = card->m_palette[(pixels>>1)&1];
176		*scanline++ = card->m_palette[pixels&1];
	166	*scanline++ = m_palette[(pixels>>7)&1];
	167	*scanline++ = m_palette[(pixels>>6)&1];
	168	*scanline++ = m_palette[(pixels>>5)&1];
	169	*scanline++ = m_palette[(pixels>>4)&1];
	170	*scanline++ = m_palette[(pixels>>3)&1];
	171	*scanline++ = m_palette[(pixels>>2)&1];
	172	*scanline++ = m_palette[(pixels>>1)&1];
	173	*scanline++ = m_palette[pixels&1];
177	174	}
178	175	}
179	176	break;
180	177
181	178	case 1:   // 2bpp
182		for (y = 0; y < card->m_yres; y++)
	179	for (y = 0; y < m_yres; y++)
183	180	{
184	181	scanline = &bitmap.pix32(y);
185		for (x = 0; x < card->m_xres/4; x++)
	182	for (x = 0; x < m_xres/4; x++)
186	183	{
187		pixels = vram8[(y * card->m_stride) + (BYTE4_XOR_BE(x))];
	184	pixels = vram8[(y * m_stride) + (BYTE4_XOR_BE(x))];
188	185
189		*scanline++ = card->m_palette[(pixels>>6)&0x3];
190		*scanline++ = card->m_palette[(pixels>>4)&0x3];
191		*scanline++ = card->m_palette[(pixels>>2)&0x3];
192		*scanline++ = card->m_palette[pixels&3];
	186	*scanline++ = m_palette[(pixels>>6)&0x3];
	187	*scanline++ = m_palette[(pixels>>4)&0x3];
	188	*scanline++ = m_palette[(pixels>>2)&0x3];
	189	*scanline++ = m_palette[pixels&3];
193	190	}
194	191	}
195	192	break;
196	193
197	194	case 2: // 4 bpp
198		for (y = 0; y < card->m_yres; y++)
	195	for (y = 0; y < m_yres; y++)
199	196	{
200	197	scanline = &bitmap.pix32(y);
201	198
202		for (x = 0; x < card->m_xres/2; x++)
	199	for (x = 0; x < m_xres/2; x++)
203	200	{
204		pixels = vram8[(y * card->m_stride) + (BYTE4_XOR_BE(x))];
	201	pixels = vram8[(y * m_stride) + (BYTE4_XOR_BE(x))];
205	202
206		*scanline++ = card->m_palette[(pixels>>4)&0xf];
207		*scanline++ = card->m_palette[pixels&0xf];
	203	*scanline++ = m_palette[(pixels>>4)&0xf];
	204	*scanline++ = m_palette[pixels&0xf];
208	205	}
209	206	}
210	207	break;
211	208
212	209	case 3: // 8 bpp
213		for (y = 0; y < card->m_yres; y++)
	210	for (y = 0; y < m_yres; y++)
214	211	{
215	212	scanline = &bitmap.pix32(y);
216	213
217		for (x = 0; x < card->m_xres; x++)
	214	for (x = 0; x < m_xres; x++)
218	215	{
219		pixels = vram8[(y * card->m_stride) + (BYTE4_XOR_BE(x))];
220		*scanline++ = card->m_palette[pixels];
	216	pixels = vram8[(y * m_stride) + (BYTE4_XOR_BE(x))];
	217	*scanline++ = m_palette[pixels];
221	218	}
222	219	}
223	220	break;
224	221
225	222	case 4: // 24 bpp
226		for (y = 0; y < card->m_yres; y++)
	223	for (y = 0; y < m_yres; y++)
227	224	{
228	225	scanline = &bitmap.pix32(y);
229		base = (UINT32 *)&card->m_vram[y * card->m_stride];
230		for (x = 0; x < card->m_xres; x++)
	226	base = (UINT32 *)&m_vram[y * m_stride];
	227	for (x = 0; x < m_xres; x++)
231	228	{
232	229	*scanline++ = *base++;
233	230	}

trunk/src/mess/video/nubus_48gc.h

r17990	r17991
24	24	virtual machine_config_constructor device_mconfig_additions() const;
25	25	virtual const rom_entry *device_rom_region() const;
26	26
	27	UINT32 screen_update(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect);
27	28	protected:
28	29	// device-level overrides
29	30	virtual void device_start();

trunk/src/mess/video/nubus_m2hires.c

r17990	r17991
16	16
17	17	#define VRAM_SIZE   (0x80000)   // 512k max
18	18
19		static SCREEN_UPDATE_RGB32( m2hires );
20
21	19	MACHINE_CONFIG_FRAGMENT( m2hires )
22	20	MCFG_SCREEN_ADD( M2HIRES_SCREEN_NAME, RASTER)
23		MCFG_SCREEN_UPDATE_STATIC(m2hires)
	21	MCFG_SCREEN_UPDATE_DEVICE(DEVICE_SELF, nubus_m2hires_device, screen_update)
24	22	MCFG_SCREEN_RAW_PARAMS(25175000, 800, 0, 640, 525, 0, 480)
25	23	MCFG_SCREEN_SIZE(1024,768)
26	24	MCFG_SCREEN_VISIBLE_AREA(0, 640-1, 0, 480-1)
r17990	r17991
140	138
141	139	***************************************************************************/
142	140
143		static SCREEN_UPDATE_RGB32( m2hires )
	141	UINT32 nubus_m2hires_device::screen_update(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect)
144	142	{
145	143	UINT32 *scanline;
146	144	int x, y;
147		nubus_m2hires_device *card = downcast<nubus_m2hires_device *>(screen.owner());
148	145	UINT8 pixels, *vram;
149	146
150	147	// first time?  kick off the VBL timer
151		if (!card->m_screen)
	148	if (!m_screen)
152	149	{
153		card->m_screen = &screen;
154		card->m_timer->adjust(card->m_screen->time_until_pos(479, 0), 0);
	150	m_screen = &screen;
	151	m_timer->adjust(m_screen->time_until_pos(479, 0), 0);
155	152	}
156	153
157		vram = card->m_vram + 0x20;
	154	vram = m_vram + 0x20;
158	155
159		switch (card->m_mode)
	156	switch (m_mode)
160	157	{
161	158	case 0: // 1 bpp?
162	159	for (y = 0; y < 480; y++)
r17990	r17991
166	163	{
167	164	pixels = vram[(y * 128) + (BYTE4_XOR_BE(x))];
168	165
169		*scanline++ = card->m_palette[((pixels>>7)&0x1)];
170		*scanline++ = card->m_palette[((pixels>>6)&0x1)];
171		*scanline++ = card->m_palette[((pixels>>5)&0x1)];
172		*scanline++ = card->m_palette[((pixels>>4)&0x1)];
173		*scanline++ = card->m_palette[((pixels>>3)&0x1)];
174		*scanline++ = card->m_palette[((pixels>>2)&0x1)];
175		*scanline++ = card->m_palette[((pixels>>1)&0x1)];
176		*scanline++ = card->m_palette[(pixels&1)];
	166	*scanline++ = m_palette[((pixels>>7)&0x1)];
	167	*scanline++ = m_palette[((pixels>>6)&0x1)];
	168	*scanline++ = m_palette[((pixels>>5)&0x1)];
	169	*scanline++ = m_palette[((pixels>>4)&0x1)];
	170	*scanline++ = m_palette[((pixels>>3)&0x1)];
	171	*scanline++ = m_palette[((pixels>>2)&0x1)];
	172	*scanline++ = m_palette[((pixels>>1)&0x1)];
	173	*scanline++ = m_palette[(pixels&1)];
177	174	}
178	175	}
179	176	break;
r17990	r17991
186	183	{
187	184	pixels = vram[(y * 256) + (BYTE4_XOR_BE(x))];
188	185
189		*scanline++ = card->m_palette[((pixels>>6)&3)];
190		*scanline++ = card->m_palette[((pixels>>4)&3)];
191		*scanline++ = card->m_palette[((pixels>>2)&3)];
192		*scanline++ = card->m_palette[(pixels&3)];
	186	*scanline++ = m_palette[((pixels>>6)&3)];
	187	*scanline++ = m_palette[((pixels>>4)&3)];
	188	*scanline++ = m_palette[((pixels>>2)&3)];
	189	*scanline++ = m_palette[(pixels&3)];
193	190	}
194	191	}
195	192	break;
r17990	r17991
203	200	{
204	201	pixels = vram[(y * 512) + (BYTE4_XOR_BE(x))];
205	202
206		*scanline++ = card->m_palette[((pixels&0xf0)>>4)];
207		*scanline++ = card->m_palette[(pixels&0xf)];
	203	*scanline++ = m_palette[((pixels&0xf0)>>4)];
	204	*scanline++ = m_palette[(pixels&0xf)];
208	205	}
209	206	}
210	207	break;
r17990	r17991
217	214	for (x = 0; x < 640; x++)
218	215	{
219	216	pixels = vram[(y * 1024) + (BYTE4_XOR_BE(x))];
220		*scanline++ = card->m_palette[pixels];
	217	*scanline++ = m_palette[pixels];
221	218	}
222	219	}
223	220	break;
224	221
225	222	default:
226		fatalerror("m2hires: unknown video mode %d\n", card->m_mode);
	223	fatalerror("m2hires: unknown video mode %d\n", m_mode);
227	224	break;
228	225	}
229	226	return 0;

trunk/src/mess/video/nubus_m2hires.h

r17990	r17991
25	25	virtual machine_config_constructor device_mconfig_additions() const;
26	26	virtual const rom_entry *device_rom_region() const;
27	27
	28	UINT32 screen_update(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect);
28	29	protected:
29	30	// device-level overrides
30	31	virtual void device_start();

trunk/src/mess/video/nubus_spec8.c

r17990	r17991
18	18
19	19	#define VRAM_SIZE   (0xc0000)   // 768k of VRAM for 1024x768 @ 8 bit
20	20
21		static SCREEN_UPDATE_RGB32( spec8s3 );
22
23	21	MACHINE_CONFIG_FRAGMENT( spec8s3 )
24	22	MCFG_SCREEN_ADD( SPEC8S3_SCREEN_NAME, RASTER)
25		MCFG_SCREEN_UPDATE_STATIC(spec8s3)
	23	MCFG_SCREEN_UPDATE_DEVICE(DEVICE_SELF, nubus_spec8s3_device, screen_update)
26	24	MCFG_SCREEN_RAW_PARAMS(25175000, 800, 0, 640, 525, 0, 480)
27	25	MCFG_SCREEN_SIZE(1024,768)
28	26	MCFG_SCREEN_VISIBLE_AREA(0, 1024-1, 0, 768-1)
r17990	r17991
144	142
145	143	***************************************************************************/
146	144
147		static SCREEN_UPDATE_RGB32( spec8s3 )
	145	UINT32 nubus_spec8s3_device::screen_update(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect)
148	146	{
149	147	UINT32 *scanline;
150	148	int x, y;
151		nubus_spec8s3_device *card = downcast<nubus_spec8s3_device *>(screen.owner());
152	149	UINT8 pixels, *vram;
153	150
154	151	// first time?  kick off the VBL timer
155		if (!card->m_screen)
	152	if (!m_screen)
156	153	{
157		card->m_screen = &screen;
158		card->m_timer->adjust(card->m_screen->time_until_pos(767, 0), 0);
	154	m_screen = &screen;
	155	m_timer->adjust(m_screen->time_until_pos(767, 0), 0);
159	156	}
160		vram = card->m_vram + 0x400;
	157	vram = m_vram + 0x400;
161	158
162		switch (card->m_mode)
	159	switch (m_mode)
163	160	{
164	161	case 0: // 1 bpp
165	162	for (y = 0; y < 768; y++)
r17990	r17991
169	166	{
170	167	pixels = vram[(y * 512) + (BYTE4_XOR_BE(x))];
171	168
172		*scanline++ = card->m_palette[pixels&0x80];
173		*scanline++ = card->m_palette[(pixels<<1)&0x80];
174		*scanline++ = card->m_palette[(pixels<<2)&0x80];
175		*scanline++ = card->m_palette[(pixels<<3)&0x80];
176		*scanline++ = card->m_palette[(pixels<<4)&0x80];
177		*scanline++ = card->m_palette[(pixels<<5)&0x80];
178		*scanline++ = card->m_palette[(pixels<<6)&0x80];
179		*scanline++ = card->m_palette[(pixels<<7)&0x80];
	169	*scanline++ = m_palette[pixels&0x80];
	170	*scanline++ = m_palette[(pixels<<1)&0x80];
	171	*scanline++ = m_palette[(pixels<<2)&0x80];
	172	*scanline++ = m_palette[(pixels<<3)&0x80];
	173	*scanline++ = m_palette[(pixels<<4)&0x80];
	174	*scanline++ = m_palette[(pixels<<5)&0x80];
	175	*scanline++ = m_palette[(pixels<<6)&0x80];
	176	*scanline++ = m_palette[(pixels<<7)&0x80];
180	177	}
181	178	}
182	179	break;
r17990	r17991
189	186	{
190	187	pixels = vram[(y * 512) + (BYTE4_XOR_BE(x))];
191	188
192		*scanline++ = card->m_palette[pixels&0xc0];
193		*scanline++ = card->m_palette[(pixels<<2)&0xc0];
194		*scanline++ = card->m_palette[(pixels<<4)&0xc0];
195		*scanline++ = card->m_palette[(pixels<<6)&0xc0];
	189	*scanline++ = m_palette[pixels&0xc0];
	190	*scanline++ = m_palette[(pixels<<2)&0xc0];
	191	*scanline++ = m_palette[(pixels<<4)&0xc0];
	192	*scanline++ = m_palette[(pixels<<6)&0xc0];
196	193	}
197	194	}
198	195	break;
r17990	r17991
206	203	{
207	204	pixels = vram[(y * 512) + (BYTE4_XOR_BE(x))];
208	205
209		*scanline++ = card->m_palette[pixels&0xf0];
210		*scanline++ = card->m_palette[(pixels<<4)&0xf0];
	206	*scanline++ = m_palette[pixels&0xf0];
	207	*scanline++ = m_palette[(pixels<<4)&0xf0];
211	208	}
212	209	}
213	210	break;
r17990	r17991
220	217	for (x = 0; x < 1024; x++)
221	218	{
222	219	pixels = vram[(y * 1024) + (BYTE4_XOR_BE(x))];
223		*scanline++ = card->m_palette[pixels];
	220	*scanline++ = m_palette[pixels];
224	221	}
225	222	}
226	223	break;
227	224
228	225	default:
229		fatalerror("spec8s3: unknown video mode %d\n", card->m_mode);
	226	fatalerror("spec8s3: unknown video mode %d\n", m_mode);
230	227	break;
231	228	}
232	229	return 0;

trunk/src/mess/video/nubus_spec8.h

r17990	r17991
26	26	virtual const rom_entry *device_rom_region() const;
27	27	virtual void device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr);
28	28
	29	UINT32 screen_update(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect);
29	30	protected:
30	31	// device-level overrides
31	32	virtual void device_start();

trunk/src/mess/video/nubus_radiustpd.c

r17990	r17991
16	16
17	17	#define VRAM_SIZE   (0x40000)   // 256k.  1152x880 1 bit per pixel fits nicely.
18	18
19		static SCREEN_UPDATE_RGB32( radiustpd );
20
21	19	MACHINE_CONFIG_FRAGMENT( radiustpd )
22	20	MCFG_SCREEN_ADD( RADIUSTPD_SCREEN_NAME, RASTER)
23		MCFG_SCREEN_UPDATE_STATIC(radiustpd)
	21	MCFG_SCREEN_UPDATE_DEVICE(DEVICE_SELF, nubus_radiustpd_device, screen_update)
24	22	MCFG_SCREEN_SIZE(1280, 960)
25	23	MCFG_SCREEN_REFRESH_RATE(70)
26	24	MCFG_SCREEN_VISIBLE_AREA(0, 1152-1, 0, 880-1)
r17990	r17991
141	139
142	140	***************************************************************************/
143	141
144		static SCREEN_UPDATE_RGB32( radiustpd )
	142	UINT32 nubus_radiustpd_device::screen_update(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect)
145	143	{
146	144	UINT32 *scanline;
147	145	int x, y;
148		nubus_radiustpd_device *card = downcast<nubus_radiustpd_device *>(screen.owner());
149	146	UINT8 pixels, *vram;
150	147
151	148	// first time?  kick off the VBL timer
152		if (!card->m_screen)
	149	if (!m_screen)
153	150	{
154		card->m_screen = &screen;
155		card->m_timer->adjust(card->m_screen->time_until_pos(479, 0), 0);
	151	m_screen = &screen;
	152	m_timer->adjust(m_screen->time_until_pos(479, 0), 0);
156	153	}
157	154
158		vram = card->m_vram + 0x200;
	155	vram = m_vram + 0x200;
159	156
160	157	for (y = 0; y < 880; y++)
161	158	{
r17990	r17991
164	161	{
165	162	pixels = vram[(y * (1152/8)) + (BYTE4_XOR_BE(x))];
166	163
167		*scanline++ = card->m_palette[((pixels>>7)&0x1)];
168		*scanline++ = card->m_palette[((pixels>>6)&0x1)];
169		*scanline++ = card->m_palette[((pixels>>5)&0x1)];
170		*scanline++ = card->m_palette[((pixels>>4)&0x1)];
171		*scanline++ = card->m_palette[((pixels>>3)&0x1)];
172		*scanline++ = card->m_palette[((pixels>>2)&0x1)];
173		*scanline++ = card->m_palette[((pixels>>1)&0x1)];
174		*scanline++ = card->m_palette[(pixels&1)];
	164	*scanline++ = m_palette[((pixels>>7)&0x1)];
	165	*scanline++ = m_palette[((pixels>>6)&0x1)];
	166	*scanline++ = m_palette[((pixels>>5)&0x1)];
	167	*scanline++ = m_palette[((pixels>>4)&0x1)];
	168	*scanline++ = m_palette[((pixels>>3)&0x1)];
	169	*scanline++ = m_palette[((pixels>>2)&0x1)];
	170	*scanline++ = m_palette[((pixels>>1)&0x1)];
	171	*scanline++ = m_palette[(pixels&1)];
175	172	}
176	173	}
177	174

trunk/src/mess/video/nubus_radiustpd.h

r17990	r17991
25	25	virtual machine_config_constructor device_mconfig_additions() const;
26	26	virtual const rom_entry *device_rom_region() const;
27	27
	28	UINT32 screen_update(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect);
28	29	protected:
29	30	// device-level overrides
30	31	virtual void device_start();

Previous

199869 Revisions

Next

---

© 1997-2024 The MAME Team