static void draw_background( struct mame_bitmap *bitmap, const struct rectangle *cliprect )
{
	int dx = -48;
	int dy = 16;
	int attributes = grchamp_vreg1[0x3];
		/*	----xxxx	Analog Tachometer output
		**	---x----	palette select
		**	--x-----	enables msb of bg#3 xscroll
		**	xx------	unused
		*/

	int color = (attributes&0x10)?1:0;
	if( color!=palette_bank )
	{
		palette_bank = color;
		tilemap_mark_all_tiles_dirty( ALL_TILEMAPS );
	}

	tilemap_set_scrollx( tilemap[0], 0, dx-(grchamp_vreg1[0x0]+grchamp_vreg1[0x1]*256) );
	tilemap_set_scrolly( tilemap[0], 0, dy - grchamp_vreg1[0x2] );
	tilemap_set_scrollx( tilemap[1], 0, dx-(grchamp_vreg1[0x5]+grchamp_vreg1[0x6]*256) );
	tilemap_set_scrolly( tilemap[1], 0, dy - grchamp_vreg1[0x7] );
	tilemap_set_scrollx( tilemap[2], 0, dx-(grchamp_vreg1[0x9]+ ((attributes&0x20)?256:(grchamp_vreg1[0xa]*256))));
	tilemap_set_scrolly( tilemap[2], 0, dy - grchamp_vreg1[0xb] );

	tilemap_draw(bitmap,cliprect,tilemap[0],0,0);
	tilemap_draw(bitmap,cliprect,tilemap[1],0,0);
	tilemap_draw(bitmap,cliprect,tilemap[2],0,0);
}
Beispiel #2
0
static SCREEN_UPDATE(galaxi)
{
	galaxi_state *state = screen->machine().driver_data<galaxi_state>();
	int layers_ctrl = -1;

#ifdef MAME_DEBUG
	if (screen->machine().input().code_pressed(KEYCODE_R))	// remapped due to inputs changes.
	{
		int msk = 0;
		if (screen->machine().input().code_pressed(KEYCODE_T))	msk |= 1;
		if (screen->machine().input().code_pressed(KEYCODE_Y))	msk |= 2;
		if (screen->machine().input().code_pressed(KEYCODE_U))	msk |= 4;
		if (screen->machine().input().code_pressed(KEYCODE_I))	msk |= 8;
		if (screen->machine().input().code_pressed(KEYCODE_O))	msk |= 16;
		if (msk != 0) layers_ctrl &= msk;
	}
#endif

	if (layers_ctrl & 1)	tilemap_draw(bitmap, cliprect, state->m_bg1_tmap, TILEMAP_DRAW_OPAQUE, 0);
	else				bitmap_fill(bitmap, cliprect, get_black_pen(screen->machine()));
	if (layers_ctrl & 2)	tilemap_draw(bitmap, cliprect, state->m_bg2_tmap, 0, 0);
	if (layers_ctrl & 4)	tilemap_draw(bitmap, cliprect, state->m_bg3_tmap, 0, 0);
	if (layers_ctrl & 8)	tilemap_draw(bitmap, cliprect, state->m_bg4_tmap, 0, 0);

	if (layers_ctrl & 16)	tilemap_draw(bitmap, cliprect, state->m_fg_tmap, 0, 0);

	return 0;
}
Beispiel #3
0
static SCREEN_UPDATE( dunhuang )
{
	dunhuang_state *state = screen->machine().driver_data<dunhuang_state>();
	int layers_ctrl = -1;

#if DUNHUANG_DEBUG
if (input_code_pressed(screen->machine(), KEYCODE_Z))
{
	int msk = 0;
	if (input_code_pressed(screen->machine(), KEYCODE_Q))	msk |= 1;
	if (input_code_pressed(screen->machine(), KEYCODE_W))	msk |= 2;
	if (msk != 0) layers_ctrl &= msk;
}
#endif

	bitmap_fill(bitmap, cliprect, get_black_pen(screen->machine()));

	switch (state->m_layers)
	{
		case 0x04:	// girl select: bg over fg
			if (layers_ctrl & 2)	tilemap_draw(bitmap,cliprect, state->m_tmap2, TILEMAP_DRAW_OPAQUE, 0);
			if (layers_ctrl & 1)	tilemap_draw(bitmap,cliprect, state->m_tmap,  0, 0);
			break;
		case 0x05:	// dips: must hide fg
			if (layers_ctrl & 1)	tilemap_draw(bitmap,cliprect, state->m_tmap,  TILEMAP_DRAW_OPAQUE, 0);
			break;
		case 0x07:	// game,demo: fg over bg
		default:
			if (layers_ctrl & 1)	tilemap_draw(bitmap,cliprect, state->m_tmap,  TILEMAP_DRAW_OPAQUE, 0);
			if (layers_ctrl & 2)	tilemap_draw(bitmap,cliprect, state->m_tmap2, 0, 0);
			break;
	}

	return 0;
}
Beispiel #4
0
static VIDEO_UPDATE( drtomy )
{
	tilemap_draw(bitmap,cliprect,tilemap_bg,0,0);
	tilemap_draw(bitmap,cliprect,tilemap_fg,0,0);
	draw_sprites(screen->machine,bitmap,cliprect);
	return 0;
}
Beispiel #5
0
void cave_vh_screenrefresh(struct osd_bitmap *bitmap,int full_refresh)
{
	int pri;
	int layers_ctrl = -1;

	int	glob_flipx	=	READ_WORD(&cave_videoregs[0]) & 0x8000;
	int	glob_flipy	=	READ_WORD(&cave_videoregs[2]) & 0x8000;

	tilemap_set_flip(ALL_TILEMAPS, (glob_flipx ? TILEMAP_FLIPX : 0) | (glob_flipy ? TILEMAP_FLIPY : 0) );

	tilemap_set_enable( tilemap_0, READ_WORD(&cave_vctrl_0[4]) & 1 );
	tilemap_set_scrollx(tilemap_0, 0, READ_WORD(&cave_vctrl_0[0]) );
	tilemap_set_scrolly(tilemap_0, 0, READ_WORD(&cave_vctrl_0[2]) );

	if (tilemap_1)
	{
		tilemap_set_enable( tilemap_1, READ_WORD(&cave_vctrl_1[4]) & 1 );
		tilemap_set_scrollx(tilemap_1, 0, READ_WORD(&cave_vctrl_1[0]) );
		tilemap_set_scrolly(tilemap_1, 0, READ_WORD(&cave_vctrl_1[2]) );
	}

	if (tilemap_2)
	{
		tilemap_set_enable( tilemap_2, READ_WORD(&cave_vctrl_2[4]) & 1 );
		tilemap_set_scrollx(tilemap_2, 0, READ_WORD(&cave_vctrl_2[0]) );
		tilemap_set_scrolly(tilemap_2, 0, READ_WORD(&cave_vctrl_2[2]) );
	}

	tilemap_update(ALL_TILEMAPS);

	palette_init_used_colors();

	get_sprite_info();

	sprite_update();

	if (palette_recalc())	tilemap_mark_all_pixels_dirty(ALL_TILEMAPS);

	tilemap_render(ALL_TILEMAPS);

	/* Clear the background if at least one of layer 0's tile priorities
	   is lacking */

	if ((layers_ctrl & 0xf) != 0xf)	osd_clearbitmap(Machine->scrbitmap);

	/* Pen 0 of layer 0's tiles (any priority) goes below anything else */

	for ( pri = 0; pri < 4; pri++ )
		if ((layers_ctrl&(1<<(pri+0)))&&tilemap_0)	tilemap_draw(bitmap, tilemap_0, TILEMAP_IGNORE_TRANSPARENCY | pri);

	/* Draw the rest with transparency */

	for ( pri = 0; pri < 4; pri++ )
	{
		if ((layers_ctrl&(1<<(pri+12))))			sprite_draw(sprite_list, pri);
		if ((layers_ctrl&(1<<(pri+0)))&&tilemap_0)	tilemap_draw(bitmap, tilemap_0, pri);
		if ((layers_ctrl&(1<<(pri+4)))&&tilemap_1)	tilemap_draw(bitmap, tilemap_1, pri);
		if ((layers_ctrl&(1<<(pri+8)))&&tilemap_2)	tilemap_draw(bitmap, tilemap_2, pri);
	}
}
Beispiel #6
0
static VIDEO_UPDATE( good )
{
    good_state *state = (good_state *)screen->machine->driver_data;
    tilemap_draw(bitmap, cliprect, state->bg_tilemap, 0, 0);
    tilemap_draw(bitmap, cliprect, state->fg_tilemap, 0, 0);
    return 0;
}
Beispiel #7
0
static SCREEN_UPDATE(kingdrby)
{
	kingdrby_state *state = screen->machine().driver_data<kingdrby_state>();
	const rectangle &visarea = screen->visible_area();
	rectangle clip;
	tilemap_set_scrollx( state->m_sc0_tilemap,0, state->m_vram[0x342]);
	tilemap_set_scrolly( state->m_sc0_tilemap,0, state->m_vram[0x341]);
	tilemap_set_scrollx( state->m_sc1_tilemap,0, state->m_vram[0x342]);
	tilemap_set_scrolly( state->m_sc1_tilemap,0, state->m_vram[0x341]);
	tilemap_set_scrolly( state->m_sc0w_tilemap,0, 32);

	/* maybe it needs two window tilemaps? (one at the top, the other at the bottom)*/
	clip.min_x = visarea.min_x;
	clip.max_x = 256;
	clip.min_y = 192;
	clip.max_y = visarea.max_y;

	/*TILEMAP_DRAW_CATEGORY + TILEMAP_DRAW_OPAQUE doesn't suit well?*/
	tilemap_draw(bitmap,cliprect,state->m_sc0_tilemap,0,0);
	draw_sprites(screen->machine(),bitmap,cliprect);
	tilemap_draw(bitmap,cliprect,state->m_sc1_tilemap,TILEMAP_DRAW_CATEGORY(1),0);
	tilemap_draw(bitmap,&clip,state->m_sc0w_tilemap,0,0);

	return 0;
}
Beispiel #8
0
void stfight_vh_screenrefresh( struct osd_bitmap *bitmap,int full_refresh )
{
	tilemap_update(ALL_TILEMAPS);

	if (palette_recalc())
		tilemap_mark_all_pixels_dirty(ALL_TILEMAPS);

	tilemap_render(ALL_TILEMAPS);


	fillbitmap(priority_bitmap,0,NULL);

	if (bg_tilemap->enable)
	    tilemap_draw(bitmap,bg_tilemap,0);
	else
		fillbitmap(bitmap,Machine->pens[0],&Machine->visible_area);

	tilemap_draw(bitmap,fg_tilemap,1<<16);

	/* Draw sprites (may be obscured by foreground layer) */
	if (stfight_vh_latch_ram[0x07] & 0x40)
		draw_sprites(bitmap);

	tilemap_draw(bitmap,tx_tilemap,0);
}
Beispiel #9
0
static VIDEO_UPDATE( dunhuang )
{
	int layers_ctrl = -1;

#if DUNHUANG_DEBUG
if (input_code_pressed(KEYCODE_Z))
{
	int msk = 0;
	if (input_code_pressed(KEYCODE_Q))	msk |= 1;
	if (input_code_pressed(KEYCODE_W))	msk |= 2;
	if (msk != 0) layers_ctrl &= msk;
}
#endif

	fillbitmap(bitmap,get_black_pen(screen->machine),cliprect);

	switch (dunhuang_layers)
	{
		case 0x04:	// girl select: bg over fg
			if (layers_ctrl & 2)	tilemap_draw(bitmap,cliprect, tmap2, TILEMAP_DRAW_OPAQUE, 0);
			if (layers_ctrl & 1)	tilemap_draw(bitmap,cliprect, tmap,  0, 0);
			break;
		case 0x05:	// dips: must hide fg
			if (layers_ctrl & 1)	tilemap_draw(bitmap,cliprect, tmap,  TILEMAP_DRAW_OPAQUE, 0);
			break;
		case 0x07:	// game,demo: fg over bg
		default:
			if (layers_ctrl & 1)	tilemap_draw(bitmap,cliprect, tmap,  TILEMAP_DRAW_OPAQUE, 0);
			if (layers_ctrl & 2)	tilemap_draw(bitmap,cliprect, tmap2, 0, 0);
			break;
	}

	return 0;
}
Beispiel #10
0
static VIDEO_UPDATE( pkscramble )
{
	tilemap_draw(bitmap,cliprect,bg_tilemap,0,0);
	tilemap_draw(bitmap,cliprect,md_tilemap,0,0);
	tilemap_draw(bitmap,cliprect,fg_tilemap,0,0);
	return 0;
}
Beispiel #11
0
static SCREEN_UPDATE( good )
{
	good_state *state = screen->machine->driver_data<good_state>();
	tilemap_draw(bitmap, cliprect, state->bg_tilemap, 0, 0);
	tilemap_draw(bitmap, cliprect, state->fg_tilemap, 0, 0);
	return 0;
}
Beispiel #12
0
void raiden_vh_screenrefresh(struct osd_bitmap *bitmap,int full_refresh)
{
	int color,offs,sprite;
	int colmask[16],i,pal_base;

	/* Setup the tilemaps, alternate version has different scroll positions */
	if (!ALTERNATE) {
		tilemap_set_scrollx( background_layer,0, ((raiden_scroll_ram[1]<<8)+raiden_scroll_ram[0]) );
		tilemap_set_scrolly( background_layer,0, ((raiden_scroll_ram[3]<<8)+raiden_scroll_ram[2]) );
		tilemap_set_scrollx( foreground_layer,0, ((raiden_scroll_ram[5]<<8)+raiden_scroll_ram[4]) );
		tilemap_set_scrolly( foreground_layer,0, ((raiden_scroll_ram[7]<<8)+raiden_scroll_ram[6]) );
	}
	else {
		tilemap_set_scrolly( background_layer,0, ((raiden_scroll_ram[0x02]&0x30)<<4)+((raiden_scroll_ram[0x04]&0x7f)<<1)+((raiden_scroll_ram[0x04]&0x80)>>7) );
		tilemap_set_scrollx( background_layer,0, ((raiden_scroll_ram[0x12]&0x30)<<4)+((raiden_scroll_ram[0x14]&0x7f)<<1)+((raiden_scroll_ram[0x14]&0x80)>>7) );
		tilemap_set_scrolly( foreground_layer,0, ((raiden_scroll_ram[0x22]&0x30)<<4)+((raiden_scroll_ram[0x24]&0x7f)<<1)+((raiden_scroll_ram[0x24]&0x80)>>7) );
		tilemap_set_scrollx( foreground_layer,0, ((raiden_scroll_ram[0x32]&0x30)<<4)+((raiden_scroll_ram[0x34]&0x7f)<<1)+((raiden_scroll_ram[0x34]&0x80)>>7) );
	}

	tilemap_update(ALL_TILEMAPS);

	/* Build the dynamic palette */
	palette_init_used_colors();

	/* Sprites */
	pal_base = Machine->drv->gfxdecodeinfo[3].color_codes_start;
	for (color = 0;color < 16;color++) colmask[color] = 0;
	for (offs = 0;offs <0x1000;offs += 8)
	{
		color = buffered_spriteram[offs+1]&0xf;
		sprite = buffered_spriteram[offs+2]+(buffered_spriteram[offs+3]<<8);
		sprite &= 0x0fff;
		colmask[color] |= Machine->gfx[3]->pen_usage[sprite];
	}
	for (color = 0;color < 16;color++)
	{
		for (i = 0;i < 15;i++)
		{
			if (colmask[color] & (1 << i))
				palette_used_colors[pal_base + 16 * color + i] = PALETTE_COLOR_USED;
		}
	}

	if (palette_recalc())
		tilemap_mark_all_pixels_dirty(ALL_TILEMAPS);

	tilemap_render(ALL_TILEMAPS);
	tilemap_draw(bitmap,background_layer,0);

	/* Draw sprites underneath foreground */
	draw_sprites(bitmap,0x40);
	tilemap_draw(bitmap,foreground_layer,0);

	/* Rest of sprites */
	draw_sprites(bitmap,0x80);

	/* Text layer */
	tilemap_draw(bitmap,text_layer,0);
}
static VIDEO_UPDATE(mil4000)
{
    tilemap_draw(bitmap,cliprect,sc0_tilemap,0,0);
    tilemap_draw(bitmap,cliprect,sc1_tilemap,0,0);
    tilemap_draw(bitmap,cliprect,sc2_tilemap,0,0);
    tilemap_draw(bitmap,cliprect,sc3_tilemap,0,0);
    return 0;
}
Beispiel #14
0
static SCREEN_UPDATE(dacholer)
{
	dacholer_state *state = screen->machine().driver_data<dacholer_state>();
	tilemap_draw(bitmap, cliprect, state->m_bg_tilemap, 0, 0);
	tilemap_draw(bitmap, cliprect, state->m_fg_tilemap, 0, 0);
	draw_sprites(screen->machine(), bitmap, cliprect);
	return 0;
}
Beispiel #15
0
static VIDEO_UPDATE(dacholer)
{
	dacholer_state *state = (dacholer_state *)screen->machine->driver_data;
	tilemap_draw(bitmap, cliprect, state->bg_tilemap, 0, 0);
	tilemap_draw(bitmap, cliprect, state->fg_tilemap, 0, 0);
	draw_sprites(screen->machine, bitmap, cliprect);
	return 0;
}
Beispiel #16
0
static VIDEO_UPDATE( dynadice )
{
	rectangle myclip=*cliprect;
	myclip.max_x=15;
	tilemap_draw(bitmap,cliprect,bg_tilemap,0,0);
	tilemap_draw(bitmap,&myclip,top_tilemap,0,0);
	return 0;
}
static SCREEN_UPDATE(mil4000)
{
	mil4000_state *state = screen->machine().driver_data<mil4000_state>();
	tilemap_draw(bitmap,cliprect,state->m_sc0_tilemap,0,0);
	tilemap_draw(bitmap,cliprect,state->m_sc1_tilemap,0,0);
	tilemap_draw(bitmap,cliprect,state->m_sc2_tilemap,0,0);
	tilemap_draw(bitmap,cliprect,state->m_sc3_tilemap,0,0);
	return 0;
}
Beispiel #18
0
static VIDEO_UPDATE( drtomy )
{
	drtomy_state *state = screen->machine->driver_data<drtomy_state>();

	tilemap_draw(bitmap, cliprect, state->tilemap_bg, 0, 0);
	tilemap_draw(bitmap, cliprect, state->tilemap_fg, 0, 0);
	draw_sprites(screen->machine, bitmap, cliprect);
	return 0;
}
Beispiel #19
0
static VIDEO_UPDATE( chanbara )
{
	chanbara_state *state = screen->machine->driver_data<chanbara_state>();

	tilemap_set_scrolly(state->bg2_tilemap, 0, state->scroll | (state->scrollhi << 8));
	tilemap_draw(bitmap, cliprect, state->bg2_tilemap, 0, 0);
	draw_sprites(screen->machine, bitmap, cliprect);
	tilemap_draw(bitmap, cliprect, state->bg_tilemap, 0, 0);
	return 0;
}
Beispiel #20
0
static VIDEO_UPDATE(cabaret)
{
	bitmap_fill(bitmap, cliprect, get_black_pen(screen->machine));

	tilemap_draw(bitmap, cliprect, bg_tilemap, 0, 0);

	tilemap_draw(bitmap, cliprect, fg_tilemap, 0, 0);

	return 0;
}
Beispiel #21
0
bool zodiack_state::screen_update( screen_device &screen, bitmap_t &bitmap, const rectangle &cliprect )
{
	for (int i = 0; i < 32; i++)
		tilemap_set_scrolly(m_fg_tilemap, i, m_attributeram[i * 2]);

	tilemap_draw(&bitmap, &cliprect, m_bg_tilemap, 0, 0);
	tilemap_draw(&bitmap, &cliprect, m_fg_tilemap, 0, 0);
	draw_bullets(&bitmap, &cliprect);
	draw_sprites(&bitmap, &cliprect);
	return 0;
}
Beispiel #22
0
static SCREEN_UPDATE(cabaret)
{
	cabaret_state *state = screen->machine().driver_data<cabaret_state>();
	bitmap_fill(bitmap, cliprect, get_black_pen(screen->machine()));

	tilemap_draw(bitmap, cliprect, state->m_bg_tilemap, 0, 0);

	tilemap_draw(bitmap, cliprect, state->m_fg_tilemap, 0, 0);

	return 0;
}
Beispiel #23
0
static VIDEO_UPDATE( panicr)
{
    bitmap_fill(bitmap,cliprect,get_black_pen(screen->machine));
    tilemap_mark_all_tiles_dirty( txttilemap );
    tilemap_set_scrollx( bgtilemap,0, ((scrollram[0x02]&0x0f)<<12)+((scrollram[0x02]&0xf0)<<4)+((scrollram[0x04]&0x7f)<<1)+((scrollram[0x04]&0x80)>>7) );
    tilemap_draw(bitmap,cliprect,bgtilemap,0,0);
    draw_sprites(screen->machine,bitmap,cliprect);
    tilemap_draw(bitmap,cliprect,txttilemap,0,0);

    return 0;
}
Beispiel #24
0
static SCREEN_UPDATE( panicr)
{
    panicr_state *state = screen->machine().driver_data<panicr_state>();
    bitmap_fill(bitmap,cliprect,get_black_pen(screen->machine()));
    tilemap_mark_all_tiles_dirty( state->m_txttilemap );
    tilemap_set_scrollx( state->m_bgtilemap,0, ((state->m_scrollram[0x02]&0x0f)<<12)+((state->m_scrollram[0x02]&0xf0)<<4)+((state->m_scrollram[0x04]&0x7f)<<1)+((state->m_scrollram[0x04]&0x80)>>7) );
    tilemap_draw(bitmap,cliprect,state->m_bgtilemap,0,0);
    draw_sprites(screen->machine(),bitmap,cliprect);
    tilemap_draw(bitmap,cliprect,state->m_txttilemap,0,0);

    return 0;
}
Beispiel #25
0
static SCREEN_UPDATE( calorie )
{
	calorie_state *state = screen->machine().driver_data<calorie_state>();
	int x;

	if (state->m_bg_bank & 0x10)
	{
		tilemap_draw(bitmap, cliprect, state->m_bg_tilemap, 0, 0);
		tilemap_draw(bitmap, cliprect, state->m_fg_tilemap, 0, 0);
	}
	else
	{
		tilemap_draw(bitmap, cliprect, state->m_fg_tilemap, TILEMAP_DRAW_OPAQUE, 0);
	}


	for (x = 0x400; x >= 0; x -= 4)
	{
		int xpos, ypos, tileno, color, flipx, flipy;

		tileno = state->m_sprites[x + 0];
		color = state->m_sprites[x + 1] & 0x0f;
		flipx = state->m_sprites[x + 1] & 0x40;
		flipy = 0;
		ypos = 0xff - state->m_sprites[x + 2];
		xpos = state->m_sprites[x + 3];

		if (flip_screen_get(screen->machine()))
		{
			if (state->m_sprites[x + 1] & 0x10)
				ypos = 0xff - ypos + 32;
			else
				ypos = 0xff - ypos + 16;

			xpos = 0xff - xpos - 16;
			flipx = !flipx;
			flipy = !flipy;
		}

		if (state->m_sprites[x + 1] & 0x10)
		{
			 /* 32x32 sprites */
			drawgfx_transpen(bitmap, cliprect, screen->machine().gfx[3], tileno | 0x40, color, flipx, flipy, xpos, ypos - 31, 0);
		}
		else
		{
			/* 16x16 sprites */
			drawgfx_transpen(bitmap, cliprect, screen->machine().gfx[2], tileno, color, flipx, flipy, xpos, ypos - 15, 0);
		}
	}
	return 0;
}
Beispiel #26
0
void gundealr_vh_screenrefresh(struct osd_bitmap *bitmap,int full_refresh)
{
	tilemap_update(ALL_TILEMAPS);

	palette_init_used_colors();
	if (palette_recalc())
		tilemap_mark_all_pixels_dirty(ALL_TILEMAPS);

	tilemap_render(ALL_TILEMAPS);

	tilemap_draw(bitmap,bg_tilemap,0);
	tilemap_draw(bitmap,fg_tilemap,0);
}
Beispiel #27
0
static VIDEO_UPDATE( calorie )
{
	int x;

	if (calorie_bg & 0x10)
	{
		tilemap_draw(bitmap,cliprect,bg_tilemap,0,0);
		tilemap_draw(bitmap,cliprect,fg_tilemap,0,0);
	}
	else
	{
		tilemap_draw(bitmap,cliprect,fg_tilemap,TILEMAP_DRAW_OPAQUE,0);
	}


	for (x = 0x400; x >= 0; x -= 4)
	{
		int xpos, ypos, tileno, color, flipx, flipy;

		tileno = calorie_sprites[x+0];
		color = calorie_sprites[x+1] & 0x0f;
		flipx = calorie_sprites[x+1] & 0x40;
		flipy = 0;
		ypos = 0xff - calorie_sprites[x+2];
		xpos = calorie_sprites[x+3];

		if(flip_screen_get(screen->machine))
		{
			if( calorie_sprites[x+1] & 0x10 )
				ypos = 0xff - ypos + 32;
			else
				ypos = 0xff - ypos + 16;

			xpos = 0xff - xpos - 16;
			flipx = !flipx;
			flipy = !flipy;
		}

		if( calorie_sprites[x+1] & 0x10 )
		{
			 /* 32x32 sprites */
			drawgfx_transpen(bitmap,cliprect,screen->machine->gfx[3],tileno | 0x40,color,flipx,flipy,xpos,ypos - 31,0);
		}
		else
		{
			/* 16x16 sprites */
			drawgfx_transpen(bitmap,cliprect,screen->machine->gfx[2],tileno,color,flipx,flipy,xpos,ypos - 15,0);
		}
	}
	return 0;
}
Beispiel #28
0
void maniacsq_vh_screenrefresh(struct osd_bitmap *bitmap,int full_refresh)
{
	/* set scroll registers */
	tilemap_set_scrolly(pant[0], 0, READ_WORD(&gaelco_vregs[0]));
	tilemap_set_scrollx(pant[0], 0, READ_WORD(&gaelco_vregs[2])+4);
	tilemap_set_scrolly(pant[1], 0, READ_WORD(&gaelco_vregs[4]));
	tilemap_set_scrollx(pant[1], 0, READ_WORD(&gaelco_vregs[6]));

	tilemap_update(ALL_TILEMAPS);
	gaelco_sort_sprites();

	if (palette_recalc())
		tilemap_mark_all_pixels_dirty(ALL_TILEMAPS);

	tilemap_render(ALL_TILEMAPS);


	fillbitmap( bitmap, Machine->pens[0], &Machine->visible_area );

	tilemap_draw(bitmap,pant[1],3);
	tilemap_draw(bitmap,pant[0],3);
	gaelco_draw_sprites(bitmap,3);

	tilemap_draw(bitmap,pant[1],2);
	tilemap_draw(bitmap,pant[0],2);
	gaelco_draw_sprites(bitmap,2);

	tilemap_draw(bitmap,pant[1],1);
	tilemap_draw(bitmap,pant[0],1);
	gaelco_draw_sprites(bitmap,1);

	tilemap_draw(bitmap,pant[1],0);
	tilemap_draw(bitmap,pant[0],0);
	gaelco_draw_sprites(bitmap,0);
}
Beispiel #29
0
void maniacsq_vh_screenrefresh(struct osd_bitmap *bitmap,int full_refresh)
{
	/* set scroll registers */
	tilemap_set_scrolly(pant[0], 0, gaelco_vregs[0]);
	tilemap_set_scrollx(pant[0], 0, gaelco_vregs[1]+4);
	tilemap_set_scrolly(pant[1], 0, gaelco_vregs[2]);
	tilemap_set_scrollx(pant[1], 0, gaelco_vregs[3]);

	tilemap_update(ALL_TILEMAPS);
	gaelco_sort_sprites();

	palette_recalc();


	fillbitmap( bitmap, Machine->pens[0], &Machine->visible_area );

	tilemap_draw(bitmap,pant[1],3,0);
	tilemap_draw(bitmap,pant[0],3,0);
	gaelco_draw_sprites(bitmap,3);

	tilemap_draw(bitmap,pant[1],2,0);
	tilemap_draw(bitmap,pant[0],2,0);
	gaelco_draw_sprites(bitmap,2);

	tilemap_draw(bitmap,pant[1],1,0);
	tilemap_draw(bitmap,pant[0],1,0);
	gaelco_draw_sprites(bitmap,1);

	tilemap_draw(bitmap,pant[1],0,0);
	tilemap_draw(bitmap,pant[0],0,0);
	gaelco_draw_sprites(bitmap,0);
}
Beispiel #30
0
static VIDEO_UPDATE(bestleag)
{
	tilemap_set_scrollx(bg_tilemap,0,(bestleag_vregs[0x00/2] & 0xfff) + (bestleag_vregs[0x08/2] & 0x7) - 3);
	tilemap_set_scrolly(bg_tilemap,0,bestleag_vregs[0x02/2]);
	tilemap_set_scrollx(tx_tilemap,0,bestleag_vregs[0x04/2]);
	tilemap_set_scrolly(tx_tilemap,0,bestleag_vregs[0x06/2]);
	tilemap_set_scrollx(fg_tilemap,0,bestleag_vregs[0x08/2] & 0xfff8);
	tilemap_set_scrolly(fg_tilemap,0,bestleag_vregs[0x0a/2]);

	tilemap_draw(bitmap,cliprect,bg_tilemap,0,0);
	tilemap_draw(bitmap,cliprect,fg_tilemap,0,0);
	draw_sprites(screen->machine,bitmap,cliprect);
	tilemap_draw(bitmap,cliprect,tx_tilemap,0,0);
	return 0;
}