Sprinter/mame
2
0
Fork 0
mirror of https://github.com/holub/mame synced 2025-05-20 12:48:53 +03:00
Code Issues Actions Packages Projects Releases Wiki Activity

Fixed regressed flip screen support in Toaplan 2 games [David Haywood]

Browse Source
This commit is contained in:
Angelo Salese 2011-01-19 14:50:53 +00:00
parent 613213c894
commit 1a1ae4e415
3 changed files with 179 additions and 249 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

381
src/mame/video/gp9001.c
View File

@ -152,40 +152,40 @@ Pipi & Bibis | Fix Eight | V-Five | Snow Bros. 2 |
#define GP9001_PRIMASK (0x000e)
static WRITE16_DEVICE_HANDLER( gp9001_bg_tilemap_w )
static WRITE16_DEVICE_HANDLER( gp9001_bg_tmap_w )
{
gp9001vdp_device *vdp = (gp9001vdp_device*)device;
COMBINE_DATA(&vdp->bgvideoram16[offset]);
tilemap_mark_tile_dirty(vdp->bg_tilemap,offset/2);
tilemap_mark_tile_dirty(vdp->bg.tmap,offset/2);
}
static WRITE16_DEVICE_HANDLER( gp9001_fg_tilemap_w )
static WRITE16_DEVICE_HANDLER( gp9001_fg_tmap_w )
{
gp9001vdp_device *vdp = (gp9001vdp_device*)device;
COMBINE_DATA(&vdp->fgvideoram16[offset]);
tilemap_mark_tile_dirty(vdp->fg_tilemap,offset/2);
tilemap_mark_tile_dirty(vdp->fg.tmap,offset/2);
}
static WRITE16_DEVICE_HANDLER( gp9001_top_tilemap_w )
static WRITE16_DEVICE_HANDLER( gp9001_top_tmap_w )
{
gp9001vdp_device *vdp = (gp9001vdp_device*)device;
COMBINE_DATA(&vdp->topvideoram16[offset]);
tilemap_mark_tile_dirty(vdp->top_tilemap,offset/2);
tilemap_mark_tile_dirty(vdp->top.tmap,offset/2);
}
static READ16_DEVICE_HANDLER( gp9001_bg_tilemap_r )
static READ16_DEVICE_HANDLER( gp9001_bg_tmap_r )
{
gp9001vdp_device *vdp = (gp9001vdp_device*)device;
return vdp->bgvideoram16[offset];
}
static READ16_DEVICE_HANDLER( gp9001_fg_tilemap_r )
static READ16_DEVICE_HANDLER( gp9001_fg_tmap_r )
{
gp9001vdp_device *vdp = (gp9001vdp_device*)device;
return vdp->fgvideoram16[offset];
}
static READ16_DEVICE_HANDLER( gp9001_top_tilemap_r )
static READ16_DEVICE_HANDLER( gp9001_top_tmap_r )
{
gp9001vdp_device *vdp = (gp9001vdp_device*)device;
return vdp->topvideoram16[offset];
@ -204,9 +204,9 @@ static WRITE16_DEVICE_HANDLER( gp9001_spram_w )
}
static ADDRESS_MAP_START( gp9001vdp_map, 0, 16 )
AM_RANGE(0x0000, 0x0fff) AM_DEVREADWRITE(DEVICE_SELF, gp9001_bg_tilemap_r, gp9001_bg_tilemap_w)
AM_RANGE(0x1000, 0x1fff) AM_DEVREADWRITE(DEVICE_SELF, gp9001_fg_tilemap_r, gp9001_fg_tilemap_w)
AM_RANGE(0x2000, 0x2fff) AM_DEVREADWRITE(DEVICE_SELF, gp9001_top_tilemap_r, gp9001_top_tilemap_w)
AM_RANGE(0x0000, 0x0fff) AM_DEVREADWRITE(DEVICE_SELF, gp9001_bg_tmap_r, gp9001_bg_tmap_w)
AM_RANGE(0x1000, 0x1fff) AM_DEVREADWRITE(DEVICE_SELF, gp9001_fg_tmap_r, gp9001_fg_tmap_w)
AM_RANGE(0x2000, 0x2fff) AM_DEVREADWRITE(DEVICE_SELF, gp9001_top_tmap_r, gp9001_top_tmap_w)
AM_RANGE(0x3000, 0x37ff) AM_DEVREADWRITE(DEVICE_SELF, gp9001_spram_r, gp9001_spram_w)
AM_RANGE(0x3800, 0x3fff) AM_RAM // sprite mirror?
ADDRESS_MAP_END
@ -335,13 +335,13 @@ void gp9001vdp_device::create_tilemaps(int region)
{
tile_region = region;
top_tilemap = tilemap_create_device(this, get_top0_tile_info,tilemap_scan_rows,16,16,32,32);
fg_tilemap = tilemap_create_device(this, get_fg0_tile_info,tilemap_scan_rows,16,16,32,32);
bg_tilemap = tilemap_create_device(this, get_bg0_tile_info,tilemap_scan_rows,16,16,32,32);
top.tmap = tilemap_create_device(this, get_top0_tile_info,tilemap_scan_rows,16,16,32,32);
fg.tmap = tilemap_create_device(this, get_fg0_tile_info,tilemap_scan_rows,16,16,32,32);
bg.tmap = tilemap_create_device(this, get_bg0_tile_info,tilemap_scan_rows,16,16,32,32);
tilemap_set_transparent_pen(top_tilemap,0);
tilemap_set_transparent_pen(fg_tilemap,0);
tilemap_set_transparent_pen(bg_tilemap,0);
tilemap_set_transparent_pen(top.tmap,0);
tilemap_set_transparent_pen(fg.tmap,0);
tilemap_set_transparent_pen(bg.tmap,0);
}
@ -366,46 +366,46 @@ void gp9001vdp_device::device_start()
state_save_register_device_item(this,0, gp9001_scroll_reg);
state_save_register_device_item(this,0, gp9001_voffs);
state_save_register_device_item(this,0, bg_scrollx);
state_save_register_device_item(this,0, bg_scrolly);
state_save_register_device_item(this,0, fg_scrollx);
state_save_register_device_item(this,0, fg_scrolly);
state_save_register_device_item(this,0, top_scrollx);
state_save_register_device_item(this,0, top_scrolly);
state_save_register_device_item(this,0, bg.scrollx);
state_save_register_device_item(this,0, bg.scrolly);
state_save_register_device_item(this,0, fg.scrollx);
state_save_register_device_item(this,0, fg.scrolly);
state_save_register_device_item(this,0, top.scrollx);
state_save_register_device_item(this,0, top.scrolly);
state_save_register_device_item(this,0, sprite_scrollx);
state_save_register_device_item(this,0, sprite_scrolly);
state_save_register_device_item(this,0, bg_flip);
state_save_register_device_item(this,0, fg_flip);
state_save_register_device_item(this,0, top_flip);
state_save_register_device_item(this,0, bg.flip);
state_save_register_device_item(this,0, fg.flip);
state_save_register_device_item(this,0, top.flip);
state_save_register_device_item(this,0, sprite_flip);
gp9001_gfxrom_is_banked = 0;
gp9001_gfxrom_bank_dirty = 0;
state_save_register_device_item_array(this,0,gp9001_gfxrom_bank);
extra_xoffset[0]=0;
extra_xoffset[1]=0;
extra_xoffset[2]=0;
extra_xoffset[3]=0;
bg.extra_xoffset=0;
fg.extra_xoffset=0;
top.extra_xoffset=0;
sp_extra_xoffset=0;
extra_yoffset[0]=0;
extra_yoffset[1]=0;
extra_yoffset[2]=0;
extra_yoffset[3]=0;
bg.extra_yoffset=0;
fg.extra_yoffset=0;
top.extra_yoffset=0;
sp_extra_yoffset=0;
}
void gp9001vdp_device::device_reset()
{
gp9001_voffs = 0;
gp9001_scroll_reg = 0;
bg_scrollx = bg_scrolly = 0;
fg_scrollx = fg_scrolly = 0;
top_scrollx = top_scrolly = 0;
bg.scrollx = bg.scrolly = 0;
fg.scrollx = fg.scrolly = 0;
top.scrollx = top.scrolly = 0;
sprite_scrollx = sprite_scrolly = 0;
bg_flip = 0;
fg_flip = 0;
top_flip = 0;
bg.flip = 0;
fg.flip = 0;
top.flip = 0;
sprite_flip = 0;
/* debug */
@ -478,6 +478,46 @@ static WRITE16_DEVICE_HANDLER( gp9001_scroll_reg_select_w )
}
}
static void gp9001_set_scrollx_reg(gp9001layer* layer, UINT16 data, UINT16 mem_mask, int xoffs_flip, int xoffs_normal, int flip)
{
COMBINE_DATA(&layer->scrollx);
if (flip)
{
layer->flip |= TILEMAP_FLIPX;
layer->scrollx -= xoffs_flip;
tilemap_set_scrollx(layer->tmap,0,-(layer->scrollx+layer->extra_xoffset));
}
else
{
layer->flip &= (~TILEMAP_FLIPX);
layer->scrollx -= xoffs_normal;
tilemap_set_scrollx(layer->tmap,0,layer->scrollx+layer->extra_xoffset);
}
tilemap_set_flip(layer->tmap,layer->flip);
}
static void gp9001_set_scrolly_reg(gp9001layer* layer, UINT16 data, UINT16 mem_mask, int yoffs_flip, int yoffs_normal, int flip)
{
COMBINE_DATA(&layer->scrolly);
if (flip)
{
layer->flip |= TILEMAP_FLIPY;
layer->scrolly -= yoffs_flip;
tilemap_set_scrolly(layer->tmap,0,-(layer->scrolly+layer->extra_yoffset));
}
else
{
layer->flip &= (~TILEMAP_FLIPY);
layer->scrolly -= yoffs_normal;
tilemap_set_scrolly(layer->tmap,0,layer->scrolly+layer->extra_yoffset);
}
tilemap_set_flip(layer->tmap,layer->flip);
}
static void gp9001_scroll_reg_data_w(gp9001vdp_device *vdp, offs_t offset, UINT16 data, UINT16 mem_mask)
{
@ -486,108 +526,61 @@ static void gp9001_scroll_reg_data_w(gp9001vdp_device *vdp, offs_t offset, UINT1
/************************************************************************/
//printf("gp9001_scroll_reg_data_w %04x %04x\n", offset, data);
// writes with 8x set turn on flip for the specified layer / axis
int flip = vdp->gp9001_scroll_reg & 0x80;
switch(vdp->gp9001_scroll_reg)
switch(vdp->gp9001_scroll_reg&0x7f)
{
case 0x00: data -= 0x1d6; /* 1D6h */
COMBINE_DATA(&vdp->bg_scrollx);
vdp->bg_flip &= (~TILEMAP_FLIPX);
tilemap_set_flip(vdp->bg_tilemap,vdp->bg_flip);
tilemap_set_scrollx(vdp->bg_tilemap,0,vdp->bg_scrollx+vdp->extra_xoffset[0]);
case 0x00: gp9001_set_scrollx_reg(&vdp->bg, data, mem_mask, 0x229, 0x1d6, flip); break;
case 0x01: gp9001_set_scrolly_reg(&vdp->bg, data, mem_mask, 0x210, 0x1ef, flip); break;
case 0x02: gp9001_set_scrollx_reg(&vdp->fg, data, mem_mask, 0x227, 0x1d8, flip); break;
case 0x03: gp9001_set_scrolly_reg(&vdp->fg, data, mem_mask, 0x210, 0x1ef, flip); break;
case 0x04: gp9001_set_scrollx_reg(&vdp->top,data, mem_mask, 0x225, 0x1da, flip); break;
case 0x05: gp9001_set_scrolly_reg(&vdp->top,data, mem_mask, 0x210, 0x1ef, flip); break;
case 0x06:
if (flip)
{
data -= 0x17b;
COMBINE_DATA(&vdp->sprite_scrollx);
if (vdp->sprite_scrollx & 0x8000) vdp->sprite_scrollx |= 0xfffffe00;
else vdp->sprite_scrollx &= 0x1ff;
vdp->sprite_flip |= GP9001_SPRITE_FLIPX;
}
else
{
data -= 0x1cc;
COMBINE_DATA(&vdp->sprite_scrollx);
if (vdp->sprite_scrollx & 0x8000) vdp->sprite_scrollx |= 0xfffffe00;
else vdp->sprite_scrollx &= 0x1ff;
vdp->sprite_flip &= (~GP9001_SPRITE_FLIPX);
}
break;
case 0x01: data -= 0x1ef; /* 1EFh */
COMBINE_DATA(&vdp->bg_scrolly);
vdp->bg_flip &= (~TILEMAP_FLIPY);
tilemap_set_flip(vdp->bg_tilemap,vdp->bg_flip);
tilemap_set_scrolly(vdp->bg_tilemap,0,vdp->bg_scrolly+vdp->extra_yoffset[0]);
case 0x07:
if (flip)
{
data -= 0x108; /* 108h */
COMBINE_DATA(&vdp->sprite_scrolly);
if (vdp->sprite_scrolly & 0x8000) vdp->sprite_scrolly |= 0xfffffe00;
else vdp->sprite_scrolly &= 0x1ff;
vdp->sprite_flip |= GP9001_SPRITE_FLIPY;
}
else
{
data -= 0x1ef; /* 1F7h */
COMBINE_DATA(&vdp->sprite_scrolly);
if (vdp->sprite_scrolly & 0x8000) vdp->sprite_scrolly |= 0xfffffe00;
else vdp->sprite_scrolly &= 0x1ff;
vdp->sprite_flip &= (~GP9001_SPRITE_FLIPY);
}
break;
case 0x02: data -= 0x1d8; /* 1D0h */
COMBINE_DATA(&vdp->fg_scrollx);
vdp->fg_flip &= (~TILEMAP_FLIPX);
tilemap_set_flip(vdp->fg_tilemap,vdp->fg_flip);
tilemap_set_scrollx(vdp->fg_tilemap,0,vdp->fg_scrollx+vdp->extra_xoffset[1]);
break;
case 0x03: data -= 0x1ef; /* 1EFh */
COMBINE_DATA(&vdp->fg_scrolly);
vdp->fg_flip &= (~TILEMAP_FLIPY);
tilemap_set_flip(vdp->fg_tilemap,vdp->fg_flip);
tilemap_set_scrolly(vdp->fg_tilemap,0,vdp->fg_scrolly+vdp->extra_yoffset[1]);
break;
case 0x04: data -= 0x1da; /* 1DAh */
COMBINE_DATA(&vdp->top_scrollx);
vdp->top_flip &= (~TILEMAP_FLIPX);
tilemap_set_flip(vdp->top_tilemap,vdp->top_flip);
tilemap_set_scrollx(vdp->top_tilemap,0,vdp->top_scrollx+vdp->extra_xoffset[2]);
break;
case 0x05: data -= 0x1ef; /* 1EFh */
COMBINE_DATA(&vdp->top_scrolly);
vdp->top_flip &= (~TILEMAP_FLIPY);
tilemap_set_flip(vdp->top_tilemap,vdp->top_flip);
tilemap_set_scrolly(vdp->top_tilemap,0,vdp->top_scrolly+vdp->extra_yoffset[2]);
break;
case 0x06: data -= 0x1cc; /* 1D4h */
COMBINE_DATA(&vdp->sprite_scrollx);
if (vdp->sprite_scrollx & 0x8000) vdp->sprite_scrollx |= 0xfffffe00;
else vdp->sprite_scrollx &= 0x1ff;
vdp->sprite_flip &= (~GP9001_SPRITE_FLIPX);
break;
case 0x07: data -= 0x1ef; /* 1F7h */
COMBINE_DATA(&vdp->sprite_scrolly);
if (vdp->sprite_scrolly & 0x8000) vdp->sprite_scrolly |= 0xfffffe00;
else vdp->sprite_scrolly &= 0x1ff;
vdp->sprite_flip &= (~GP9001_SPRITE_FLIPY);
break;
case 0x0f: break;
case 0x80: data -= 0x229; /* 169h */
COMBINE_DATA(&vdp->bg_scrollx);
vdp->bg_flip |= TILEMAP_FLIPX;
tilemap_set_flip(vdp->bg_tilemap,vdp->bg_flip);
tilemap_set_scrollx(vdp->bg_tilemap,0,vdp->bg_scrollx+vdp->extra_xoffset[0]);
break;
case 0x81: data -= 0x210; /* 100h */
COMBINE_DATA(&vdp->bg_scrolly);
vdp->bg_flip |= TILEMAP_FLIPY;
tilemap_set_flip(vdp->bg_tilemap,vdp->bg_flip);
tilemap_set_scrolly(vdp->bg_tilemap,0,vdp->bg_scrolly+vdp->extra_yoffset[0]);
break;
case 0x82: data -= 0x227; /* 15Fh */
COMBINE_DATA(&vdp->fg_scrollx);
vdp->fg_flip |= TILEMAP_FLIPX;
tilemap_set_flip(vdp->fg_tilemap,vdp->fg_flip);
tilemap_set_scrollx(vdp->fg_tilemap,0,vdp->fg_scrollx+vdp->extra_xoffset[1]);
break;
case 0x83: data -= 0x210; /* 100h */
COMBINE_DATA(&vdp->fg_scrolly);
vdp->fg_flip |= TILEMAP_FLIPY;
tilemap_set_flip(vdp->fg_tilemap,vdp->fg_flip);
tilemap_set_scrolly(vdp->fg_tilemap,0,vdp->fg_scrolly+vdp->extra_yoffset[1]);
break;
case 0x84: data -= 0x225; /* 165h */
COMBINE_DATA(&vdp->top_scrollx);
vdp->top_flip |= TILEMAP_FLIPX;
tilemap_set_flip(vdp->top_tilemap,vdp->top_flip);
tilemap_set_scrollx(vdp->top_tilemap,0,vdp->top_scrollx+vdp->extra_xoffset[2]);
break;
case 0x85: data -= 0x210; /* 100h */
COMBINE_DATA(&vdp->top_scrolly);
vdp->top_flip |= TILEMAP_FLIPY;
tilemap_set_flip(vdp->top_tilemap,vdp->top_flip);
tilemap_set_scrolly(vdp->top_tilemap,0,vdp->top_scrolly+vdp->extra_yoffset[2]);
break;
case 0x86: data -= 0x17b; /* 17Bh */
COMBINE_DATA(&vdp->sprite_scrollx);
if (vdp->sprite_scrollx & 0x8000) vdp->sprite_scrollx |= 0xfffffe00;
else vdp->sprite_scrollx &= 0x1ff;
vdp->sprite_flip |= GP9001_SPRITE_FLIPX;
break;
case 0x87: data -= 0x108; /* 108h */
COMBINE_DATA(&vdp->sprite_scrolly);
if (vdp->sprite_scrolly & 0x8000) vdp->sprite_scrolly |= 0xfffffe00;
else vdp->sprite_scrolly &= 0x1ff;
vdp->sprite_flip |= GP9001_SPRITE_FLIPY;
break;
case 0x8f: break;
case 0x0e: /******* Initialise video controller register ? *******/
#if 0 // do we know this works on real hw?
@ -604,78 +597,12 @@ static void gp9001_scroll_reg_data_w(gp9001vdp_device *vdp, offs_t offset, UINT1
}
#endif
case 0x0f: break;
default: logerror("Hmmm, writing %08x to unknown video control register (%08x) Video controller %01x !!!\n",data ,vdp->gp9001_scroll_reg,vdp->tile_region>>1);
break;
}
// enable / disable layer debug keys (broken at the moment)
#ifdef MAME_DEBUG
// 1st vdp
if (vdp->tile_region == 0)
{
/* this is non-vdp
if ( input_code_pressed_once(vdp->machine, KEYCODE_W) )
{
display_tx += 1;
display_tx &= 1;
if (gp9001_txvideoram16 != 0)
tilemap_set_enable(tx_tilemap, display_tx);
}
*/
if ( input_code_pressed_once(vdp->machine, KEYCODE_L) )
{
vdp->display_sp += 1;
vdp->display_sp &= 1;
}
if ( input_code_pressed_once(vdp->machine, KEYCODE_K) )
{
vdp->display_top += 1;
vdp->display_top &= 1;
tilemap_set_enable(vdp->top_tilemap, vdp->display_top);
}
if ( input_code_pressed_once(vdp->machine, KEYCODE_J) )
{
vdp->display_fg += 1;
vdp->display_fg &= 1;
tilemap_set_enable(vdp->fg_tilemap, vdp->display_fg);
}
if ( input_code_pressed_once(vdp->machine, KEYCODE_H) )
{
vdp->display_bg += 1;
vdp->display_bg &= 1;
tilemap_set_enable(vdp->bg_tilemap, vdp->display_bg);
}
}
// 2nd vdp
if (vdp->tile_region == 2)
{
if ( input_code_pressed_once(vdp->machine, KEYCODE_O) )
{
vdp->display_sp += 1;
vdp->display_sp &= 1;
}
if ( input_code_pressed_once(vdp->machine, KEYCODE_I) )
{
vdp->display_top += 1;
vdp->display_top &= 1;
tilemap_set_enable(vdp->top_tilemap, vdp->display_top);
}
if ( input_code_pressed_once(vdp->machine, KEYCODE_U) )
{
vdp->display_fg += 1;
vdp->display_fg &= 1;
tilemap_set_enable(vdp->fg_tilemap, vdp->display_fg);
}
if ( input_code_pressed_once(vdp->machine, KEYCODE_Y) )
{
vdp->display_bg += 1;
vdp->display_bg &= 1;
tilemap_set_enable(vdp->bg_tilemap, vdp->display_bg);
}
}
#endif
}
static WRITE16_DEVICE_HANDLER( gp9001_scroll_reg_devvdata_w )
@ -862,7 +789,7 @@ void gp9001_log_vram(gp9001vdp_device* vdp, running_machine *machine)
{
source_now0 = (UINT16 *)(vdp->spriteram16_now);
source_new0 = (UINT16 *)(vdp->spriteram16_new);
logerror("---0--> %04x %04x %04x %04x %04x %04x %04x %04x\n", vdp->bg_scrollx,vdp->bg_scrolly,vdp->fg_scrollx,vdp->fg_scrolly,vdp->top_scrollx,vdp->top_scrolly,vdp->sprite_scrollx, vdp->sprite_scrolly);
logerror("---0--> %04x %04x %04x %04x %04x %04x %04x %04x\n", vdp->bg.scrollx,vdp->bg.scrolly,vdp->fg.scrollx,vdp->fg.scrolly,vdp->top.scrollx,vdp->top.scrolly,vdp->sprite_scrollx, vdp->sprite_scrolly);
}
if (vdp->tile_region == 2)
@ -871,7 +798,7 @@ void gp9001_log_vram(gp9001vdp_device* vdp, running_machine *machine)
source_new1 = (UINT16 *)(vdp->spriteram16_new);
logerror("Scrolls BG-X BG-Y FG-X FG-Y TOP-X TOP-Y Sprite-X Sprite-Y\n");
logerror("---1--> %04x %04x %04x %04x %04x %04x %04x %04x\n", vdp->bg_scrollx,vdp->bg_scrolly,vdp->fg_scrollx,vdp->fg_scrolly,vdp->top_scrollx,vdp->top_scrolly,vdp->sprite_scrollx, vdp->sprite_scrolly);
logerror("---1--> %04x %04x %04x %04x %04x %04x %04x %04x\n", vdp->bg.scrollx,vdp->bg.scrolly,vdp->fg.scrollx,vdp->fg.scrolly,vdp->top.scrollx,vdp->top.scrolly,vdp->sprite_scrollx, vdp->sprite_scrolly);
}
@ -917,11 +844,11 @@ void gp9001_log_vram(gp9001vdp_device* vdp, running_machine *machine)
if (vdp->tile_region == 0)
{
logerror("---0--> %04x %04x %04x %04x %04x %04x %04x %04x\n", vdp->bg_scrollx,vdp->bg_scrolly,vdp->fg_scrollx,vdp->fg_scrolly,vdp->top_scrollx,vdp->top_scrolly,vdp->sprite_scrollx, vdp->sprite_scrolly);
logerror("---0--> %04x %04x %04x %04x %04x %04x %04x %04x\n", vdp->bg.scrollx,vdp->bg.scrolly,vdp->fg.scrollx,vdp->fg.scrolly,vdp->top.scrollx,vdp->top.scrolly,vdp->sprite_scrollx, vdp->sprite_scrolly);
}
if (vdp->tile_region == 2)
{
logerror("---1--> %04x %04x %04x %04x %04x %04x %04x %04x\n", vdp->bg_scrollx,vdp->bg_scrolly,vdp->fg_scrollx,vdp->fg_scrolly,vdp->top_scrollx,vdp->top_scrolly,vdp->sprite_scrollx, vdp->sprite_scrolly);
logerror("---1--> %04x %04x %04x %04x %04x %04x %04x %04x\n", vdp->bg.scrollx,vdp->bg.scrolly,vdp->fg.scrollx,vdp->fg.scrolly,vdp->top.scrollx,vdp->top.scrolly,vdp->sprite_scrollx, vdp->sprite_scrolly);
}
@ -950,12 +877,12 @@ void gp9001_log_vram(gp9001vdp_device* vdp, running_machine *machine)
if (vdp->tile_region == 0)
{
logerror("---0--> %04x %04x %04x %04x %04x %04x %04x %04x\n", vdp->bg_scrollx,vdp->bg_scrolly,vdp->fg_scrollx,vdp->fg_scrolly,vdp->top_scrollx,vdp->top_scrolly,vdp->sprite_scrollx, vdp->sprite_scrolly);
logerror("---0--> %04x %04x %04x %04x %04x %04x %04x %04x\n", vdp->bg.scrollx,vdp->bg.scrolly,vdp->fg.scrollx,vdp->fg.scrolly,vdp->top.scrollx,vdp->top.scrolly,vdp->sprite_scrollx, vdp->sprite_scrolly);
}
if (vdp->tile_region == 2)
{
logerror("---1--> %04x %04x %04x %04x %04x %04x %04x %04x\n", vdp->bg_scrollx,vdp->bg_scrolly,vdp->fg_scrollx,vdp->fg_scrolly,vdp->top_scrollx,vdp->top_scrolly,vdp->sprite_scrollx, vdp->sprite_scrolly);
logerror("---1--> %04x %04x %04x %04x %04x %04x %04x %04x\n", vdp->bg.scrollx,vdp->bg.scrolly,vdp->fg.scrollx,vdp->fg.scrolly,vdp->top.scrollx,vdp->top.scrolly,vdp->sprite_scrollx, vdp->sprite_scrolly);
}
@ -984,12 +911,12 @@ void gp9001_log_vram(gp9001vdp_device* vdp, running_machine *machine)
if (vdp->tile_region == 0)
{
logerror("---0--> %04x %04x %04x %04x %04x %04x %04x %04x\n", vdp->bg_scrollx,vdp->bg_scrolly,vdp->fg_scrollx,vdp->fg_scrolly,vdp->top_scrollx,vdp->top_scrolly,vdp->sprite_scrollx, vdp->sprite_scrolly);
logerror("---0--> %04x %04x %04x %04x %04x %04x %04x %04x\n", vdp->bg.scrollx,vdp->bg.scrolly,vdp->fg.scrollx,vdp->fg.scrolly,vdp->top.scrollx,vdp->top.scrolly,vdp->sprite_scrollx, vdp->sprite_scrolly);
}
if (vdp->tile_region == 2)
{
logerror("---1--> %04x %04x %04x %04x %04x %04x %04x %04x\n", vdp->bg_scrollx,vdp->bg_scrolly,vdp->fg_scrollx,vdp->fg_scrolly,vdp->top_scrollx,vdp->top_scrolly,vdp->sprite_scrollx, vdp->sprite_scrolly);
logerror("---1--> %04x %04x %04x %04x %04x %04x %04x %04x\n", vdp->bg.scrollx,vdp->bg.scrolly,vdp->fg.scrollx,vdp->fg.scrolly,vdp->top.scrollx,vdp->top.scrolly,vdp->sprite_scrollx, vdp->sprite_scrolly);
}
for ( tile_voffs = 0; tile_voffs < (GP9001_BG_VRAM_SIZE/2); tile_voffs += 2 )
@ -1024,12 +951,12 @@ void gp9001_log_vram(gp9001vdp_device* vdp, running_machine *machine)
if (vdp->tile_region == 0)
{
logerror("---0--> %04x %04x %04x %04x %04x %04x %04x %04x\n", vdp->bg_scrollx,vdp->bg_scrolly,vdp->fg_scrollx,vdp->fg_scrolly,vdp->top_scrollx,vdp->top_scrolly,vdp->sprite_scrollx, vdp->sprite_scrolly);
logerror("---0--> %04x %04x %04x %04x %04x %04x %04x %04x\n", vdp->bg.scrollx,vdp->bg.scrolly,vdp->fg.scrollx,vdp->fg.scrolly,vdp->top.scrollx,vdp->top.scrolly,vdp->sprite_scrollx, vdp->sprite_scrolly);
}
if (vdp->tile_region == 2)
{
logerror("---1--> %04x %04x %04x %04x %04x %04x %04x %04x\n", vdp->bg_scrollx,vdp->bg_scrolly,vdp->fg_scrollx,vdp->fg_scrolly,vdp->top_scrollx,vdp->top_scrolly,vdp->sprite_scrollx, vdp->sprite_scrolly);
logerror("---1--> %04x %04x %04x %04x %04x %04x %04x %04x\n", vdp->bg.scrollx,vdp->bg.scrolly,vdp->fg.scrollx,vdp->fg.scrolly,vdp->top.scrollx,vdp->top.scrolly,vdp->sprite_scrollx, vdp->sprite_scrolly);
}
}
#endif
@ -1050,8 +977,8 @@ void gp9001vdp_device::draw_sprites( running_machine *machine, bitmap_t *bitmap,
UINT16 *source = (UINT16 *)(spriteram16_n);
old_x = (-(sprite_scrollx+extra_xoffset[3])) & 0x1ff;
old_y = (-(sprite_scrolly+extra_yoffset[3])) & 0x1ff;
old_x = (-(sprite_scrollx+sp_extra_xoffset)) & 0x1ff;
old_y = (-(sprite_scrolly+sp_extra_yoffset)) & 0x1ff;
for (offs = 0; offs < (GP9001_SPRITERAM_SIZE/2); offs += 4)
{
@ -1084,8 +1011,8 @@ void gp9001vdp_device::draw_sprites( running_machine *machine, bitmap_t *bitmap,
/***** find position to display sprite *****/
if (!(attrib & 0x4000))
{
sx_base = ((source[offs + 2] >> 7) - (sprite_scrollx+extra_xoffset[3])) & 0x1ff;
sy_base = ((source[offs + 3] >> 7) - (sprite_scrolly+extra_yoffset[3])) & 0x1ff;
sx_base = ((source[offs + 2] >> 7) - (sprite_scrollx+sp_extra_xoffset)) & 0x1ff;
sy_base = ((source[offs + 3] >> 7) - (sprite_scrolly+sp_extra_yoffset)) & 0x1ff;
} else {
sx_base = (old_x + (source[offs + 2] >> 7)) & 0x1ff;
sy_base = (old_y + (source[offs + 3] >> 7)) & 0x1ff;
@ -1287,14 +1214,14 @@ void gp9001vdp_device::gp9001_render_vdp(running_machine* machine, bitmap_t* bit
{
if (gp9001_gfxrom_is_banked && gp9001_gfxrom_bank_dirty)
{
tilemap_mark_all_tiles_dirty(bg_tilemap);
tilemap_mark_all_tiles_dirty(fg_tilemap);
tilemap_mark_all_tiles_dirty(bg.tmap);
tilemap_mark_all_tiles_dirty(fg.tmap);
gp9001_gfxrom_bank_dirty = 0;
}
gp9001_draw_custom_tilemap( machine, bitmap, bg_tilemap, gp9001_primap1, batsugun_prienable0);
gp9001_draw_custom_tilemap( machine, bitmap, fg_tilemap, gp9001_primap1, batsugun_prienable0);
gp9001_draw_custom_tilemap( machine, bitmap, top_tilemap, gp9001_primap1, batsugun_prienable0);
gp9001_draw_custom_tilemap( machine, bitmap, bg.tmap, gp9001_primap1, batsugun_prienable0);
gp9001_draw_custom_tilemap( machine, bitmap, fg.tmap, gp9001_primap1, batsugun_prienable0);
gp9001_draw_custom_tilemap( machine, bitmap, top.tmap, gp9001_primap1, batsugun_prienable0);
draw_sprites( machine,bitmap,cliprect, gp9001_sprprimap1);
}

31
src/mame/video/gp9001.h
View File

@ -16,6 +16,18 @@ protected:
UINT8 m_gfxregion;
};
struct gp9001layer
{
UINT8 flip;
UINT16 scrollx;
UINT16 scrolly;
tilemap_t *tmap;
// offset kludges, needed by fixeight bootleg
int extra_xoffset;
int extra_yoffset;
};
class gp9001vdp_device : public device_t,
public device_memory_interface
{
@ -32,22 +44,16 @@ public:
UINT16 *spriteram16_n;
UINT16 gp9001_scroll_reg;
UINT16 bg_scrollx;
UINT16 bg_scrolly;
UINT16 fg_scrollx;
UINT16 fg_scrolly;
UINT16 top_scrollx;
UINT16 top_scrolly;
UINT16 sprite_scrollx;
UINT16 sprite_scrolly;
int sp_extra_xoffset;
int sp_extra_yoffset;
UINT16 sprite_flip;
UINT8 bg_flip;
UINT8 fg_flip;
UINT8 top_flip;
UINT8 sprite_flip;
gp9001layer bg, top, fg;
int tile_region; // we also use this to figure out which vdp we're using in some debug logging features
tilemap_t *top_tilemap, *fg_tilemap, *bg_tilemap;
// debug
int display_bg;
@ -69,9 +75,6 @@ public:
void gp9001_video_eof(void);
void create_tilemaps(int region);
// offset kludges, needed by fixeight bootleg
int extra_xoffset[4];
int extra_yoffset[4];
bitmap_t *custom_priority_bitmap;
int *displog;

16
src/mame/video/toaplan2.c
View File

@ -129,15 +129,15 @@ VIDEO_START( fixeighb )
VIDEO_START_CALL( truxton2 );
/* This bootleg has additional layer offsets on the VDP */
state->vdp0->extra_xoffset[0]=-26;
state->vdp0->extra_xoffset[1]=-22;
state->vdp0->extra_xoffset[2]=-18;
state->vdp0->extra_xoffset[3]=8;
state->vdp0->bg.extra_xoffset=-26;
state->vdp0->fg.extra_xoffset=-22;
state->vdp0->top.extra_xoffset=-18;
state->vdp0->sp_extra_xoffset=8;
state->vdp0->extra_yoffset[0]=-15;
state->vdp0->extra_yoffset[1]=-15;
state->vdp0->extra_yoffset[2]=-15;
state->vdp0->extra_yoffset[3]=8;
state->vdp0->bg.extra_yoffset=-15;
state->vdp0->fg.extra_yoffset=-15;
state->vdp0->top.extra_yoffset=-15;
state->vdp0->sp_extra_yoffset=8;
tilemap_set_scrolldx(state->tx_tilemap, 0, 0);
}