Previous

15994 Revisions

Next

r2201 Tuesday 1st April, 2008 at 17:20:24 UTC by Firewave
Removed unncessary machine->pens lookups

[src/mess/video]

cdp1864.c crt.c dai.c electron.c enterp.c epnick.c epnick.h exidy.c galaxy.c gamecom.c gb.c hd66421.c hp48.c kc.c lviv.c nc.c nes.c odyssey2.c oric.c pcw.c pcw16.c pmd85.c primo.c

src/mess/video/hp48.c

r2200	r2201
121	121	VIDEO_UPDATE( hp48 )
122	122	{
123	123	int x, y, i, p, data, max_y;
124		int color[2];
125	124	//   int contrast=(hp48_hardware.data[1]|((hp48_hardware.data[2]&1)<<4));
126	125
127		/* HJB: we cannot initialize array with values from other arrays, thus... */
128		color[0] = screen->machine->pens[0];
129		color[1] = screen->machine->pens[1];
130
131	126	i = LCD_MAIN_BASE_ADDRESS;
132	127	max_y = MIN(64, LCD_MAIN_SIZE + 1 );
133	128	if ( max_y < 3 ) {
r2200	r2201
169	164	}
170	165
171	166	hp48_draw_special(bitmap,RIGHT+12,DOWN-13,hp48_orange,
172		hp48_hardware.data[0xb]&1?color[1]:color[1]);
	167	hp48_hardware.data[0xb]&1?1:1);
173	168	hp48_draw_special(bitmap,RIGHT+57,DOWN-13,hp48_blue,
174		hp48_hardware.data[0xb]&2?color[1]:color[0]);
	169	hp48_hardware.data[0xb]&2?1:0);
175	170	hp48_draw_special(bitmap,RIGHT+102,DOWN-13,hp48_alpha,
176		hp48_hardware.data[0xb]&4?color[1]:color[0]);
	171	hp48_hardware.data[0xb]&4?1:0);
177	172	hp48_draw_special(bitmap,RIGHT+147,DOWN-13,hp48_alarm,
178		hp48_hardware.data[0xb]&8?color[1]:color[0]);
	173	hp48_hardware.data[0xb]&8?1:0);
179	174	hp48_draw_special(bitmap,RIGHT+192,DOWN-13,hp48_busy,
180		hp48_hardware.data[0xc]&1?color[1]:color[0]);
	175	hp48_hardware.data[0xc]&1?1:0);
181	176	hp48_draw_special(bitmap,RIGHT+237,DOWN-13,hp48_transmit,
182		hp48_hardware.data[0xc]&2?color[1]:color[0]);
	177	hp48_hardware.data[0xc]&2?1:0);
183	178	return 0;
184	179	}

src/mess/video/dai.c

r2200	r2201
132	132	{
133	133	current_colour = dai_4_colours_palette[(((current_data_1>>(7-k)) & 0x01)<<1) | ((current_data_2>>(7-k)) & 0x01)];
134	134	for (l=0; l<12; l++)
135		*BITMAP_ADDR16(bitmap, current_scan_line/2 + j, (i*8+k)*12+l) = screen->machine->pens[current_colour];
	135	*BITMAP_ADDR16(bitmap, current_scan_line/2 + j, (i*8+k)*12+l) = current_colour;
136	136	}
137	137	}
138	138	}
r2200	r2201
149	149	{
150	150	current_colour = dai_4_colours_palette[(((current_data_1>>(7-k)) & 0x01)<<1) | ((current_data_2>>(7-k)) & 0x01)];
151	151	for (l=0; l<12; l++)
152		*BITMAP_ADDR16(bitmap, current_scan_line/2 + j, (i*8+k)*12+l) = screen->machine->pens[current_colour];
	152	*BITMAP_ADDR16(bitmap, current_scan_line/2 + j, (i*8+k)*12+l) = current_colour;
153	153	}
154	154	}
155	155	}
r2200	r2201
171	171	{
172	172	current_colour = dai_4_colours_palette[(((current_data_1>>(7-k)) & 0x01)<<1) | ((current_data_2>>(7-k)) & 0x01)];
173	173	for (l=0; l<6; l++)
174		*BITMAP_ADDR16(bitmap, current_scan_line/2 + j, (i*8+k)*6+l) = screen->machine->pens[current_colour];
	174	*BITMAP_ADDR16(bitmap, current_scan_line/2 + j, (i*8+k)*6+l) = current_colour;
175	175	}
176	176	}
177	177	}
r2200	r2201
188	188	{
189	189	current_colour = dai_4_colours_palette[(((current_data_1>>(7-k)) & 0x01)<<1) | ((current_data_2>>(7-k)) & 0x01)];
190	190	for (l=0; l<6; l++)
191		*BITMAP_ADDR16(bitmap, current_scan_line/2 + j, (i*8+k)*6+l) = screen->machine->pens[current_colour];
	191	*BITMAP_ADDR16(bitmap, current_scan_line/2 + j, (i*8+k)*6+l) = current_colour;
192	192	}
193	193	}
194	194	}
r2200	r2201
210	210	{
211	211	current_colour = dai_4_colours_palette[(((current_data_1>>(7-k)) & 0x01)<<1) | ((current_data_2>>(7-k)) & 0x01)];
212	212	for (l=0; l<3; l++)
213		*BITMAP_ADDR16(bitmap, current_scan_line/2 + j, (i*8+k)*3+l) = screen->machine->pens[current_colour];
	213	*BITMAP_ADDR16(bitmap, current_scan_line/2 + j, (i*8+k)*3+l) = current_colour;
214	214	}
215	215	}
216	216	}
r2200	r2201
226	226	{
227	227	current_colour = dai_4_colours_palette[(((current_data_1>>(7-k)) & 0x01)<<1) | ((current_data_2>>(7-k)) & 0x01)];
228	228	for (l=0; l<3; l++)
229		*BITMAP_ADDR16(bitmap, current_scan_line/2 + j, (i*8+k)*3+l) = screen->machine->pens[current_colour];
	229	*BITMAP_ADDR16(bitmap, current_scan_line/2 + j, (i*8+k)*3+l) = current_colour;
230	230	}
231	231	}
232	232	}
r2200	r2201
248	248	{
249	249	current_colour = dai_4_colours_palette[(((current_data_1>>(7-k)) & 0x01)<<1) | ((current_data_2>>(7-k)) & 0x01)];
250	250	for (l=0; l<2; l++)
251		*BITMAP_ADDR16(bitmap, current_scan_line/2 + j, (i*8+k)*2+l) = screen->machine->pens[current_colour];
	251	*BITMAP_ADDR16(bitmap, current_scan_line/2 + j, (i*8+k)*2+l) = current_colour;
252	252	}
253	253	}
254	254	}
r2200	r2201
264	264	{
265	265	current_colour = dai_4_colours_palette[(((current_data_1>>(7-k)) & 0x01)<<1) | ((current_data_2>>(7-k)) & 0x01)];
266	266	for (l=0; l<2; l++)
267		*BITMAP_ADDR16(bitmap, current_scan_line/2 + j, (i*8+k)*2+l) = screen->machine->pens[current_colour];
	267	*BITMAP_ADDR16(bitmap, current_scan_line/2 + j, (i*8+k)*2+l) = current_colour;
268	268	}
269	269	}
270	270	}
r2200	r2201
293	293	{
294	294	current_colour = dai_4_colours_palette[(((current_data_2 >> k)&0x01)<<1) | ((char_rom[current_data_1*16+j]>>k) & 0x01)];
295	295	for (l=0; l<12; l++)
296		*BITMAP_ADDR16(bitmap, current_scan_line/2 + j, (i*8+k)*12+l) = screen->machine->pens[current_colour];
	296	*BITMAP_ADDR16(bitmap, current_scan_line/2 + j, (i*8+k)*12+l) = current_colour;
297	297	}
298	298	}
299	299	}
r2200	r2201
311	311	{
312	312	current_colour = dai_4_colours_palette[(((current_data_2 >> k)&0x01)<<1) | ((char_rom[current_data_1*16+j]>>k) & 0x01)];
313	313	for (l=0; l<12; l++)
314		*BITMAP_ADDR16(bitmap, current_scan_line/2 + j, (i*8+k)*12+l) = screen->machine->pens[current_colour];
	314	*BITMAP_ADDR16(bitmap, current_scan_line/2 + j, (i*8+k)*12+l) = current_colour;
315	315	}
316	316	}
317	317	}
r2200	r2201
334	334	{
335	335	current_colour = dai_4_colours_palette[(((current_data_2 >> k)&0x01)<<1) | ((char_rom[current_data_1*16+j]>>k) & 0x01)];
336	336	for (l=0; l<6; l++)
337		*BITMAP_ADDR16(bitmap, current_scan_line/2 + j, (i*8+k)*6+l) = screen->machine->pens[current_colour];
	337	*BITMAP_ADDR16(bitmap, current_scan_line/2 + j, (i*8+k)*6+l) = current_colour;
338	338	}
339	339	}
340	340	}
r2200	r2201
352	352	{
353	353	current_colour = dai_4_colours_palette[(((current_data_2 >> k)&0x01)<<1) | ((char_rom[current_data_1*16+j]>>k) & 0x01)];
354	354	for (l=0; l<6; l++)
355		*BITMAP_ADDR16(bitmap, current_scan_line/2 + j, (i*8+k)*6+l) = screen->machine->pens[current_colour];
	355	*BITMAP_ADDR16(bitmap, current_scan_line/2 + j, (i*8+k)*6+l) = current_colour;
356	356	}
357	357	}
358	358	}
r2200	r2201
375	375	{
376	376	current_colour = dai_4_colours_palette[(((current_data_2 >> k)&0x01)<<1) | ((char_rom[current_data_1*16+j]>>k) & 0x01)];
377	377	for (l=0; l<3; l++)
378		*BITMAP_ADDR16(bitmap, current_scan_line/2 + j, (i*8+k)*3+l) = screen->machine->pens[current_colour];
	378	*BITMAP_ADDR16(bitmap, current_scan_line/2 + j, (i*8+k)*3+l) = current_colour;
379	379	}
380	380	}
381	381	}
r2200	r2201
392	392	{
393	393	current_colour = dai_4_colours_palette[(((current_data_2 >> k)&0x01)<<1) | ((char_rom[current_data_1*16+j]>>k) & 0x01)];
394	394	for (l=0; l<3; l++)
395		*BITMAP_ADDR16(bitmap, current_scan_line/2 + j, (i*8+k)*3+l) = screen->machine->pens[current_colour];
	395	*BITMAP_ADDR16(bitmap, current_scan_line/2 + j, (i*8+k)*3+l) = current_colour;
396	396	}
397	397	}
398	398	}
r2200	r2201
414	414	{
415	415	current_colour = dai_4_colours_palette[(((current_data_2 >> k)&0x01)<<1) | ((char_rom[current_data_1*16+j]>>k) & 0x01)];
416	416	for (l=0; l<2; l++)
417		*BITMAP_ADDR16(bitmap, current_scan_line/2 + j, (i*8+k)*2+l) = screen->machine->pens[current_colour];
	417	*BITMAP_ADDR16(bitmap, current_scan_line/2 + j, (i*8+k)*2+l) = current_colour;
418	418	}
419	419	}
420	420	}
r2200	r2201
431	431	{
432	432	current_colour = dai_4_colours_palette[(((current_data_2 >> k)&0x01)<<1) | ((char_rom[current_data_1*16+j]>>k) & 0x01)];
433	433	for (l=0; l<2; l++)
434		*BITMAP_ADDR16(bitmap, current_scan_line/2 + j, (i*8+k)*2+l) = screen->machine->pens[current_colour];
	434	*BITMAP_ADDR16(bitmap, current_scan_line/2 + j, (i*8+k)*2+l) = current_colour;
435	435	}
436	436	}
437	437	}
r2200	r2201
459	459	{
460	460	current_colour = ((current_data_1>>(7-k)) & 0x01) ? (current_data_2>>4)&0x0f : current_data_2&0x0f;
461	461	for (l=0; l<12; l++)
462		*BITMAP_ADDR16(bitmap, current_scan_line/2 + j, (i*8+k)*12+l) = screen->machine->pens[current_colour];
	462	*BITMAP_ADDR16(bitmap, current_scan_line/2 + j, (i*8+k)*12+l) = current_colour;
463	463	}
464	464	}
465	465	}
r2200	r2201
476	476	{
477	477	current_colour = ((current_data_1>>(7-k)) & 0x01) ? (current_data_2>>4)&0x0f : current_data_2&0x0f;
478	478	for (l=0; l<12; l++)
479		*BITMAP_ADDR16(bitmap, current_scan_line/2 + j, (i*8+k)*12+l) = screen->machine->pens[current_colour];
	479	*BITMAP_ADDR16(bitmap, current_scan_line/2 + j, (i*8+k)*12+l) = current_colour;
480	480	}
481	481	}
482	482	}
r2200	r2201
498	498	{
499	499	current_colour = ((current_data_1>>(7-k)) & 0x01) ? (current_data_2>>4)&0x0f : current_data_2&0x0f;
500	500	for (l=0; l<6; l++)
501		*BITMAP_ADDR16(bitmap, current_scan_line/2 + j, (i*8+k)*6+l) = screen->machine->pens[current_colour];
	501	*BITMAP_ADDR16(bitmap, current_scan_line/2 + j, (i*8+k)*6+l) = current_colour;
502	502	}
503	503	}
504	504	}
r2200	r2201
515	515	{
516	516	current_colour = ((current_data_1>>(7-k)) & 0x01) ? (current_data_2>>4)&0x0f : current_data_2&0x0f;
517	517	for (l=0; l<6; l++)
518		*BITMAP_ADDR16(bitmap, current_scan_line/2 + j, (i*8+k)*6+l) = screen->machine->pens[current_colour];
	518	*BITMAP_ADDR16(bitmap, current_scan_line/2 + j, (i*8+k)*6+l) = current_colour;
519	519	}
520	520	}
521	521	}
r2200	r2201
537	537	{
538	538	current_colour = ((current_data_1>>(7-k)) & 0x01) ? (current_data_2>>4)&0x0f : current_data_2&0x0f;
539	539	for (l=0; l<3; l++)
540		*BITMAP_ADDR16(bitmap, current_scan_line/2 + j, (i*8+k)*3+l) = screen->machine->pens[current_colour];
	540	*BITMAP_ADDR16(bitmap, current_scan_line/2 + j, (i*8+k)*3+l) = current_colour;
541	541	}
542	542	}
543	543	}
r2200	r2201
553	553	{
554	554	current_colour = ((current_data_1>>(7-k)) & 0x01) ? (current_data_2>>4)&0x0f : current_data_2&0x0f;
555	555	for (l=0; l<3; l++)
556		*BITMAP_ADDR16(bitmap, current_scan_line/2 + j, (i*8+k)*3+l) = screen->machine->pens[current_colour];
	556	*BITMAP_ADDR16(bitmap, current_scan_line/2 + j, (i*8+k)*3+l) = current_colour;
557	557	}
558	558	}
559	559	}
r2200	r2201
575	575	{
576	576	current_colour = ((current_data_1>>(7-k)) & 0x01) ? (current_data_2>>4)&0x0f : current_data_2&0x0f;
577	577	for (l=0; l<2; l++)
578		*BITMAP_ADDR16(bitmap, current_scan_line/2 + j, (i*8+k)*2+l) = screen->machine->pens[current_colour];
	578	*BITMAP_ADDR16(bitmap, current_scan_line/2 + j, (i*8+k)*2+l) = current_colour;
579	579	}
580	580	}
581	581	}
r2200	r2201
591	591	{
592	592	current_colour = ((current_data_1>>(7-k)) & 0x01) ? (current_data_2>>4)&0x0f : current_data_2&0x0f;
593	593	for (l=0; l<2; l++)
594		*BITMAP_ADDR16(bitmap, current_scan_line/2 + j, (i*8+k)*2+l) = screen->machine->pens[current_colour];
	594	*BITMAP_ADDR16(bitmap, current_scan_line/2 + j, (i*8+k)*2+l) = current_colour;
595	595	}
596	596	}
597	597	}
r2200	r2201
618	618	{
619	619	current_colour = ((char_rom[current_data_1*16+j]>>k) & 0x01) ? (current_data_2>>4)&0x0f : current_data_2&0x0f;
620	620	for (l=0; l<12; l++)
621		*BITMAP_ADDR16(bitmap, current_scan_line/2 + j, (i*8+k)*12+l) = screen->machine->pens[current_colour];
	621	*BITMAP_ADDR16(bitmap, current_scan_line/2 + j, (i*8+k)*12+l) = current_colour;
622	622	}
623	623	}
624	624	}
r2200	r2201
635	635	{
636	636	current_colour = ((char_rom[current_data_1*16+j]>>k) & 0x01) ? (current_data_2>>4)&0x0f : current_data_2&0x0f;
637	637	for (l=0; l<12; l++)
638		*BITMAP_ADDR16(bitmap, current_scan_line/2 + j, (i*8+k)*12+l) = screen->machine->pens[current_colour];
	638	*BITMAP_ADDR16(bitmap, current_scan_line/2 + j, (i*8+k)*12+l) = current_colour;
639	639	}
640	640	}
641	641	}
r2200	r2201
657	657	{
658	658	current_colour = ((char_rom[current_data_1*16+j]>>k) & 0x01) ? (current_data_2>>4)&0x0f : current_data_2&0x0f;
659	659	for (l=0; l<6; l++)
660		*BITMAP_ADDR16(bitmap, current_scan_line/2 + j, (i*8+k)*6+l) = screen->machine->pens[current_colour];
	660	*BITMAP_ADDR16(bitmap, current_scan_line/2 + j, (i*8+k)*6+l) = current_colour;
661	661	}
662	662	}
663	663	}
r2200	r2201
674	674	{
675	675	current_colour = ((char_rom[current_data_1*16+j]>>k) & 0x01) ? (current_data_2>>4)&0x0f : current_data_2&0x0f;
676	676	for (l=0; l<6; l++)
677		*BITMAP_ADDR16(bitmap, current_scan_line/2 + j, (i*8+k)*6+l) = screen->machine->pens[current_colour];
	677	*BITMAP_ADDR16(bitmap, current_scan_line/2 + j, (i*8+k)*6+l) = current_colour;
678	678	}
679	679	}
680	680	}
r2200	r2201
696	696	{
697	697	current_colour = ((char_rom[current_data_1*16+j]>>k) & 0x01) ? (current_data_2>>4)&0x0f : current_data_2&0x0f;
698	698	for (l=0; l<3; l++)
699		*BITMAP_ADDR16(bitmap, current_scan_line/2 + j, (i*8+k)*3+l) = screen->machine->pens[current_colour];
	699	*BITMAP_ADDR16(bitmap, current_scan_line/2 + j, (i*8+k)*3+l) = current_colour;
700	700	}
701	701	}
702	702	}
r2200	r2201
712	712	{
713	713	current_colour = ((char_rom[current_data_1*16+j]>>k) & 0x01) ? (current_data_2>>4)&0x0f : current_data_2&0x0f;
714	714	for (l=0; l<3; l++)
715		*BITMAP_ADDR16(bitmap, current_scan_line/2 + j, (i*8+k)*3+l) = screen->machine->pens[current_colour];
	715	*BITMAP_ADDR16(bitmap, current_scan_line/2 + j, (i*8+k)*3+l) = current_colour;
716	716	}
717	717	}
718	718	}
r2200	r2201
733	733	{
734	734	current_colour = ((char_rom[current_data_1*16+j]>>k) & 0x01) ? (current_data_2>>4)&0x0f : current_data_2&0x0f;
735	735	for (l=0; l<2; l++)
736		*BITMAP_ADDR16(bitmap, current_scan_line/2 + j, (i*8+k)*2+l) = screen->machine->pens[current_colour];
	736	*BITMAP_ADDR16(bitmap, current_scan_line/2 + j, (i*8+k)*2+l) = current_colour;
737	737	}
738	738	}
739	739	}
r2200	r2201
749	749	{
750	750	current_colour = ((char_rom[current_data_1*16+j]>>k) & 0x01) ? (current_data_2>>4)&0x0f : current_data_2&0x0f;
751	751	for (l=0; l<2; l++)
752		*BITMAP_ADDR16(bitmap, current_scan_line/2 + j, (i*8+k)*2+l) = screen->machine->pens[current_colour];
	752	*BITMAP_ADDR16(bitmap, current_scan_line/2 + j, (i*8+k)*2+l) = current_colour;
753	753	}
754	754	}
755	755	}

src/mess/video/nc.c

r2200	r2201
70	70
71	71	if (nc200_backlight)
72	72	{
73		pens[0] = screen->machine->pens[2];
74		pens[1] = screen->machine->pens[3];
	73	pens[0] = 2;
	74	pens[1] = 3;
75	75	}
76	76	else
77	77	{
78		pens[0] = screen->machine->pens[0];
79		pens[1] = screen->machine->pens[1];
	78	pens[0] = 0;
	79	pens[1] = 1;
80	80	}
81	81	}
82	82	else
83	83	{
84	84	height = NC_SCREEN_HEIGHT;
85	85	width = NC_SCREEN_WIDTH;
86		pens[0] = screen->machine->pens[2];
87		pens[1] = screen->machine->pens[3];
	86	pens[0] = 2;
	87	pens[1] = 3;
88	88	}
89	89
90	90

src/mess/video/nes.c

r2200	r2201
132	132	if ((readinputport(PORT_CONFIG1) & 0x00f0) == 0x0030)
133	133	sights |= 0x0002;
134	134	if (sights & 0x0001)
135		draw_sight(bitmap, screen->machine->pens[0x30], readinputport(PORT_ZAPPER0_X), readinputport(PORT_ZAPPER0_Y));
	135	draw_sight(bitmap, 0x30, readinputport(PORT_ZAPPER0_X), readinputport(PORT_ZAPPER0_Y));
136	136	if (sights & 0x0002)
137		draw_sight(bitmap, screen->machine->pens[0x00], readinputport(PORT_ZAPPER1_X), readinputport(PORT_ZAPPER1_Y));
	137	draw_sight(bitmap, 0x00, readinputport(PORT_ZAPPER1_X), readinputport(PORT_ZAPPER1_Y));
138	138
139	139	/* if this is a disk system game, check for the flip-disk key */
140	140	if (nes.mapper == 20)

src/mess/video/gb.c

r2200	r2201
241	241	}
242	242	}
243	243
244		INLINE void gb_update_sprites ( running_machine *machine )
	244	INLINE void gb_update_sprites ( void )
245	245	{
246	246	bitmap_t *bitmap = tmpbitmap;
247	247	UINT8 height, tilemask, line, *oam, *vram;
r2200	r2201
291	291	{
292	292	register int colour = ((data & 0x0100) ? 2 : 0) | ((data & 0x0001) ? 1 : 0);
293	293	if (colour && !bg_zbuf[xindex] && xindex >= 0 && xindex < 160)
294		gb_plot_pixel(bitmap, xindex, yindex, machine->pens[spal[colour]]);
	294	gb_plot_pixel(bitmap, xindex, yindex, spal[colour]);
295	295	data >>= 1;
296	296	}
297	297	break;
r2200	r2201
300	300	{
301	301	register int colour = ((data & 0x0100) ? 2 : 0) | ((data & 0x0001) ? 1 : 0);
302	302	if (colour && xindex >= 0 && xindex < 160)
303		gb_plot_pixel(bitmap, xindex, yindex, machine->pens[spal[colour]]);
	303	gb_plot_pixel(bitmap, xindex, yindex, spal[colour]);
304	304	data >>= 1;
305	305	}
306	306	break;
r2200	r2201
309	309	{
310	310	register int colour = ((data & 0x8000) ? 2 : 0) | ((data & 0x0080) ? 1 : 0);
311	311	if (colour && !bg_zbuf[xindex] && xindex >= 0 && xindex < 160)
312		gb_plot_pixel(bitmap, xindex, yindex, machine->pens[spal[colour]]);
	312	gb_plot_pixel(bitmap, xindex, yindex, spal[colour]);
313	313	data <<= 1;
314	314	}
315	315	break;
r2200	r2201
318	318	{
319	319	register int colour = ((data & 0x8000) ? 2 : 0) | ((data & 0x0080) ? 1 : 0);
320	320	if (colour && xindex >= 0 && xindex < 160)
321		gb_plot_pixel(bitmap, xindex, yindex, machine->pens[spal[colour]]);
	321	gb_plot_pixel(bitmap, xindex, yindex, spal[colour]);
322	322	data <<= 1;
323	323	}
324	324	break;
r2200	r2201
385	385	r.min_y = r.max_y = gb_lcd.current_line;
386	386	r.min_x = gb_lcd.start_x;
387	387	r.max_x = gb_lcd.end_x - 1;
388		fillbitmap( bitmap, machine->pens[ gb_bpal[0] ], &r );
	388	fillbitmap( bitmap, gb_bpal[0], &r );
389	389	}
390	390	while ( l < 2 ) {
391	391	UINT8   xindex, *map, *tiles;
r2200	r2201
413	413	while ( i > 0 ) {
414	414	while ( ( gb_lcd.layer[l].xshift < 8 ) && i ) {
415	415	register int colour = ( ( data & 0x8000 ) ? 2 : 0 ) | ( ( data & 0x0080 ) ? 1 : 0 );
416		gb_plot_pixel( bitmap, xindex, gb_lcd.current_line, machine->pens[ gb_bpal[ colour ] ] );
	416	gb_plot_pixel( bitmap, xindex, gb_lcd.current_line, gb_bpal[ colour ] );
417	417	bg_zbuf[ xindex ] = colour;
418	418	xindex++;
419	419	data <<= 1;
r2200	r2201
437	437	l++;
438	438	}
439	439	if ( gb_lcd.end_x == 160 && LCDCONT & 0x02 ) {
440		gb_update_sprites( machine );
	440	gb_update_sprites();
441	441	}
442	442	gb_lcd.start_x = gb_lcd.end_x;
443	443	}
r2200	r2201
449	449	const device_config *screen = video_screen_first(machine->config);
450	450	rectangle r = *video_screen_get_visible_area(screen);
451	451	r.min_y = r.max_y = gb_lcd.current_line;
452		fillbitmap( bitmap, screen->machine->pens[0], &r );
	452	fillbitmap( bitmap, 0, &r );
453	453	}
454	454	gb_lcd.previous_line = gb_lcd.current_line;
455	455	}
r2200	r2201
682	682	r.max_x -= SGB_XOFFSET;
683	683	r.min_y = SGB_YOFFSET;
684	684	r.max_y -= SGB_YOFFSET;
685		fillbitmap( bitmap, machine->pens[0], &r );
	685	fillbitmap( bitmap, 0, &r );
686	686	} return;
687	687	case 3: /* Blank screen (white - or should it be color 0?) */
688	688	{
r2200	r2201
692	692	r.max_x -= SGB_XOFFSET;
693	693	r.min_y = SGB_YOFFSET;
694	694	r.max_y -= SGB_YOFFSET;
695		fillbitmap( bitmap, machine->pens[32767], &r );
	695	fillbitmap( bitmap, 32767, &r );
696	696	} return;
697	697	}
698	698
r2200	r2201
711	711	r.min_x = SGB_XOFFSET;
712	712	r.max_x -= SGB_XOFFSET;
713	713	r.min_y = r.max_y = gb_lcd.current_line + SGB_YOFFSET;
714		fillbitmap( bitmap, machine->pens[0], &r );
	714	fillbitmap( bitmap, 0, &r );
715	715	}
716	716	while( l < 2 ) {
717	717	UINT8   xindex, sgb_palette, *map, *tiles;
r2200	r2201
782	782	r.min_x = SGB_XOFFSET;
783	783	r.max_x -= SGB_XOFFSET;
784	784	r.min_y = r.max_y = gb_lcd.current_line + SGB_YOFFSET;
785		fillbitmap(bitmap, machine->pens[0], &r);
	785	fillbitmap(bitmap, 0, &r);
786	786	}
787	787	gb_lcd.previous_line = gb_lcd.current_line;
788	788	}
r2200	r2201
848	848	{
849	849	register int colour = ((data & 0x0100) ? 2 : 0) | ((data & 0x0001) ? 1 : 0);
850	850	if (colour && !bg_zbuf[xindex] && xindex >= 0 && xindex < 160)
851		gb_plot_pixel(bitmap, xindex, yindex, machine->pens[cgb_spal[pal + colour]]);
	851	gb_plot_pixel(bitmap, xindex, yindex, cgb_spal[pal + colour]);
852	852	data >>= 1;
853	853	}
854	854	break;
r2200	r2201
859	859	if((bg_zbuf[xindex] & 0x80) && (bg_zbuf[xindex] & 0x7f) && (LCDCONT & 0x1))
860	860	colour = 0;
861	861	if (colour && xindex >= 0 && xindex < 160)
862		gb_plot_pixel(bitmap, xindex, yindex, machine->pens[cgb_spal[pal + colour]]);
	862	gb_plot_pixel(bitmap, xindex, yindex, cgb_spal[pal + colour]);
863	863	data >>= 1;
864	864	}
865	865	break;
r2200	r2201
868	868	{
869	869	register int colour = ((data & 0x8000) ? 2 : 0) | ((data & 0x0080) ? 1 : 0);
870	870	if (colour && !bg_zbuf[xindex] && xindex >= 0 && xindex < 160)
871		gb_plot_pixel(bitmap, xindex, yindex, machine->pens[cgb_spal[pal + colour]]);
	871	gb_plot_pixel(bitmap, xindex, yindex, cgb_spal[pal + colour]);
872	872	data <<= 1;
873	873	}
874	874	break;
r2200	r2201
879	879	if((bg_zbuf[xindex] & 0x80) && (bg_zbuf[xindex] & 0x7f) && (LCDCONT & 0x1))
880	880	colour = 0;
881	881	if (colour && xindex >= 0 && xindex < 160)
882		gb_plot_pixel(bitmap, xindex, yindex, machine->pens[cgb_spal[pal + colour]]);
	882	gb_plot_pixel(bitmap, xindex, yindex, cgb_spal[pal + colour]);
883	883	data <<= 1;
884	884	}
885	885	break;
r2200	r2201
947	947	r.min_y = r.max_y = gb_lcd.current_line;
948	948	r.min_x = gb_lcd.start_x;
949	949	r.max_x = gb_lcd.end_x - 1;
950		fillbitmap( bitmap, machine->pens[ ( gbc_mode == GBC_MODE_MONO ) ? 0 : 32767 ], &r );
	950	fillbitmap( bitmap, ( gbc_mode == GBC_MODE_MONO ) ? 0 : 32767, &r );
951	951	}
952	952	while ( l < 2 ) {
953	953	UINT8   xindex, *map, *tiles, *gbcmap;
r2200	r2201
996	996	colour = ( ( data & 0x8000 ) ? 2 : 0 ) | ( ( data & 0x0080 ) ? 1 : 0 );
997	997	data <<= 1;
998	998	}
999		gb_plot_pixel( bitmap, xindex, gb_lcd.current_line, machine->pens[ cgb_bpal[ ( ( gbcmap[ gb_lcd.layer[l].xindex ] & 0x07 ) * 4 ) + colour ] ] );
	999	gb_plot_pixel( bitmap, xindex, gb_lcd.current_line, cgb_bpal[ ( ( gbcmap[ gb_lcd.layer[l].xindex ] & 0x07 ) * 4 ) + colour ] );
1000	1000	bg_zbuf[ xindex ] = colour + ( gbcmap[ gb_lcd.layer[l].xindex ] & 0x80 );
1001	1001	xindex++;
1002	1002	gb_lcd.layer[l].xshift++;
r2200	r2201
1039	1039	const device_config *screen = video_screen_first(machine->config);
1040	1040	rectangle r = *video_screen_get_visible_area(screen);
1041	1041	r.min_y = r.max_y = gb_lcd.current_line;
1042		fillbitmap( bitmap, machine->pens[ ( gbc_mode == GBC_MODE_MONO ) ? 0 : 32767 ], &r );
	1042	fillbitmap( bitmap, ( gbc_mode == GBC_MODE_MONO ) ? 0 : 32767, &r );
1043	1043	}
1044	1044	gb_lcd.previous_line = gb_lcd.current_line;
1045	1045	}

src/mess/video/pcw16.c

r2200	r2201
65	65	}
66	66
67	67	/* 640, 1 bit per pixel */
68		static void pcw16_vh_decode_mode0(running_machine *machine, bitmap_t *bitmap, int x, int y, unsigned char byte)
	68	static void pcw16_vh_decode_mode0(bitmap_t *bitmap, int x, int y, unsigned char byte)
69	69	{
70	70	int b;
71	71	int local_byte;
r2200	r2201
74	74
75	75	local_byte = byte;
76	76
77		cols[0] = machine->pens[pcw16_colour_palette[0]];
78		cols[1] = machine->pens[pcw16_colour_palette[1]];
	77	cols[0] = pcw16_colour_palette[0];
	78	cols[1] = pcw16_colour_palette[1];
79	79
80	80	px = x;
81	81	for (b=0; b<8; b++)
r2200	r2201
88	88	}
89	89
90	90	/* 320, 2 bits per pixel */
91		static void pcw16_vh_decode_mode1(running_machine *machine, bitmap_t *bitmap, int x, int y, unsigned char byte)
	91	static void pcw16_vh_decode_mode1(bitmap_t *bitmap, int x, int y, unsigned char byte)
92	92	{
93	93	int b;
94	94	int px;
r2200	r2201
97	97
98	98	for (b=0; b<3; b++)
99	99	{
100		cols[b] = machine->pens[pcw16_colour_palette[b]];
	100	cols[b] = pcw16_colour_palette[b];
101	101	}
102	102
103	103	local_byte = byte;
r2200	r2201
119	119	}
120	120
121	121	/* 160, 4 bits per pixel */
122		static void pcw16_vh_decode_mode2(running_machine *machine, bitmap_t *bitmap, int x, int y, unsigned char byte)
	122	static void pcw16_vh_decode_mode2(bitmap_t *bitmap, int x, int y, unsigned char byte)
123	123	{
124	124	int px;
125	125	int b;
126	126	int local_byte;
127	127	int cols[2];
128	128
129		cols[0] = machine->pens[pcw16_colour_palette[0]];
130		cols[1] = machine->pens[pcw16_colour_palette[1]];
	129	cols[0] = pcw16_colour_palette[0];
	130	cols[1] = pcw16_colour_palette[1];
131	131	local_byte = byte;
132	132
133	133	px = x;
r2200	r2201
176	176	border_colour = pcw16_colour_palette[1];
177	177	}
178	178
179		border_colour = screen->machine->pens[border_colour];
180
181	179	if ((pcw16_video_control & (1<<6))==0)
182	180	{
183	181	/* blank */
r2200	r2201
248	246	{
249	247	case 0:
250	248	{
251		pcw16_vh_decode_mode0(screen->machine, bitmap,x,y+PCW16_BORDER_HEIGHT,byte);
	249	pcw16_vh_decode_mode0(bitmap,x,y+PCW16_BORDER_HEIGHT,byte);
252	250	}
253	251	break;
254	252
255	253	case 1:
256	254	{
257		pcw16_vh_decode_mode1(screen->machine, bitmap, x,y+PCW16_BORDER_HEIGHT, byte);
	255	pcw16_vh_decode_mode1(bitmap, x,y+PCW16_BORDER_HEIGHT, byte);
258	256	}
259	257	break;
260	258
261	259	case 3:
262	260	case 2:
263	261	{
264		pcw16_vh_decode_mode2(screen->machine, bitmap, x, y+PCW16_BORDER_HEIGHT, byte);
	262	pcw16_vh_decode_mode2(bitmap, x, y+PCW16_BORDER_HEIGHT, byte);
265	263	}
266	264	break;
267	265	}

src/mess/video/gamecom.c

r2200	r2201
22	22	rec.min_x = 0;
23	23	rec.max_x = Y_PIXELS - 1;
24	24	rec.min_y = rec.max_y = scanline;
25		fillbitmap( tmpbitmap, machine->pens[ 0 ], &rec );
	25	fillbitmap( tmpbitmap, 0, &rec );
26	26	return;
27	27	} else {
28	28	UINT8 *line = &gamecom_vram[ base_address + 40 * scanline ];
r2200	r2201
57	57	}
58	58	for( i = 0; i < 40; i++ ) {
59	59	UINT8 p = line[i];
60		*BITMAP_ADDR16(tmpbitmap, i * 4 + 0, scanline) = machine->pens[ pal[ ( p >> 6 ) & 3 ] ];
61		*BITMAP_ADDR16(tmpbitmap, i * 4 + 1, scanline) = machine->pens[ pal[ ( p >> 4 ) & 3 ] ];
62		*BITMAP_ADDR16(tmpbitmap, i * 4 + 2, scanline) = machine->pens[ pal[ ( p >> 2 ) & 3 ] ];
63		*BITMAP_ADDR16(tmpbitmap, i * 4 + 3, scanline) = machine->pens[ pal[ ( p      ) & 3 ] ];
	60	*BITMAP_ADDR16(tmpbitmap, i * 4 + 0, scanline) = pal[ ( p >> 6 ) & 3 ];
	61	*BITMAP_ADDR16(tmpbitmap, i * 4 + 1, scanline) = pal[ ( p >> 4 ) & 3 ];
	62	*BITMAP_ADDR16(tmpbitmap, i * 4 + 2, scanline) = pal[ ( p >> 2 ) & 3 ];
	63	*BITMAP_ADDR16(tmpbitmap, i * 4 + 3, scanline) = pal[ ( p      ) & 3 ];
64	64	}
65	65	}
66	66

src/mess/video/epnick.c

r2200	r2201
30	30
31	31	// MESS specific
32	32	/* 8-bit pixel write! */
33		static void nick_write_pixel(running_machine *machine, NICK_STATE *nick, int ci)
	33	static void nick_write_pixel(NICK_STATE *nick, int ci)
34	34	{
35	35	if (nick->dest_pos < nick->dest_max_pos)
36	36	{
37		nick->dest[nick->dest_pos++] = machine->pens[ci];
	37	nick->dest[nick->dest_pos++] = ci;
38	38	}
39	39	}
40	40
r2200	r2201
119	119	}
120	120
121	121	/* write border colour */
122		static void   Nick_WriteBorder(running_machine *machine, int Clocks)
	122	static void   Nick_WriteBorder(int Clocks)
123	123	{
124	124	int i;
125	125	int ColIndex = Nick.BORDER;
126	126
127	127	for (i=0; i<(Clocks<<4); i++)
128	128	{
129		nick_write_pixel(machine, &Nick, ColIndex);
	129	nick_write_pixel(&Nick, ColIndex);
130	130	}
131	131	}
132	132
133	133
134		static void Nick_DoLeftMargin(running_machine *machine, LPT_ENTRY *pLPT)
	134	static void Nick_DoLeftMargin(LPT_ENTRY *pLPT)
135	135	{
136	136	unsigned char LeftMargin;
137	137
r2200	r2201
145	145	LeftMarginVisible = LeftMargin-Nick_FirstVisibleClock;
146	146
147	147	/* render the border */
148		Nick_WriteBorder(machine, LeftMarginVisible);
	148	Nick_WriteBorder(LeftMarginVisible);
149	149	}
150	150	}
151	151
152		static void Nick_DoRightMargin(running_machine *machine, LPT_ENTRY *pLPT)
	152	static void Nick_DoRightMargin(LPT_ENTRY *pLPT)
153	153	{
154	154	unsigned char RightMargin;
155	155
r2200	r2201
163	163	RightMarginVisible = Nick_LastVisibleClock - RightMargin;
164	164
165	165	/* render the border */
166		Nick_WriteBorder(machine, RightMarginVisible);
	166	Nick_WriteBorder(RightMarginVisible);
167	167	}
168	168	}
169	169
r2200	r2201
179	179	}
180	180	}
181	181
182		static void Nick_WritePixels2Colour(running_machine *machine, unsigned char Pen0, unsigned char Pen1, unsigned char DataByte)
	182	static void Nick_WritePixels2Colour(unsigned char Pen0, unsigned char Pen1, unsigned char DataByte)
183	183	{
184	184	int i;
185	185	int ColIndex[2];
r2200	r2201
195	195	{
196	196	PenIndex = ColIndex[(Data>>7) & 0x01];
197	197
198		nick_write_pixel(machine, &Nick, PenIndex);
	198	nick_write_pixel(&Nick, PenIndex);
199	199
200	200	Data = Data<<1;
201	201	}
202	202	}
203	203
204		static void Nick_WritePixels2ColourLPIXEL(running_machine *machine, unsigned char Pen0, unsigned char Pen1, unsigned char DataByte)
	204	static void Nick_WritePixels2ColourLPIXEL(unsigned char Pen0, unsigned char Pen1, unsigned char DataByte)
205	205	{
206	206	int i;
207	207	int ColIndex[2];
r2200	r2201
217	217	{
218	218	PenIndex = ColIndex[(Data>>7) & 0x01];
219	219
220		nick_write_pixel(machine, &Nick, PenIndex);
221		nick_write_pixel(machine, &Nick, PenIndex);
	220	nick_write_pixel(&Nick, PenIndex);
	221	nick_write_pixel(&Nick, PenIndex);
222	222
223	223	Data = Data<<1;
224	224	}
225	225	}
226	226
227	227
228		static void Nick_WritePixels(running_machine *machine, unsigned char DataByte, unsigned char CharIndex)
	228	static void Nick_WritePixels(unsigned char DataByte, unsigned char CharIndex)
229	229	{
230	230	int i;
231	231
r2200	r2201
283	283
284	284
285	285
286		Nick_WritePixels2Colour(machine, PenOffset,
	286	Nick_WritePixels2Colour(PenOffset,
287	287	(PenOffset|0x01), Data);
288	288	}
289	289	break;
r2200	r2201
309	309	PenIndex = Nick_PenIndexLookup_4Colour[Data];
310	310	PalIndex = Nick.LPT.COL[PenIndex & 0x03];
311	311
312		nick_write_pixel(machine, &Nick, PalIndex);
313		nick_write_pixel(machine, &Nick, PalIndex);
	312	nick_write_pixel(&Nick, PalIndex);
	313	nick_write_pixel(&Nick, PalIndex);
314	314
315	315	Data = Data<<1;
316	316	}
r2200	r2201
339	339
340	340	PalIndex = Nick_GetColourIndex(PenIndex);
341	341
342		nick_write_pixel(machine, &Nick, PalIndex);
343		nick_write_pixel(machine, &Nick, PalIndex);
344		nick_write_pixel(machine, &Nick, PalIndex);
345		nick_write_pixel(machine, &Nick, PalIndex);
	342	nick_write_pixel(&Nick, PalIndex);
	343	nick_write_pixel(&Nick, PalIndex);
	344	nick_write_pixel(&Nick, PalIndex);
	345	nick_write_pixel(&Nick, PalIndex);
346	346
347	347	Data = Data<<1;
348	348	}
r2200	r2201
365	365
366	366	PalIndex = Data;
367	367
368		nick_write_pixel(machine, &Nick, PalIndex);
369		nick_write_pixel(machine, &Nick, PalIndex);
370		nick_write_pixel(machine, &Nick, PalIndex);
371		nick_write_pixel(machine, &Nick, PalIndex);
372		nick_write_pixel(machine, &Nick, PalIndex);
373		nick_write_pixel(machine, &Nick, PalIndex);
374		nick_write_pixel(machine, &Nick, PalIndex);
375		nick_write_pixel(machine, &Nick, PalIndex);
	368	nick_write_pixel(&Nick, PalIndex);
	369	nick_write_pixel(&Nick, PalIndex);
	370	nick_write_pixel(&Nick, PalIndex);
	371	nick_write_pixel(&Nick, PalIndex);
	372	nick_write_pixel(&Nick, PalIndex);
	373	nick_write_pixel(&Nick, PalIndex);
	374	nick_write_pixel(&Nick, PalIndex);
	375	nick_write_pixel(&Nick, PalIndex);
376	376
377	377
378	378	}
r2200	r2201
380	380	}
381	381	}
382	382
383		static void Nick_WritePixelsLPIXEL(running_machine *machine, unsigned char DataByte, unsigned char CharIndex)
	383	static void Nick_WritePixelsLPIXEL(unsigned char DataByte, unsigned char CharIndex)
384	384	{
385	385	int i;
386	386
r2200	r2201
438	438
439	439
440	440
441		Nick_WritePixels2ColourLPIXEL(machine, PenOffset,(PenOffset|0x01), Data);
	441	Nick_WritePixels2ColourLPIXEL(PenOffset,(PenOffset|0x01), Data);
442	442	}
443	443	break;
444	444
r2200	r2201
463	463	PenIndex = Nick_PenIndexLookup_4Colour[Data];
464	464	PalIndex = Nick.LPT.COL[PenIndex & 0x03];
465	465
466		nick_write_pixel(machine, &Nick, PalIndex);
467		nick_write_pixel(machine, &Nick, PalIndex);
468		nick_write_pixel(machine, &Nick, PalIndex);
469		nick_write_pixel(machine, &Nick, PalIndex);
	466	nick_write_pixel(&Nick, PalIndex);
	467	nick_write_pixel(&Nick, PalIndex);
	468	nick_write_pixel(&Nick, PalIndex);
	469	nick_write_pixel(&Nick, PalIndex);
470	470
471	471	Data = Data<<1;
472	472	}
r2200	r2201
495	495
496	496	PalIndex = Nick_GetColourIndex(PenIndex);
497	497
498		nick_write_pixel(machine, &Nick, PalIndex);
499		nick_write_pixel(machine, &Nick, PalIndex);
500		nick_write_pixel(machine, &Nick, PalIndex);
501		nick_write_pixel(machine, &Nick, PalIndex);
502		nick_write_pixel(machine, &Nick, PalIndex);
503		nick_write_pixel(machine, &Nick, PalIndex);
504		nick_write_pixel(machine, &Nick, PalIndex);
505		nick_write_pixel(machine, &Nick, PalIndex);
	498	nick_write_pixel(&Nick, PalIndex);
	499	nick_write_pixel(&Nick, PalIndex);
	500	nick_write_pixel(&Nick, PalIndex);
	501	nick_write_pixel(&Nick, PalIndex);
	502	nick_write_pixel(&Nick, PalIndex);
	503	nick_write_pixel(&Nick, PalIndex);
	504	nick_write_pixel(&Nick, PalIndex);
	505	nick_write_pixel(&Nick, PalIndex);
506	506
507	507	Data = Data<<1;
508	508	}
r2200	r2201
525	525
526	526	PalIndex = Data;
527	527
528		nick_write_pixel(machine, &Nick, PalIndex);
529		nick_write_pixel(machine, &Nick, PalIndex);
530		nick_write_pixel(machine, &Nick, PalIndex);
531		nick_write_pixel(machine, &Nick, PalIndex);
532		nick_write_pixel(machine, &Nick, PalIndex);
533		nick_write_pixel(machine, &Nick, PalIndex);
534		nick_write_pixel(machine, &Nick, PalIndex);
535		nick_write_pixel(machine, &Nick, PalIndex);
	528	nick_write_pixel(&Nick, PalIndex);
	529	nick_write_pixel(&Nick, PalIndex);
	530	nick_write_pixel(&Nick, PalIndex);
	531	nick_write_pixel(&Nick, PalIndex);
	532	nick_write_pixel(&Nick, PalIndex);
	533	nick_write_pixel(&Nick, PalIndex);
	534	nick_write_pixel(&Nick, PalIndex);
	535	nick_write_pixel(&Nick, PalIndex);
536	536
537		nick_write_pixel(machine, &Nick, PalIndex);
538		nick_write_pixel(machine, &Nick, PalIndex);
539		nick_write_pixel(machine, &Nick, PalIndex);
540		nick_write_pixel(machine, &Nick, PalIndex);
541		nick_write_pixel(machine, &Nick, PalIndex);
542		nick_write_pixel(machine, &Nick, PalIndex);
543		nick_write_pixel(machine, &Nick, PalIndex);
544		nick_write_pixel(machine, &Nick, PalIndex);
	537	nick_write_pixel(&Nick, PalIndex);
	538	nick_write_pixel(&Nick, PalIndex);
	539	nick_write_pixel(&Nick, PalIndex);
	540	nick_write_pixel(&Nick, PalIndex);
	541	nick_write_pixel(&Nick, PalIndex);
	542	nick_write_pixel(&Nick, PalIndex);
	543	nick_write_pixel(&Nick, PalIndex);
	544	nick_write_pixel(&Nick, PalIndex);
545	545
546	546
547	547	}
r2200	r2201
550	550	}
551	551
552	552
553		static void Nick_DoPixel(running_machine *machine, int ClocksVisible)
	553	static void Nick_DoPixel(int ClocksVisible)
554	554	{
555	555	int i;
556	556	unsigned char Buf1, Buf2;
r2200	r2201
563	563	Buf2 = Nick_FetchByte(Nick.LD1);
564	564	Nick.LD1++;
565	565
566		Nick_WritePixels(machine, Buf1,Buf1);
	566	Nick_WritePixels(Buf1,Buf1);
567	567
568		Nick_WritePixels(machine, Buf2,Buf1);
	568	Nick_WritePixels(Buf2,Buf1);
569	569	}
570	570	}
571	571
572	572
573		static void Nick_DoLPixel(running_machine *machine, int ClocksVisible)
	573	static void Nick_DoLPixel(int ClocksVisible)
574	574	{
575	575	int i;
576	576	unsigned char Buf1;
r2200	r2201
580	580	Buf1 =  Nick_FetchByte(Nick.LD1);
581	581	Nick.LD1++;
582	582
583		Nick_WritePixelsLPIXEL(machine, Buf1,Buf1);
	583	Nick_WritePixelsLPIXEL(Buf1,Buf1);
584	584	}
585	585	}
586	586
587		static void Nick_DoAttr(running_machine *machine, int ClocksVisible)
	587	static void Nick_DoAttr(int ClocksVisible)
588	588	{
589	589	int i;
590	590	unsigned char Buf1, Buf2;
r2200	r2201
601	601	unsigned char BackgroundColour = ((Buf1>>4) & 0x0f);
602	602	unsigned char ForegroundColour = (Buf1 & 0x0f);
603	603
604		Nick_WritePixels2ColourLPIXEL(machine, BackgroundColour, ForegroundColour, Buf2);
	604	Nick_WritePixels2ColourLPIXEL(BackgroundColour, ForegroundColour, Buf2);
605	605	}
606	606	}
607	607	}
608	608
609		static void Nick_DoCh256(running_machine *machine, int ClocksVisible)
	609	static void Nick_DoCh256(int ClocksVisible)
610	610	{
611	611	int i;
612	612	unsigned char Buf1, Buf2;
r2200	r2201
617	617	Nick.LD1++;
618	618	Buf2 = Nick_FetchByte(ADDR_CH256(Nick.LD2, Buf1));
619	619
620		Nick_WritePixelsLPIXEL(machine, Buf2,Buf1);
	620	Nick_WritePixelsLPIXEL(Buf2,Buf1);
621	621	}
622	622	}
623	623
624		static void Nick_DoCh128(running_machine *machine, int ClocksVisible)
	624	static void Nick_DoCh128(int ClocksVisible)
625	625	{
626	626	int i;
627	627	unsigned char Buf1, Buf2;
r2200	r2201
632	632	Nick.LD1++;
633	633	Buf2 = Nick_FetchByte(ADDR_CH128(Nick.LD2, Buf1));
634	634
635		Nick_WritePixelsLPIXEL(machine, Buf2,Buf1);
	635	Nick_WritePixelsLPIXEL(Buf2,Buf1);
636	636	}
637	637	}
638	638
639		static void Nick_DoCh64(running_machine *machine, int ClocksVisible)
	639	static void Nick_DoCh64(int ClocksVisible)
640	640	{
641	641	int i;
642	642	unsigned char Buf1, Buf2;
r2200	r2201
647	647	Nick.LD1++;
648	648	Buf2 = Nick_FetchByte(ADDR_CH64(Nick.LD2, Buf1));
649	649
650		Nick_WritePixelsLPIXEL(machine, Buf2,Buf1);
	650	Nick_WritePixelsLPIXEL(Buf2,Buf1);
651	651	}
652	652	}
653	653
654	654
655		static void Nick_DoDisplay(running_machine *machine, LPT_ENTRY *pLPT)
	655	static void Nick_DoDisplay(LPT_ENTRY *pLPT)
656	656	{
657	657	unsigned char ClocksVisible;
658	658	unsigned char RightMargin, LeftMargin;
r2200	r2201
718	718	{
719	719	case NICK_PIXEL_MODE:
720	720	{
721		Nick_DoPixel(machine, ClocksVisible);
	721	Nick_DoPixel(ClocksVisible);
722	722	}
723	723	break;
724	724
725	725	case NICK_ATTR_MODE:
726	726	{
727	727	//mame_printf_info("attr mode\r\n");
728		Nick_DoAttr(machine, ClocksVisible);
	728	Nick_DoAttr( ClocksVisible);
729	729	}
730	730	break;
731	731
732	732	case NICK_CH256_MODE:
733	733	{
734	734	//mame_printf_info("ch256 mode\r\n");
735		Nick_DoCh256(machine, ClocksVisible);
	735	Nick_DoCh256(ClocksVisible);
736	736	}
737	737	break;
738	738
739	739	case NICK_CH128_MODE:
740	740	{
741		Nick_DoCh128(machine, ClocksVisible);
	741	Nick_DoCh128(ClocksVisible);
742	742	}
743	743	break;
744	744
745	745	case NICK_CH64_MODE:
746	746	{
747	747	//mame_printf_info("ch64 mode\r\n");
748		Nick_DoCh64(machine, ClocksVisible);
	748	Nick_DoCh64(ClocksVisible);
749	749	}
750	750	break;
751	751
752	752	case NICK_LPIXEL_MODE:
753	753	{
754		Nick_DoLPixel(machine, ClocksVisible);
	754	Nick_DoLPixel(ClocksVisible);
755	755	}
756	756	break;
757	757
r2200	r2201
799	799	}
800	800
801	801	/* call here to render a line of graphics */
802		static void   Nick_DoLine(running_machine *machine)
	802	static void   Nick_DoLine(void)
803	803	{
804	804	unsigned char ScanLineCount;
805	805
r2200	r2201
814	814	}
815	815
816	816	/* left border */
817		Nick_DoLeftMargin(machine, &Nick.LPT);
	817	Nick_DoLeftMargin(&Nick.LPT);
818	818
819	819	/* do visible part */
820		Nick_DoDisplay(machine, &Nick.LPT);
	820	Nick_DoDisplay(&Nick.LPT);
821	821
822	822	/* right border */
823		Nick_DoRightMargin(machine, &Nick.LPT);
	823	Nick_DoRightMargin(&Nick.LPT);
824	824
825	825	// 0x0f7 is first!
826	826	/* scan line count for this LPT */
r2200	r2201
895	895	}
896	896	}
897	897
898		void    Nick_DoScreen(running_machine *machine, bitmap_t *bm)
	898	void    Nick_DoScreen(bitmap_t *bm)
899	899	{
900	900	int line = 0;
901	901
r2200	r2201
908	908	Nick.dest_max_pos = bm->width;
909	909
910	910	/* write line */
911		Nick_DoLine(machine);
	911	Nick_DoLine();
912	912
913	913	/* next line */
914	914	line++;

src/mess/video/epnick.h

r2200	r2201
127	127	extern PALETTE_INIT( nick );
128	128
129	129	int Nick_vh_start(void);
130		void Nick_DoScreen(running_machine *machine, bitmap_t *bm);
	130	void Nick_DoScreen(bitmap_t *bm);
131	131
132	132	int Nick_reg_r(int);
133	133	WRITE8_HANDLER ( Nick_reg_w );

src/mess/video/pmd85.c

r2200	r2201
31	31	{
32	32	}
33	33
34		static void pmd85_draw_scanline(running_machine *machine, bitmap_t *bitmap, int pmd85_scanline)
	34	static void pmd85_draw_scanline(bitmap_t *bitmap, int pmd85_scanline)
35	35	{
36	36	int x, i;
37	37	int pen0, pen1;
r2200	r2201
50	50	pen1 = data & 0x80 ? 1 : 2;
51	51
52	52	for (i=0; i<6; i++)
53		scanline[x+i] = machine->pens[(data & (0x01<<i)) ? pen1 : pen0];
	53	scanline[x+i] = (data & (0x01<<i)) ? pen1 : pen0;
54	54
55	55	}
56	56	}
r2200	r2201
60	60	int pmd85_scanline;
61	61
62	62	for (pmd85_scanline=0; pmd85_scanline<256; pmd85_scanline++)
63		pmd85_draw_scanline (screen->machine, bitmap, pmd85_scanline);
	63	pmd85_draw_scanline (bitmap, pmd85_scanline);
64	64	return 0;
65	65	}

src/mess/video/lviv.c

r2200	r2201
78	78	data = lviv_video_ram[y*64+x/4];
79	79
80	80	pen = lviv_colortable[0][((data & 0x08) >> 3) | ((data & 0x80) >> (3+3))];
81		*BITMAP_ADDR16(bitmap, y, x + 0) = screen->machine->pens[pen];
	81	*BITMAP_ADDR16(bitmap, y, x + 0) = pen;
82	82
83	83	pen = lviv_colortable[0][((data & 0x04) >> 2) | ((data & 0x40) >> (2+3))];
84		*BITMAP_ADDR16(bitmap, y, x + 1) = screen->machine->pens[pen];
	84	*BITMAP_ADDR16(bitmap, y, x + 1) = pen;
85	85
86	86	pen = lviv_colortable[0][((data & 0x02) >> 1) | ((data & 0x20) >> (1+3))];
87		*BITMAP_ADDR16(bitmap, y, x + 2) = screen->machine->pens[pen];
	87	*BITMAP_ADDR16(bitmap, y, x + 2) = pen;
88	88
89	89	pen = lviv_colortable[0][((data & 0x01) >> 0) | ((data & 0x10) >> (0+3))];
90		*BITMAP_ADDR16(bitmap, y, x + 3) = screen->machine->pens[pen];
	90	*BITMAP_ADDR16(bitmap, y, x + 3) = pen;
91	91	}
92	92	return 0;
93	93	}

src/mess/video/exidy.c

r2200	r2201
15	15	int x,y;
16	16	UINT16 pens[2];
17	17
18		pens[0] = screen->machine->pens[0];
19		pens[1] = screen->machine->pens[1];
	18	pens[0] = 0;
	19	pens[1] = 1;
20	20
21	21	for (y=0; y<EXIDY_SCREEN_HEIGHT>>3; y++)
22	22	{

src/mess/video/pcw.c

r2200	r2201
69	69	pen0^=1;
70	70	}
71	71
72		pen0 = screen->machine->pens[pen0];
73		pen1 = screen->machine->pens[pen1];
74
75	72	/* video enable? */
76	73	if ((pcw_vdu_video_control_register & (1<<6))!=0)
77	74	{

src/mess/video/oric.c

r2200	r2201
197	197
198	198	/* render 6-pixels using foreground and background colours specified */
199	199	/* used in hires and text mode */
200		static void oric_vh_render_6pixels(running_machine *machine, bitmap_t *bitmap,int x,int y, int fg, int bg,int data, int invert_flag)
	200	static void oric_vh_render_6pixels(bitmap_t *bitmap,int x,int y, int fg, int bg,int data, int invert_flag)
201	201	{
202	202	int i;
203	203	int pens[2];
r2200	r2201
210	210	bg ^=0x07;
211	211	}
212	212
213		pens[1] = machine->pens[fg];
214		pens[0] = machine->pens[bg];
	213	pens[1] = fg;
	214	pens[0] = bg;
215	215
216	216	px = x;
217	217	for (i=0; i<6; i++)
r2200	r2201
306	306	oric_vh_update_attribute(c);
307	307
308	308	/* display background colour when attribute has been found */
309		oric_vh_render_6pixels(screen->machine, bitmap,x,y,vh_state.active_foreground_colour, vh_state.active_background_colour, 0,(c & 0x080));
	309	oric_vh_render_6pixels(bitmap,x,y,vh_state.active_foreground_colour, vh_state.active_background_colour, 0,(c & 0x080));
310	310
311	311	if (y<200)
312	312	{
r2200	r2201
330	330	{
331	331	int pixel_data = c & 0x03f;
332	332	/* plot hires pixels */
333		oric_vh_render_6pixels(screen->machine, bitmap,x,y,vh_state.active_foreground_colour, vh_state.active_background_colour, pixel_data,(c & 0x080));
	333	oric_vh_render_6pixels(bitmap,x,y,vh_state.active_foreground_colour, vh_state.active_background_colour, pixel_data,(c & 0x080));
334	334	}
335	335	else
336	336	{
r2200	r2201
357	357	char_data = vh_state.char_data[(char_index<<3) | ch_line] & 0x03f;
358	358
359	359	/* draw! */
360		oric_vh_render_6pixels(screen->machine, bitmap,x,y,
	360	oric_vh_render_6pixels(bitmap,x,y,
361	361	vh_state.active_foreground_colour,
362	362	vh_state.active_background_colour, char_data, (c & 0x080));
363	363	}

src/mess/video/enterp.c

r2200	r2201
24	24	***************************************************************************/
25	25	VIDEO_UPDATE( enterprise )
26	26	{
27		Nick_DoScreen(screen->machine, tmpbitmap);
	27	Nick_DoScreen(tmpbitmap);
28	28	return VIDEO_UPDATE_CALL(generic_bitmapped);
29	29	}
30	30

src/mess/video/electron.c

r2200	r2201
88	88	case 0:
89	89	for( i = 0; i < 80; i++ ) {
90	90	UINT8 pattern = read_vram( ula.screen_addr + i * 8 );
91		electron_plot_pixel( bitmap, x++, scanline, screen->machine->pens[ pal[(pattern>>7)& 1] ] );
92		electron_plot_pixel( bitmap, x++, scanline, screen->machine->pens[ pal[(pattern>>6)& 1] ] );
93		electron_plot_pixel( bitmap, x++, scanline, screen->machine->pens[ pal[(pattern>>5)& 1] ] );
94		electron_plot_pixel( bitmap, x++, scanline, screen->machine->pens[ pal[(pattern>>4)& 1] ] );
95		electron_plot_pixel( bitmap, x++, scanline, screen->machine->pens[ pal[(pattern>>3)& 1] ] );
96		electron_plot_pixel( bitmap, x++, scanline, screen->machine->pens[ pal[(pattern>>2)& 1] ] );
97		electron_plot_pixel( bitmap, x++, scanline, screen->machine->pens[ pal[(pattern>>1)& 1] ] );
98		electron_plot_pixel( bitmap, x++, scanline, screen->machine->pens[ pal[(pattern>>0)& 1] ] );
	91	electron_plot_pixel( bitmap, x++, scanline, pal[(pattern>>7)& 1] );
	92	electron_plot_pixel( bitmap, x++, scanline, pal[(pattern>>6)& 1] );
	93	electron_plot_pixel( bitmap, x++, scanline, pal[(pattern>>5)& 1] );
	94	electron_plot_pixel( bitmap, x++, scanline, pal[(pattern>>4)& 1] );
	95	electron_plot_pixel( bitmap, x++, scanline, pal[(pattern>>3)& 1] );
	96	electron_plot_pixel( bitmap, x++, scanline, pal[(pattern>>2)& 1] );
	97	electron_plot_pixel( bitmap, x++, scanline, pal[(pattern>>1)& 1] );
	98	electron_plot_pixel( bitmap, x++, scanline, pal[(pattern>>0)& 1] );
99	99	}
100	100	ula.screen_addr += 1;
101	101	if ( ( scanline & 0x07 ) == 7 ) {
r2200	r2201
106	106	x = 0;
107	107	for( i = 0; i < 80; i++ ) {
108	108	UINT8 pattern = read_vram( ula.screen_addr + i * 8 );
109		electron_plot_pixel( bitmap, x++, scanline, screen->machine->pens[ pal[map4[pattern>>3]] ] );
110		electron_plot_pixel( bitmap, x++, scanline, screen->machine->pens[ pal[map4[pattern>>3]] ] );
111		electron_plot_pixel( bitmap, x++, scanline, screen->machine->pens[ pal[map4[pattern>>2]] ] );
112		electron_plot_pixel( bitmap, x++, scanline, screen->machine->pens[ pal[map4[pattern>>2]] ] );
113		electron_plot_pixel( bitmap, x++, scanline, screen->machine->pens[ pal[map4[pattern>>1]] ] );
114		electron_plot_pixel( bitmap, x++, scanline, screen->machine->pens[ pal[map4[pattern>>1]] ] );
115		electron_plot_pixel( bitmap, x++, scanline, screen->machine->pens[ pal[map4[pattern>>0]] ] );
116		electron_plot_pixel( bitmap, x++, scanline, screen->machine->pens[ pal[map4[pattern>>0]] ] );
	109	electron_plot_pixel( bitmap, x++, scanline, pal[map4[pattern>>3]] );
	110	electron_plot_pixel( bitmap, x++, scanline, pal[map4[pattern>>3]] );
	111	electron_plot_pixel( bitmap, x++, scanline, pal[map4[pattern>>2]] );
	112	electron_plot_pixel( bitmap, x++, scanline, pal[map4[pattern>>2]] );
	113	electron_plot_pixel( bitmap, x++, scanline, pal[map4[pattern>>1]] );
	114	electron_plot_pixel( bitmap, x++, scanline, pal[map4[pattern>>1]] );
	115	electron_plot_pixel( bitmap, x++, scanline, pal[map4[pattern>>0]] );
	116	electron_plot_pixel( bitmap, x++, scanline, pal[map4[pattern>>0]] );
117	117	}
118	118	ula.screen_addr += 1;
119	119	if ( ( scanline & 0x07 ) == 7 ) {
r2200	r2201
123	123	case 2:
124	124	for( i = 0; i < 80; i++ ) {
125	125	UINT8 pattern = read_vram( ula.screen_addr + i * 8 );
126		electron_plot_pixel( bitmap, x++, scanline, screen->machine->pens[ pal[map16[pattern>>1]] ] );
127		electron_plot_pixel( bitmap, x++, scanline, screen->machine->pens[ pal[map16[pattern>>1]] ] );
128		electron_plot_pixel( bitmap, x++, scanline, screen->machine->pens[ pal[map16[pattern>>1]] ] );
129		electron_plot_pixel( bitmap, x++, scanline, screen->machine->pens[ pal[map16[pattern>>1]] ] );
130		electron_plot_pixel( bitmap, x++, scanline, screen->machine->pens[ pal[map16[pattern>>0]] ] );
131		electron_plot_pixel( bitmap, x++, scanline, screen->machine->pens[ pal[map16[pattern>>0]] ] );
132		electron_plot_pixel( bitmap, x++, scanline, screen->machine->pens[ pal[map16[pattern>>0]] ] );
133		electron_plot_pixel( bitmap, x++, scanline, screen->machine->pens[ pal[map16[pattern>>0]] ] );
	126	electron_plot_pixel( bitmap, x++, scanline, pal[map16[pattern>>1]] );
	127	electron_plot_pixel( bitmap, x++, scanline, pal[map16[pattern>>1]] );
	128	electron_plot_pixel( bitmap, x++, scanline, pal[map16[pattern>>1]] );
	129	electron_plot_pixel( bitmap, x++, scanline, pal[map16[pattern>>1]] );
	130	electron_plot_pixel( bitmap, x++, scanline, pal[map16[pattern>>0]] );
	131	electron_plot_pixel( bitmap, x++, scanline, pal[map16[pattern>>0]] );
	132	electron_plot_pixel( bitmap, x++, scanline, pal[map16[pattern>>0]] );
	133	electron_plot_pixel( bitmap, x++, scanline, pal[map16[pattern>>0]] );
134	134	}
135	135	ula.screen_addr += 1;
136	136	if ( ( scanline & 0x07 ) == 7 ) {
r2200	r2201
139	139	break;
140	140	case 3:
141	141	if ( ( scanline > 249 ) || ( scanline % 10 >= 8 ) ) {
142		fillbitmap( bitmap, screen->machine->pens[7], &r );
	142	fillbitmap( bitmap, 7, &r );
143	143	} else {
144	144	for( i = 0; i < 80; i++ ) {
145	145	UINT8 pattern = read_vram( ula.screen_addr + i * 8 );
146		electron_plot_pixel( bitmap, x++, scanline, screen->machine->pens[ pal[(pattern>>7)&1] ] );
147		electron_plot_pixel( bitmap, x++, scanline, screen->machine->pens[ pal[(pattern>>6)&1] ] );
148		electron_plot_pixel( bitmap, x++, scanline, screen->machine->pens[ pal[(pattern>>5)&1] ] );
149		electron_plot_pixel( bitmap, x++, scanline, screen->machine->pens[ pal[(pattern>>4)&1] ] );
150		electron_plot_pixel( bitmap, x++, scanline, screen->machine->pens[ pal[(pattern>>3)&1] ] );
151		electron_plot_pixel( bitmap, x++, scanline, screen->machine->pens[ pal[(pattern>>2)&1] ] );
152		electron_plot_pixel( bitmap, x++, scanline, screen->machine->pens[ pal[(pattern>>1)&1] ] );
153		electron_plot_pixel( bitmap, x++, scanline, screen->machine->pens[ pal[(pattern>>0)&1] ] );
	146	electron_plot_pixel( bitmap, x++, scanline, pal[(pattern>>7)&1] );
	147	electron_plot_pixel( bitmap, x++, scanline, pal[(pattern>>6)&1] );
	148	electron_plot_pixel( bitmap, x++, scanline, pal[(pattern>>5)&1] );
	149	electron_plot_pixel( bitmap, x++, scanline, pal[(pattern>>4)&1] );
	150	electron_plot_pixel( bitmap, x++, scanline, pal[(pattern>>3)&1] );
	151	electron_plot_pixel( bitmap, x++, scanline, pal[(pattern>>2)&1] );
	152	electron_plot_pixel( bitmap, x++, scanline, pal[(pattern>>1)&1] );
	153	electron_plot_pixel( bitmap, x++, scanline, pal[(pattern>>0)&1] );
154	154	}
155	155	ula.screen_addr += 1;
156	156	if ( ( scanline & 0x07 ) == 7 ) {
r2200	r2201
162	162	case 7:
163	163	for( i = 0; i < 40; i++ ) {
164	164	UINT8 pattern = read_vram( ula.screen_addr + i * 8 );
165		electron_plot_pixel( bitmap, x++, scanline, screen->machine->pens[ pal[(pattern>>7)&1] ] );
166		electron_plot_pixel( bitmap, x++, scanline, screen->machine->pens[ pal[(pattern>>7)&1] ] );
167		electron_plot_pixel( bitmap, x++, scanline, screen->machine->pens[ pal[(pattern>>6)&1] ] );
168		electron_plot_pixel( bitmap, x++, scanline, screen->machine->pens[ pal[(pattern>>6)&1] ] );
169		electron_plot_pixel( bitmap, x++, scanline, screen->machine->pens[ pal[(pattern>>5)&1] ] );
170		electron_plot_pixel( bitmap, x++, scanline, screen->machine->pens[ pal[(pattern>>5)&1] ] );
171		electron_plot_pixel( bitmap, x++, scanline, screen->machine->pens[ pal[(pattern>>4)&1] ] );
172		electron_plot_pixel( bitmap, x++, scanline, screen->machine->pens[ pal[(pattern>>4)&1] ] );
173		electron_plot_pixel( bitmap, x++, scanline, screen->machine->pens[ pal[(pattern>>3)&1] ] );
174		electron_plot_pixel( bitmap, x++, scanline, screen->machine->pens[ pal[(pattern>>3)&1] ] );
175		electron_plot_pixel( bitmap, x++, scanline, screen->machine->pens[ pal[(pattern>>2)&1] ] );
176		electron_plot_pixel( bitmap, x++, scanline, screen->machine->pens[ pal[(pattern>>2)&1] ] );
177		electron_plot_pixel( bitmap, x++, scanline, screen->machine->pens[ pal[(pattern>>1)&1] ] );
178		electron_plot_pixel( bitmap, x++, scanline, screen->machine->pens[ pal[(pattern>>1)&1] ] );
179		electron_plot_pixel( bitmap, x++, scanline, screen->machine->pens[ pal[(pattern>>0)&1] ] );
180		electron_plot_pixel( bitmap, x++, scanline, screen->machine->pens[ pal[(pattern>>0)&1] ] );
	165	electron_plot_pixel( bitmap, x++, scanline, pal[(pattern>>7)&1] );
	166	electron_plot_pixel( bitmap, x++, scanline, pal[(pattern>>7)&1] );
	167	electron_plot_pixel( bitmap, x++, scanline, pal[(pattern>>6)&1] );
	168	electron_plot_pixel( bitmap, x++, scanline, pal[(pattern>>6)&1] );
	169	electron_plot_pixel( bitmap, x++, scanline, pal[(pattern>>5)&1] );
	170	electron_plot_pixel( bitmap, x++, scanline, pal[(pattern>>5)&1] );
	171	electron_plot_pixel( bitmap, x++, scanline, pal[(pattern>>4)&1] );
	172	electron_plot_pixel( bitmap, x++, scanline, pal[(pattern>>4)&1] );
	173	electron_plot_pixel( bitmap, x++, scanline, pal[(pattern>>3)&1] );
	174	electron_plot_pixel( bitmap, x++, scanline, pal[(pattern>>3)&1] );
	175	electron_plot_pixel( bitmap, x++, scanline, pal[(pattern>>2)&1] );
	176	electron_plot_pixel( bitmap, x++, scanline, pal[(pattern>>2)&1] );
	177	electron_plot_pixel( bitmap, x++, scanline, pal[(pattern>>1)&1] );
	178	electron_plot_pixel( bitmap, x++, scanline, pal[(pattern>>1)&1] );
	179	electron_plot_pixel( bitmap, x++, scanline, pal[(pattern>>0)&1] );
	180	electron_plot_pixel( bitmap, x++, scanline, pal[(pattern>>0)&1] );
181	181	}
182	182	ula.screen_addr += 1;
183	183	if ( ( scanline & 0x07 ) == 7 ) {
r2200	r2201
187	187	case 5:
188	188	for( i = 0; i < 40; i++ ) {
189	189	UINT8 pattern = read_vram( ula.screen_addr + i * 8 );
190		electron_plot_pixel( bitmap, x++, scanline, screen->machine->pens[ pal[map4[pattern>>3]] ] );
191		electron_plot_pixel( bitmap, x++, scanline, screen->machine->pens[ pal[map4[pattern>>3]] ] );
192		electron_plot_pixel( bitmap, x++, scanline, screen->machine->pens[ pal[map4[pattern>>3]] ] );
193		electron_plot_pixel( bitmap, x++, scanline, screen->machine->pens[ pal[map4[pattern>>3]] ] );
194		electron_plot_pixel( bitmap, x++, scanline, screen->machine->pens[ pal[map4[pattern>>2]] ] );
195		electron_plot_pixel( bitmap, x++, scanline, screen->machine->pens[ pal[map4[pattern>>2]] ] );
196		electron_plot_pixel( bitmap, x++, scanline, screen->machine->pens[ pal[map4[pattern>>2]] ] );
197		electron_plot_pixel( bitmap, x++, scanline, screen->machine->pens[ pal[map4[pattern>>2]] ] );
198		electron_plot_pixel( bitmap, x++, scanline, screen->machine->pens[ pal[map4[pattern>>1]] ] );
199		electron_plot_pixel( bitmap, x++, scanline, screen->machine->pens[ pal[map4[pattern>>1]] ] );
200		electron_plot_pixel( bitmap, x++, scanline, screen->machine->pens[ pal[map4[pattern>>1]] ] );
201		electron_plot_pixel( bitmap, x++, scanline, screen->machine->pens[ pal[map4[pattern>>1]] ] );
202		electron_plot_pixel( bitmap, x++, scanline, screen->machine->pens[ pal[map4[pattern>>0]] ] );
203		electron_plot_pixel( bitmap, x++, scanline, screen->machine->pens[ pal[map4[pattern>>0]] ] );
204		electron_plot_pixel( bitmap, x++, scanline, screen->machine->pens[ pal[map4[pattern>>0]] ] );
205		electron_plot_pixel( bitmap, x++, scanline, screen->machine->pens[ pal[map4[pattern>>0]] ] );
	190	electron_plot_pixel( bitmap, x++, scanline, pal[map4[pattern>>3]] );
	191	electron_plot_pixel( bitmap, x++, scanline, pal[map4[pattern>>3]] );
	192	electron_plot_pixel( bitmap, x++, scanline, pal[map4[pattern>>3]] );
	193	electron_plot_pixel( bitmap, x++, scanline, pal[map4[pattern>>3]] );
	194	electron_plot_pixel( bitmap, x++, scanline, pal[map4[pattern>>2]] );
	195	electron_plot_pixel( bitmap, x++, scanline, pal[map4[pattern>>2]] );
	196	electron_plot_pixel( bitmap, x++, scanline, pal[map4[pattern>>2]] );
	197	electron_plot_pixel( bitmap, x++, scanline, pal[map4[pattern>>2]] );
	198	electron_plot_pixel( bitmap, x++, scanline, pal[map4[pattern>>1]] );
	199	electron_plot_pixel( bitmap, x++, scanline, pal[map4[pattern>>1]] );
	200	electron_plot_pixel( bitmap, x++, scanline, pal[map4[pattern>>1]] );
	201	electron_plot_pixel( bitmap, x++, scanline, pal[map4[pattern>>1]] );
	202	electron_plot_pixel( bitmap, x++, scanline, pal[map4[pattern>>0]] );
	203	electron_plot_pixel( bitmap, x++, scanline, pal[map4[pattern>>0]] );
	204	electron_plot_pixel( bitmap, x++, scanline, pal[map4[pattern>>0]] );
	205	electron_plot_pixel( bitmap, x++, scanline, pal[map4[pattern>>0]] );
206	206	}
207	207	ula.screen_addr += 1;
208	208	if ( ( scanline & 0x07 ) == 7 ) {
r2200	r2201
211	211	break;
212	212	case 6:
213	213	if ( ( scanline > 249 ) || ( scanline % 10 >= 8 ) ) {
214		fillbitmap( bitmap, screen->machine->pens[7], &r );
	214	fillbitmap( bitmap, 7, &r );
215	215	} else {
216	216	for( i = 0; i < 40; i++ ) {
217	217	UINT8 pattern = read_vram( ula.screen_addr + i * 8 );
218		electron_plot_pixel( bitmap, x++, scanline, screen->machine->pens[ pal[(pattern>>7)&1] ] );
219		electron_plot_pixel( bitmap, x++, scanline, screen->machine->pens[ pal[(pattern>>7)&1] ] );
220		electron_plot_pixel( bitmap, x++, scanline, screen->machine->pens[ pal[(pattern>>6)&1] ] );
221		electron_plot_pixel( bitmap, x++, scanline, screen->machine->pens[ pal[(pattern>>6)&1] ] );
222		electron_plot_pixel( bitmap, x++, scanline, screen->machine->pens[ pal[(pattern>>5)&1] ] );
223		electron_plot_pixel( bitmap, x++, scanline, screen->machine->pens[ pal[(pattern>>5)&1] ] );
224		electron_plot_pixel( bitmap, x++, scanline, screen->machine->pens[ pal[(pattern>>4)&1] ] );
225		electron_plot_pixel( bitmap, x++, scanline, screen->machine->pens[ pal[(pattern>>4)&1] ] );
226		electron_plot_pixel( bitmap, x++, scanline, screen->machine->pens[ pal[(pattern>>3)&1] ] );
227		electron_plot_pixel( bitmap, x++, scanline, screen->machine->pens[ pal[(pattern>>3)&1] ] );
228		electron_plot_pixel( bitmap, x++, scanline, screen->machine->pens[ pal[(pattern>>2)&1] ] );
229		electron_plot_pixel( bitmap, x++, scanline, screen->machine->pens[ pal[(pattern>>2)&1] ] );
230		electron_plot_pixel( bitmap, x++, scanline, screen->machine->pens[ pal[(pattern>>1)&1] ] );
231		electron_plot_pixel( bitmap, x++, scanline, screen->machine->pens[ pal[(pattern>>1)&1] ] );
232		electron_plot_pixel( bitmap, x++, scanline, screen->machine->pens[ pal[(pattern>>0)&1] ] );
233		electron_plot_pixel( bitmap, x++, scanline, screen->machine->pens[ pal[(pattern>>0)&1] ] );
	218	electron_plot_pixel( bitmap, x++, scanline, pal[(pattern>>7)&1] );
	219	electron_plot_pixel( bitmap, x++, scanline, pal[(pattern>>7)&1] );
	220	electron_plot_pixel( bitmap, x++, scanline, pal[(pattern>>6)&1] );
	221	electron_plot_pixel( bitmap, x++, scanline, pal[(pattern>>6)&1] );
	222	electron_plot_pixel( bitmap, x++, scanline, pal[(pattern>>5)&1] );
	223	electron_plot_pixel( bitmap, x++, scanline, pal[(pattern>>5)&1] );
	224	electron_plot_pixel( bitmap, x++, scanline, pal[(pattern>>4)&1] );
	225	electron_plot_pixel( bitmap, x++, scanline, pal[(pattern>>4)&1] );
	226	electron_plot_pixel( bitmap, x++, scanline, pal[(pattern>>3)&1] );
	227	electron_plot_pixel( bitmap, x++, scanline, pal[(pattern>>3)&1] );
	228	electron_plot_pixel( bitmap, x++, scanline, pal[(pattern>>2)&1] );
	229	electron_plot_pixel( bitmap, x++, scanline, pal[(pattern>>2)&1] );
	230	electron_plot_pixel( bitmap, x++, scanline, pal[(pattern>>1)&1] );
	231	electron_plot_pixel( bitmap, x++, scanline, pal[(pattern>>1)&1] );
	232	electron_plot_pixel( bitmap, x++, scanline, pal[(pattern>>0)&1] );
	233	electron_plot_pixel( bitmap, x++, scanline, pal[(pattern>>0)&1] );
234	234	}
235	235	ula.screen_addr += 1;
236	236	if ( ( scanline % 10 ) == 7 ) {

src/mess/video/cdp1864.c

r2200	r2201
130	130	color = cdp1864.colorram_r(cdp1864.dmaptr);
131	131	}
132	132
133		*BITMAP_ADDR16(cdptmpbitmap, y, sx + x) = Machine->pens[color];
	133	*BITMAP_ADDR16(cdptmpbitmap, y, sx + x) = color;
134	134
135	135	data <<= 1;
136	136	}
r2200	r2201
224	224	{
225	225	if (cdp1864.disp)
226	226	{
227		fillbitmap(bitmap, screen->machine->pens[cdp1864_bgcolseq[cdp1864.bgcolor]], cliprect);
	227	fillbitmap(bitmap, cdp1864_bgcolseq[cdp1864.bgcolor], cliprect);
228	228	copybitmap_trans(bitmap, cdptmpbitmap, 0, 0, 0, 0, cliprect, cdp1864.bgcolor);
229	229	}
230	230	else

src/mess/video/odyssey2.c

r2200	r2201
305	305	rect.min_y = rect.max_y = vpos;
306	306	rect.min_x = I824X_START_ACTIVE_SCAN;
307	307	rect.max_x = I824X_END_ACTIVE_SCAN - 1;
308		fillbitmap( tmp_bitmap, machine->pens[ ( (o2_vdc.s.color >> 3) & 0x7 ) | ( ( lum << 3 ) ^ 0x08 ) ], &rect );
	308	fillbitmap( tmp_bitmap, ( (o2_vdc.s.color >> 3) & 0x7 ) | ( ( lum << 3 ) ^ 0x08 ), &rect );
309	309
310	310	/* Clear collision map */
311	311	memset( collision_map, 0, sizeof( collision_map ) );
312	312
313	313	/* Display grid if enabled */
314	314	if ( o2_vdc.s.control & 0x08 ) {
315		UINT16   color = machine->pens[ ( o2_vdc.s.color & 7 ) | ( ( o2_vdc.s.color >> 3 ) & 0x08 ) | ( ( lum << 3 ) ^ 0x08 ) ];
	315	UINT16   color = ( o2_vdc.s.color & 7 ) | ( ( o2_vdc.s.color >> 3 ) & 0x08 ) | ( ( lum << 3 ) ^ 0x08 );
316	316	int      x_grid_offset = 8;
317	317	int    y_grid_offset = 24;
318	318	int      width = 16;
r2200	r2201
368	368	int   height = 8 - ( ( ( y >> 1 ) + o2_vdc.s.foreground[i].ptr ) & 7 );
369	369
370	370	if ( y <= ( vpos - start_vpos ) && ( vpos - start_vpos ) < y + height * 2 ) {
371		UINT16   color = machine->pens[ 16 + ( ( o2_vdc.s.foreground[i].color & 0x0E ) >> 1 ) ];
	371	UINT16   color = 16 + ( ( o2_vdc.s.foreground[i].color & 0x0E ) >> 1 );
372	372	int      offset = ( o2_vdc.s.foreground[i].ptr | ( ( o2_vdc.s.foreground[i].color & 0x01 ) << 8 ) ) + ( y >> 1 ) + ( ( vpos - start_vpos - y ) >> 1 );
373	373	UINT8   chr = ((char*)o2_shape)[ offset & 0x1FF ];
374	374	int      x = o2_vdc.s.foreground[i].x;
r2200	r2201
405	405	for ( j = 0; j < ARRAY_LENGTH( o2_vdc.s.quad[0].single ); j++, x += 8 ) {
406	406	int      char_height = 8 - ( ( ( y >> 1 ) + o2_vdc.s.quad[i].single[j].ptr ) & 7 );
407	407	if ( y <= ( vpos - start_vpos ) && ( vpos - start_vpos ) < y + char_height * 2 ) {
408		UINT16 color = machine->pens[ 16 + ( ( o2_vdc.s.quad[i].single[j].color & 0x0E ) >> 1 ) ];
	408	UINT16 color = 16 + ( ( o2_vdc.s.quad[i].single[j].color & 0x0E ) >> 1 );
409	409	int   offset = ( o2_vdc.s.quad[i].single[j].ptr | ( ( o2_vdc.s.quad[i].single[j].color & 0x01 ) << 8 ) ) + ( y >> 1 ) + ( ( vpos - start_vpos - y ) >> 1 );
410	410	UINT8   chr = ((char*)o2_shape)[ offset & 0x1FF ];
411	411	UINT8   m;
r2200	r2201
440	440	/* Zoomed sprite */
441	441	sprite_width[i] = 16;
442	442	if ( y <= ( vpos - start_vpos ) && ( vpos - start_vpos ) < y + height * 4 ) {
443		UINT16 color = machine->pens[ 16 + ( ( o2_vdc.s.sprites[i].color >> 3 ) & 0x07 ) ];
	443	UINT16 color = 16 + ( ( o2_vdc.s.sprites[i].color >> 3 ) & 0x07 );
444	444	UINT8   chr = o2_vdc.s.shape[i][ ( ( vpos - start_vpos - y ) >> 2 ) ];
445	445	int      x = o2_vdc.s.sprites[i].x;
446	446	UINT8   m;
r2200	r2201
477	477	} else {
478	478	/* Regular sprite */
479	479	if ( y <= ( vpos - start_vpos ) && ( vpos - start_vpos ) < y + height * 2 ) {
480		UINT16 color = machine->pens[ 16 + ( ( o2_vdc.s.sprites[i].color >> 3 ) & 0x07 ) ];
	480	UINT16 color = 16 + ( ( o2_vdc.s.sprites[i].color >> 3 ) & 0x07 );
481	481	UINT8   chr = o2_vdc.s.shape[i][ ( ( vpos - start_vpos - y ) >> 1 ) ];
482	482	int      x = o2_vdc.s.sprites[i].x;
483	483	UINT8   m;

src/mess/video/primo.c

r2200	r2201
14	14	UINT16 primo_video_memory_base;
15	15
16	16
17		static void primo_draw_scanline(running_machine *machine, bitmap_t *bitmap, int primo_scanline)
	17	static void primo_draw_scanline(bitmap_t *bitmap, int primo_scanline)
18	18	{
19	19	int x, i;
20	20	UINT8 data;
r2200	r2201
30	30	data = primo_video_ram_line[x/8];
31	31
32	32	for (i=0; i<8; i++)
33		scanline[x+i]=machine->pens[(data & (0x80>>i)) ? 1 : 0];
	33	scanline[x+i]=(data & (0x80>>i)) ? 1 : 0;
34	34
35	35	}
36	36	}
r2200	r2201
41	41	int primo_scanline;
42	42
43	43	for (primo_scanline=0; primo_scanline<192; primo_scanline++)
44		primo_draw_scanline(screen->machine, bitmap, primo_scanline);
	44	primo_draw_scanline(bitmap, primo_scanline);
45	45	return 0;
46	46	}

src/mess/video/crt.c

r2200	r2201
170	170	}
171	171
172	172	/* draw pixel on screen */
173		//plot_pixel(bitmap, x, y+crt_window_offset_y, machine->pens[node->intensity]);
174		line[x] = screen->machine->pens[node->intensity];
	173	//plot_pixel(bitmap, x, y+crt_window_offset_y, node->intensity);
	174	line[x] = node->intensity;
175	175
176	176	if (node->intensity != 0)
177	177	p_i = i;   /* current node will be next iteration's previous node */

src/mess/video/hd66421.c

r2200	r2201
144	144	if (temp <  0) temp =  0;
145	145	if (temp > 31) temp = 31;
146	146	bright = 1.0 * temp / 31;
147		pen[i] = screen->machine->pens[i];
	147	pen[i] = i;
148	148	#ifdef BRIGHTNESS_DOES_NOT_WORK
149	149	palette_set_color( screen->machine, pen[i], 255 * bright, 255 * bright, 255 * bright);
150	150	#else

src/mess/video/galaxy.c

r2200	r2201
61	61	black_area.max_x = 32*8-1;
62	62	black_area.min_y = 0;
63	63	black_area.max_y = 16*13-1;
64		fillbitmap(bitmap, screen->machine->pens[1], &black_area);
	64	fillbitmap(bitmap, 1, &black_area);
65	65	fast_mode = TRUE;
66	66	return 0;
67	67	}
r2200	r2201
82	82	}
83	83	if (horizontal_pos == 0x0b)
84	84	black_area.min_x =  black_area.max_x = 0;
85		fillbitmap(bitmap, screen->machine->pens[1], &black_area);
	85	fillbitmap(bitmap, 1, &black_area);
86	86	}
87	87
88	88	for( offs = 0; offs < 512; offs++ )

src/mess/video/kc.c

r2200	r2201
116	116
117	117
118	118	/* draw 8 pixels */
119		static void kc85_draw_8_pixels(running_machine *machine, bitmap_t *bitmap,int x,int y, unsigned char colour_byte, unsigned char gfx_byte)
	119	static void kc85_draw_8_pixels(bitmap_t *bitmap,int x,int y, unsigned char colour_byte, unsigned char gfx_byte)
120	120	{
121	121	int a;
122	122	int background_pen;
r2200	r2201
144	144	foreground_pen = background_pen;
145	145	}
146	146
147		pens[0] = machine->pens[background_pen];
148		pens[1] = machine->pens[foreground_pen];
	147	pens[0] = background_pen;
	148	pens[1] = foreground_pen;
149	149
150	150	px = x;
151	151
r2200	r2201
288	288
289	289	/* process visible cycles within a line */
290	290	/* the cycles will never span over the end of a line */
291		static void kc85_common_process_cycles(running_machine *machine, struct video_update_state *video_update, int cycles)
	291	static void kc85_common_process_cycles(struct video_update_state *video_update, int cycles)
292	292	{
293	293	while (cycles!=0)
294	294	{
r2200	r2201
322	322	/* grab colour and pixel information */
323	323	video_update->pixel_grab_callback(&video_update->grab_data,video_update->x,video_update->y,&colour_byte, &gfx_byte);
324	324	/* draw to screen */
325		kc85_draw_8_pixels(machine, video_update->bitmap, video_update->render_x, video_update->render_y,colour_byte, gfx_byte);
	325	kc85_draw_8_pixels(video_update->bitmap, video_update->render_x, video_update->render_y,colour_byte, gfx_byte);
326	326	/* update render coordinate */
327	327	video_update->render_x+=8;
328	328	video_update->x++;
r2200	r2201
373	373	}
374	374
375	375	/* process a whole visible line */
376		static int kc85_common_vh_process_line(running_machine *machine, struct video_update_state *video_update, int cycles)
	376	static int kc85_common_vh_process_line(struct video_update_state *video_update, int cycles)
377	377	{
378	378	int cycles_to_do;
379	379
r2200	r2201
386	386	//logerror("process line: cycles_to_do: %d\n",cycles_to_do);
387	387
388	388	/* do the cycles - draw them */
389		kc85_common_process_cycles(machine, video_update, cycles_to_do);
	389	kc85_common_process_cycles(video_update, cycles_to_do);
390	390
391	391	video_update->horizontal.cycles_remaining -= cycles_to_do;
392	392	cycles -=cycles_to_do;
r2200	r2201
423	423	return cycles;
424	424	}
425	425
426		static void kc85_common_vh_process_lines(running_machine *machine, struct video_update_state *video_update, int cycles)
	426	static void kc85_common_vh_process_lines(struct video_update_state *video_update, int cycles)
427	427	{
428	428	while (cycles!=0)
429	429	{
r2200	r2201
451	451	int cycles_remaining;
452	452
453	453	/* update cycles with number of cycles not processed */
454		cycles_remaining = kc85_common_vh_process_line(machine, video_update, cycles_to_do);
	454	cycles_remaining = kc85_common_vh_process_line(video_update, cycles_to_do);
455	455
456	456	cycles_done = cycles_to_do - cycles_remaining;
457	457
r2200	r2201
529	529	delta_cycles = pItem->Event_Time - cycles_offset;
530	530
531	531	//logerror("cycles between this event and next: %d\n",delta_cycles);
532		kc85_common_vh_process_lines(machine, &video_update, delta_cycles);
	532	kc85_common_vh_process_lines(&video_update, delta_cycles);
533	533
534	534	/* update number of cycles remaining in frame */
535	535	cycles_remaining_in_frame -= delta_cycles;
r2200	r2201
546	546
547	547
548	548	/* process remainder */
549		kc85_common_vh_process_lines(machine, &video_update, cycles_remaining_in_frame);
	549	kc85_common_vh_process_lines(&video_update, cycles_remaining_in_frame);
550	550	EventList_Reset();
551	551	EventList_SetOffsetStartTime ( ATTOTIME_TO_CYCLES(0, attotime_mul(video_screen_get_scan_period(machine->primary_screen), video_screen_get_vpos(machine->primary_screen))) );
552	552	}
r2200	r2201
673	673	colour_byte = colour_ram[offset];
674	674	gfx_byte = pixel_ram[offset];
675	675
676		kc85_draw_8_pixels(machine, bitmap,(x<<3),y, colour_byte, gfx_byte);
	676	kc85_draw_8_pixels(bitmap,(x<<3),y, colour_byte, gfx_byte);
677	677
678	678	}
679	679	}
r2200	r2201
770	770	colour_byte = colour_ram[colour_offset];
771	771	gfx_byte = pixel_ram[pixel_offset];
772	772
773		kc85_draw_8_pixels(machine, bitmap,(x<<3),y, colour_byte, gfx_byte);
	773	kc85_draw_8_pixels(bitmap,(x<<3),y, colour_byte, gfx_byte);
774	774	}
775	775	}
776	776	#endif

Previous

15994 Revisions

Next

---

© 1998-2018 The MESS Team