megasys1.c

这个是延伸mame的在wince平台下的游戏模拟器的代码

/***************************************************************************

  Draw the game screen in the given osd_bitmap.

***************************************************************************/
void paletteram_RRRRGGGGBBBBRGBx_word_w(int offset, int data);
void vh_screenrefresh(struct osd_bitmap *bitmap,int full_refresh)
{
int offs,code,sx,sy,attr,i,j;
unsigned char *current_ram, *current_dirty;
int current_mask;
int mask[3] = {0xfff,0xfff,0xfff};

unsigned int *pen_usage;
int color_codes_start, color, colmask[16], layers_n;

int active_layers1;

	active_layers1 = active_layers;

	layers_n = 3;

	switch (hardware_type)
	{
		/* MS1-Z has scroll 1,2 & Sprites only (always active, no priority ?) */
		case 'Z':
		{
			layers_n = 2;
			bg = 0;		fg = 1;		txt = 2;
			active_layers = 0x020B;
		}	break;

		case 'A':
		{
			bg = 0;
			if (active_layers & 0x0100)	{fg = 2;	txt = 1;}
			else						{fg = 1;	txt = 2;}
		}

		case 'B':
		{
			if (Machine->gamedrv != &avspirit_driver)
			{
				bg = 0;
				if (active_layers & 0x0100)	{fg = 2;	txt = 1;}
				else						{fg = 1;	txt = 2;}
			}
			else
			{
				txt = 2;
				if (active_layers & 0x0100)	{bg = 0;	fg = 1;}
				else						{bg = 1;	fg = 0;}
			}
		}	break;

		case 'C':
		{
			active_layers ^= 0x0200;	/* sprites/fg priority swapped */
			txt = 2;
			if (active_layers & 0x0100)	{bg = 0;	fg = 1;}
			else						{bg = 1;	fg = 0;}
		}	break;

	}


/* Palette stuff */

	palette_init_used_colors();

/* We consider whole layers, redraw whole layers: worst case is slow! */

	for (j = 0 ; j < layers_n ; j++ )
	{
		/* let's skip disabled layers */


		pen_usage = Machine->gfx[j]->pen_usage;
		color_codes_start = Machine->drv->gfxdecodeinfo[j].color_codes_start;

		for (color = 0 ; color < 16 ; color++) colmask[color] = 0;

		for (offs  = 0 ; offs < 0x4000 ; offs += 2)
		{
			color = ( READ_WORD(&scrollram[j][offs]) & 0xF000 ) >> 12;
			code  =   READ_WORD(&scrollram[j][offs]) & mask[j];

			if (scrollflag[j] & 0x10)
					colmask[color] |= pen_usage[code];
			else{	colmask[color] |= pen_usage[code*4+0];
					colmask[color] |= pen_usage[code*4+1];
					colmask[color] |= pen_usage[code*4+2];
					colmask[color] |= pen_usage[code*4+3];}
		}

		for (color = 0; color < 16; color++)
		{
			if (colmask[color])
			{
				for (i = 0; i < 16; i++)
					if (colmask[color] & (1 << i))
						palette_used_colors[16 * color + i + color_codes_start] = PALETTE_COLOR_USED;
			}
		}

		if (j != bg)	/* background colors are all used */
		{
			for (color = 0; color < 16; color++)
				palette_used_colors[16 * color + 15 + color_codes_start] = PALETTE_COLOR_TRANSPARENT;
		}
	}



	/* Sprites */

	for (color = 0 ; color < 16 ; color++) colmask[color] = 0;

	/* different sprites hw */
	if (hardware_type == 'Z')
	{
	int sprite;

		pen_usage = Machine->gfx[2]->pen_usage;
		color_codes_start = Machine->drv->gfxdecodeinfo[2].color_codes_start;

		for (sprite = 0; sprite < 0x80 ; sprite++)
		{
		unsigned char* spritedata;

			spritedata = &spriteram[sprite*16];

			sx = READ_WORD(&spritedata[0x0A]) % 512;
			sy = READ_WORD(&spritedata[0x0C]) % 512;

			if (sx > 256-1) sx -= 512;
			if (sy > 256-1) sy -= 512;

			if ((sx > 256-1) ||(sy > 256-1) ||(sx < 0-15) ||(sy < 0-15)) continue;

			code  = READ_WORD(&spritedata[0x0E]);
			color = READ_WORD(&spritedata[0x08]) & 0x0F;

			colmask[color] |= pen_usage[code];
		}
	}
	else
	{
		pen_usage = Machine->gfx[3]->pen_usage;
		color_codes_start = Machine->drv->gfxdecodeinfo[3].color_codes_start;

		for (offs = 0; offs < 0x2000 ; offs += 8)
		{
		int sprite;
		unsigned char* spritedata;

			sprite = READ_WORD(&objectram[offs+0x00]);
			spritedata = &spriteram[(sprite&0x7F)*16];

			attr = READ_WORD(&spritedata[0x08]);
			if ( (attr & 0xc0) != ((offs/0x800)<<6) ) continue;

			sx = ( READ_WORD(&spritedata[0x0A]) + READ_WORD(&objectram[offs+0x02]) ) % 512;
			sy = ( READ_WORD(&spritedata[0x0C]) + READ_WORD(&objectram[offs+0x04]) ) % 512;

			if (sx > 256-1) sx -= 512;
			if (sy > 256-1) sy -= 512;

			if ((sx > 256-1) ||(sy > 256-1) ||(sx < 0-15) ||(sy < 0-15)) continue;

			code  = READ_WORD(&spritedata[0x0E]) + READ_WORD(&objectram[offs+0x06]);
			code  =	(code & 0xfff ) + (spritebank << 12);
			color = (attr & 0x0F);

			colmask[color] |= pen_usage[code];
		}
	}


	for (color = 0; color < 16; color++)
	 for (i = 0; i < 16; i++)
	  if (colmask[color] & (1 << i)) palette_used_colors[16 * color + i + color_codes_start] = PALETTE_COLOR_USED;

/* hack: colors with bit 0 high will flash */
#if 0
	{
	unsigned char tmp_paletteram[256*4*2];

				for (color = 0; color < 256*4; color++)
					tmp_paletteram[color*2] = paletteram[color*2];

				for (color = 0; color < 256*4; color++)
				{
					if (paletteram_word_r(color*2)&1)
					{
						palette_used_colors[color] = PALETTE_COLOR_USED;
						paletteram_RRRRGGGGBBBBRGBx_word_w(color*2,(cpu_getcurrentframe() & 1)?0xF000:0xFFFF);
					}
				}

				if (palette_recalc()) mark_dirty_all();

				for (color = 0; color < 256*4; color++)
					paletteram[color*2] = tmp_paletteram[color*2];
	}
#else
	if (palette_recalc()) mark_dirty_all();
#endif



/* Allocate off screen bitmaps */

	for (i = 0; i < layers_n ; i++)
	{
		nx[i] = 16 / ( 1 << (scrollflag[i] & 0x3) );
		ny[i] = 32 / nx[i];

		if (scrollflag[i]&0x10)
		{
			if (ny[i] > 4)
			{
				nx[i] /= 1;
				ny[i] /= 4;
			}
			else
			{
				nx[i] /= 2;
				ny[i] /= 2;
			}
		}

		/* let's skip disabled layers */
		if ( (active_layers & (1 << i )) && (scroll_bitmap[i] == 0) )
		{
			if ((scroll_bitmap[i] = osd_new_bitmap(256*nx[i], 256*ny[i], 4))==0)
			{
				return;
			}

		}

	}


#ifdef MAME_DEBUG
debugsprites = 0;
if (osd_key_pressed(OSD_KEY_Z))
{
int msk = 0;

	if (osd_key_pressed(OSD_KEY_Q)) { msk |= 0xfff1;}
	if (osd_key_pressed(OSD_KEY_W)) { msk |= 0xfff2;}
	if (osd_key_pressed(OSD_KEY_E)) { msk |= 0xfff4;}
	if (osd_key_pressed(OSD_KEY_A))	{ msk |= 0xfff8; debugsprites = 1;}
	if (osd_key_pressed(OSD_KEY_S))	{ msk |= 0xfff8; debugsprites = 2;}
	if (osd_key_pressed(OSD_KEY_D))	{ msk |= 0xfff8; debugsprites = 3;}
	if (osd_key_pressed(OSD_KEY_F))	{ msk |= 0xfff8; debugsprites = 4;}

	if (msk != 0) active_layers &= msk;
}
#endif



/* Update the scrolling layers */

	for (i = 0; i < layers_n ; i++)
	{
		/* let's skip disabled layers */
		if (!(active_layers & (1 << i )))	continue;

		current_ram   = scrollram[i];
		current_dirty = scrollram_dirty[i];
		current_mask  = mask[i];

		if (scrollflag[i] & 0x10)	/* 8x8 tiles */
		{
		 for (j=0 ; j < nx[i]*ny[i] ; j++)
		  for (sx = (j%nx[i])*256; sx < (j%nx[i])*256+256; sx += 8)
		   for (sy = (j/nx[i])*256; sy < (j/nx[i])*256+256; sy += 8)
		   {
			if (current_dirty[0])
			{
				current_dirty[0] = 0;
				code = READ_WORD(&current_ram[0]);
				drawgfx(scroll_bitmap[i],Machine->gfx[i],
					code & current_mask,
					(code & 0xF000)>>12,
					0,0,
					sx,sy,
					0,TRANSPARENCY_NONE,0);
			};
			current_dirty++;	current_ram+=2;
		   }
		}
		else	/* 16x16 tiles */
		{
		 for (j=0 ; j < nx[i]*ny[i] ; j++)
		  for (sx = (j%nx[i])*256; sx < (j%nx[i])*256+256; sx += 16)
		   for (sy = (j/nx[i])*256; sy < (j/nx[i])*256+256; sy += 16)
		   {
			if (current_dirty[0])
			{
				current_dirty[0] = 0;
				code = READ_WORD(&current_ram[0]);
				attr = (code >> 12) & 0x0F;
				code = (code & current_mask) * 4;
				drawgfx(scroll_bitmap[i],Machine->gfx[i],
					code+0,
					attr,
					0,0,sx+0,sy+0,0,TRANSPARENCY_NONE,0);
				drawgfx(scroll_bitmap[i],Machine->gfx[i],
					code+1,
					attr,
					0,0,sx+0,sy+8,0,TRANSPARENCY_NONE,0);
				drawgfx(scroll_bitmap[i],Machine->gfx[i],
					code+2,
					attr,
					0,0,sx+8,sy+0,0,TRANSPARENCY_NONE,0);
				drawgfx(scroll_bitmap[i],Machine->gfx[i],
					code+3,
					attr,
					0,0,sx+8,sy+8,0,TRANSPARENCY_NONE,0);
			};
			current_dirty++;	current_ram+=2;
		   }
		} /* 16x16 tiles */
	} /* i */

/* copy each (enabled) layer */


#define copylayer(_n_,_transparency_,_pen_)\
	if (active_layers & (1 << _n_ ))\
	{\
		copyscrollbitmap(bitmap, scroll_bitmap[_n_],\
				1,&scrollx[_n_],1,&scrolly[_n_],\
				&Machine->drv->visible_area,\
				_transparency_,_pen_);\
	}


	/* Copy the background */
	copylayer(bg,TRANSPARENCY_NONE,0)
	else	osd_clearbitmap(Machine->scrbitmap);

	/* If priority effect is active .. */
	if (spriteflag & 0x0100)
	{
		/* Copy the foreground below ... */
		if (!(active_layers &0x0200))	copylayer(fg,TRANSPARENCY_PEN,palette_transparent_pen);

		/* draw sprites with color >= 8 */
		if (active_layers & 0x08)	draw_sprites(bitmap,1);

		/* ... or over sprites with color >= 8 */
		if (active_layers &0x0200)	copylayer(fg,TRANSPARENCY_PEN,palette_transparent_pen);

		/* Draw sprites with color 0-7 */
		if (active_layers & 0x08)	draw_sprites(bitmap,0);
	}
	else
	{
		/* Copy the foreground below ... */
		if (!(active_layers &0x0200))	copylayer(fg,TRANSPARENCY_PEN,palette_transparent_pen);

		/* Draw sprites regardless of their color */
		if (active_layers & 0x08)	draw_sprites(bitmap,-1);

		/* ... or over sprites */
		if (active_layers &0x0200)	copylayer(fg,TRANSPARENCY_PEN,palette_transparent_pen);
	}

	/* Copy the text layer */
	copylayer(txt,TRANSPARENCY_PEN,palette_transparent_pen);

	active_layers = active_layers1;
}