Sprinter/mame
2
0
Fork 0
mirror of https://github.com/holub/mame synced 2025-04-24 09:20:02 +03:00
Code Issues Actions Packages Projects Releases Wiki Activity

- Removed TRANSPARENCY_NONE_RAW, TRANSPARENCY_PENS_RAW and TRANSPARENCY_PEN_TABLE_RAW as they were no

Browse Source 
longer used.  Source needs to be recompiled because of the changed enum.

- Changed copybitmap and copyscrollbitmap:

  There are now 2 versions of each, one without and with transparency:

  void copybitmap(mame_bitmap *dest,mame_bitmap *src,int flipx,int flipy, int sx,int sy,const rectangle *clip);
  void copybitmap_trans(mame_bitmap *dest,mame_bitmap *src,int flipx,int flipy, int sx,int sy,const rectangle *clip, pen_t transparent_pen);
  void copyscrollbitmap(mame_bitmap *dest,mame_bitmap *src, nt rows,const int *rowscroll,int cols,const int *colscroll, const rectangle *clip);
  void copyscrollbitmap_trans(mame_bitmap *dest,mame_bitmap *src, int rows,const int *rowscroll,int cols,const int *colscroll, const rectangle *clip, pen_t transparent_pen);

  The version without _trans is the equivalent of the old TRANSPARENCY_NONE,  The *_trans version is the equivalent
  of the old TRANSPARENCY_PEN.  The old TRANSPARENCY_COLOR mode is done via calling *_trans version and passing in
  the pen that has been looked up via machine->pens[].
  So for example, copybitmap(..., TRANSPARENCY_COLOR, 0) becomes
  copybitmap_trans(..., machine->pens[0])

- Changed all drivers to the new calls.  Suprising how few drivers still use these functions.
  Most have still not been converted to tilemaps, or they are still writing to a tmpbitmap
  which gets copied over to the real bitmap in VIDEO_UPDATE.

- Changed machine->screen[0].visarea to 'cliprect' where appropriate.
This commit is contained in:
Zsolt Vasvari 2008-01-28 13:02:04 +00:00
parent e424adb362
commit 354acd5f1b
92 changed files with 301 additions and 811 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

570
src/emu/drawgfx.c
View File

@ -41,8 +41,6 @@
UINT8 gfx_drawmode_table[256];
UINT8 gfx_alpharange_table[256];
static UINT8 is_raw[TRANSPARENCY_MODES];
alpha_cache drawgfx_alpha_cache;
@ -96,13 +94,6 @@ INLINE int readbit(const UINT8 *src, unsigned int bitnum)
void drawgfx_init(running_machine *machine)
{
/* fill in the raw drawing mode table */
is_raw[TRANSPARENCY_NONE_RAW] = 1;
is_raw[TRANSPARENCY_PEN_RAW] = 1;
is_raw[TRANSPARENCY_PENS_RAW] = 1;
is_raw[TRANSPARENCY_PEN_TABLE_RAW] = 1;
is_raw[TRANSPARENCY_BLEND_RAW] = 1;
/* initialize the alpha drawing table */
alpha_set_level(255);
}
@ -953,7 +944,8 @@ INLINE void common_drawgfx(mame_bitmap *dest,const gfx_element *gfx,
assert_always(gfx, "drawgfx() gfx == 0");
code %= gfx->total_elements;
if (!is_raw[transparency])
if ((transparency != TRANSPARENCY_PEN_RAW) && (transparency != TRANSPARENCY_BLEND_RAW))
color %= gfx->total_colors;
if ((dest->format == BITMAP_FORMAT_INDEXED8 || dest->format == BITMAP_FORMAT_INDEXED16 || dest->format == BITMAP_FORMAT_INDEXED32) &&
@ -1025,22 +1017,11 @@ void mdrawgfx(mame_bitmap *dest,const gfx_element *gfx,
Use copybitmap() to copy a bitmap onto another at the given position.
***************************************************************************/
void copybitmap(mame_bitmap *dest,mame_bitmap *src,int flipx,int flipy,int sx,int sy,
static void copybitmap_common(mame_bitmap *dest,mame_bitmap *src,int flipx,int flipy,int sx,int sy,
const rectangle *clip,int transparency,int transparent_color)
{
profiler_mark(PROFILER_COPYBITMAP);
/* translate to proper transparency here */
if (transparency == TRANSPARENCY_NONE)
transparency = TRANSPARENCY_NONE_RAW;
else if (transparency == TRANSPARENCY_PEN)
transparency = TRANSPARENCY_PEN_RAW;
else if (transparency == TRANSPARENCY_COLOR)
{
transparent_color = Machine->pens[transparent_color];
transparency = TRANSPARENCY_PEN_RAW;
}
if (dest->bpp == 8)
copybitmap_core8(dest,src,flipx,flipy,sx,sy,clip,transparency,transparent_color);
else if (dest->bpp == 16)
@ -1051,6 +1032,18 @@ void copybitmap(mame_bitmap *dest,mame_bitmap *src,int flipx,int flipy,int sx,in
profiler_mark(PROFILER_END);
}
void copybitmap(mame_bitmap *dest, mame_bitmap *src, int flipx, int flipy,
int sx, int sy, const rectangle *clip)
{
copybitmap_common(dest,src,flipx,flipy,sx,sy,clip,TRANSPARENCY_NONE,0);
}
void copybitmap_trans(mame_bitmap *dest, mame_bitmap *src, int flipx, int flipy,
int sx, int sy, const rectangle *clip, pen_t transparent_pen)
{
copybitmap_common(dest,src,flipx,flipy,sx,sy,clip,TRANSPARENCY_PEN,transparent_pen);
}
/***************************************************************************
@ -1066,7 +1059,7 @@ void copybitmap(mame_bitmap *dest,mame_bitmap *src,int flipx,int flipy,int sx,in
scrolls as a whole in at least one direction.
***************************************************************************/
void copyscrollbitmap(mame_bitmap *dest,mame_bitmap *src,
static void copyscrollbitmap_common(mame_bitmap *dest,mame_bitmap *src,
int rows,const int *rowscroll,int cols,const int *colscroll,
const rectangle *clip,int transparency,int transparent_color)
{
@ -1091,7 +1084,7 @@ void copyscrollbitmap(mame_bitmap *dest,mame_bitmap *src,
if (rows == 0 && cols == 0)
{
copybitmap(dest,src,0,0,0,0,clip,transparency,transparent_color);
copybitmap_common(dest,src,0,0,0,0,clip,transparency,transparent_color);
return;
}
@ -1132,8 +1125,8 @@ void copyscrollbitmap(mame_bitmap *dest,mame_bitmap *src,
myclip.max_x = (col + cons) * colwidth - 1;
if (myclip.max_x > clip->max_x) myclip.max_x = clip->max_x;
copybitmap(dest,src,0,0,0,scroll,&myclip,transparency,transparent_color);
copybitmap(dest,src,0,0,0,scroll - srcheight,&myclip,transparency,transparent_color);
copybitmap_common(dest,src,0,0,0,scroll,&myclip,transparency,transparent_color);
copybitmap_common(dest,src,0,0,0,scroll - srcheight,&myclip,transparency,transparent_color);
col += cons;
}
@ -1170,8 +1163,8 @@ void copyscrollbitmap(mame_bitmap *dest,mame_bitmap *src,
myclip.max_y = (row + cons) * rowheight - 1;
if (myclip.max_y > clip->max_y) myclip.max_y = clip->max_y;
copybitmap(dest,src,0,0,scroll,0,&myclip,transparency,transparent_color);
copybitmap(dest,src,0,0,scroll - srcwidth,0,&myclip,transparency,transparent_color);
copybitmap_common(dest,src,0,0,scroll,0,&myclip,transparency,transparent_color);
copybitmap_common(dest,src,0,0,scroll - srcwidth,0,&myclip,transparency,transparent_color);
row += cons;
}
@ -1190,7 +1183,7 @@ void copyscrollbitmap(mame_bitmap *dest,mame_bitmap *src,
for (sx = scrollx - srcwidth;sx < destwidth;sx += srcwidth)
for (sy = scrolly - srcheight;sy < destheight;sy += srcheight)
copybitmap(dest,src,0,0,sx,sy,clip,transparency,transparent_color);
copybitmap_common(dest,src,0,0,sx,sy,clip,transparency,transparent_color);
}
else if (rows == 1)
{
@ -1228,16 +1221,16 @@ void copyscrollbitmap(mame_bitmap *dest,mame_bitmap *src,
myclip.max_x = (col + cons) * colwidth - 1 + scrollx;
if (myclip.max_x > clip->max_x) myclip.max_x = clip->max_x;
copybitmap(dest,src,0,0,scrollx,scroll,&myclip,transparency,transparent_color);
copybitmap(dest,src,0,0,scrollx,scroll - srcheight,&myclip,transparency,transparent_color);
copybitmap_common(dest,src,0,0,scrollx,scroll,&myclip,transparency,transparent_color);
copybitmap_common(dest,src,0,0,scrollx,scroll - srcheight,&myclip,transparency,transparent_color);
myclip.min_x = col * colwidth + scrollx - srcwidth;
if (myclip.min_x < clip->min_x) myclip.min_x = clip->min_x;
myclip.max_x = (col + cons) * colwidth - 1 + scrollx - srcwidth;
if (myclip.max_x > clip->max_x) myclip.max_x = clip->max_x;
copybitmap(dest,src,0,0,scrollx - srcwidth,scroll,&myclip,transparency,transparent_color);
copybitmap(dest,src,0,0,scrollx - srcwidth,scroll - srcheight,&myclip,transparency,transparent_color);
copybitmap_common(dest,src,0,0,scrollx - srcwidth,scroll,&myclip,transparency,transparent_color);
copybitmap_common(dest,src,0,0,scrollx - srcwidth,scroll - srcheight,&myclip,transparency,transparent_color);
col += cons;
}
@ -1278,16 +1271,16 @@ void copyscrollbitmap(mame_bitmap *dest,mame_bitmap *src,
myclip.max_y = (row + cons) * rowheight - 1 + scrolly;
if (myclip.max_y > clip->max_y) myclip.max_y = clip->max_y;
copybitmap(dest,src,0,0,scroll,scrolly,&myclip,transparency,transparent_color);
copybitmap(dest,src,0,0,scroll - srcwidth,scrolly,&myclip,transparency,transparent_color);
copybitmap_common(dest,src,0,0,scroll,scrolly,&myclip,transparency,transparent_color);
copybitmap_common(dest,src,0,0,scroll - srcwidth,scrolly,&myclip,transparency,transparent_color);
myclip.min_y = row * rowheight + scrolly - srcheight;
if (myclip.min_y < clip->min_y) myclip.min_y = clip->min_y;
myclip.max_y = (row + cons) * rowheight - 1 + scrolly - srcheight;
if (myclip.max_y > clip->max_y) myclip.max_y = clip->max_y;
copybitmap(dest,src,0,0,scroll,scrolly - srcheight,&myclip,transparency,transparent_color);
copybitmap(dest,src,0,0,scroll - srcwidth,scrolly - srcheight,&myclip,transparency,transparent_color);
copybitmap_common(dest,src,0,0,scroll,scrolly - srcheight,&myclip,transparency,transparent_color);
copybitmap_common(dest,src,0,0,scroll - srcwidth,scrolly - srcheight,&myclip,transparency,transparent_color);
row += cons;
}
@ -1295,6 +1288,21 @@ void copyscrollbitmap(mame_bitmap *dest,mame_bitmap *src,
}
void copyscrollbitmap(mame_bitmap *dest, mame_bitmap *src,
int rows, const int *rowscroll, int cols, const int *colscroll,
const rectangle *clip)
{
copyscrollbitmap_common(dest,src,rows,rowscroll,cols,colscroll,clip,TRANSPARENCY_NONE,0);
}
void copyscrollbitmap_trans(mame_bitmap *dest, mame_bitmap *src,
int rows, const int *rowscroll, int cols, const int *colscroll,
const rectangle *clip, pen_t transparent_pen)
{
copyscrollbitmap_common(dest,src,rows,rowscroll,cols,colscroll,clip,TRANSPARENCY_PEN,transparent_pen);
}
/* notes:
- startx and starty MUST be UINT32 for calculations to work correctly
- srcbitmap->width and height are assumed to be a power of 2 to speed up wraparound
@ -1358,7 +1366,7 @@ INLINE void common_drawgfxzoom( mame_bitmap *dest_bmp,const gfx_element *gfx,
if (transparency != TRANSPARENCY_PEN && transparency != TRANSPARENCY_PEN_RAW
&& transparency != TRANSPARENCY_PENS && transparency != TRANSPARENCY_COLOR
&& transparency != TRANSPARENCY_PEN_TABLE && transparency != TRANSPARENCY_PEN_TABLE_RAW
&& transparency != TRANSPARENCY_PEN_TABLE
&& transparency != TRANSPARENCY_BLEND_RAW
&& transparency != TRANSPARENCY_ALPHA && transparency != TRANSPARENCY_ALPHARANGE
&& transparency != TRANSPARENCY_NONE)
@ -1918,80 +1926,6 @@ INLINE void common_drawgfxzoom( mame_bitmap *dest_bmp,const gfx_element *gfx,
}
}
}
/* case 4b: TRANSPARENCY_PEN_TABLE_RAW */
if (transparency == TRANSPARENCY_PEN_TABLE_RAW)
{
pen_t *palette_shadow_table = Machine->shadow_table;
if (pri_buffer)
{
for( y=sy; y<ey; y++ )
{
UINT8 *source = source_base + (y_index>>16) * gfx->line_modulo;
UINT8 *dest = BITMAP_ADDR8(dest_bmp, y, 0);
UINT8 *pri = BITMAP_ADDR8(pri_buffer, y, 0);
int x, x_index = x_index_base;
for( x=sx; x<ex; x++ )
{
int c = source[x_index>>16];
if( c != transparent_color )
{
switch(gfx_drawmode_table[c])
{
case DRAWMODE_SOURCE:
if (((1 << (pri[x] & 0x1f)) & pri_mask) == 0)
{
if (pri[x] & 0x80)
dest[x] = palette_shadow_table[color + c];
else
dest[x] = color + c;
}
pri[x] = (pri[x] & 0x7f) | 31;
break;
case DRAWMODE_SHADOW:
if (((1 << pri[x]) & pri_mask) == 0)
dest[x] = palette_shadow_table[dest[x]];
pri[x] |= al;
break;
}
}
x_index += dx;
}
y_index += dy;
}
}
else
{
for( y=sy; y<ey; y++ )
{
UINT8 *source = source_base + (y_index>>16) * gfx->line_modulo;
UINT8 *dest = BITMAP_ADDR8(dest_bmp, y, 0);
int x, x_index = x_index_base;
for( x=sx; x<ex; x++ )
{
int c = source[x_index>>16];
if( c != transparent_color )
{
switch(gfx_drawmode_table[c])
{
case DRAWMODE_SOURCE:
dest[x] = color + c;
break;
case DRAWMODE_SHADOW:
dest[x] = palette_shadow_table[dest[x]];
break;
}
}
x_index += dx;
}
y_index += dy;
}
}
}
}
}
}
@ -2515,81 +2449,6 @@ INLINE void common_drawgfxzoom( mame_bitmap *dest_bmp,const gfx_element *gfx,
}
}
/* case 4b: TRANSPARENCY_PEN_TABLE_RAW */
if (transparency == TRANSPARENCY_PEN_TABLE_RAW)
{
pen_t *palette_shadow_table = Machine->shadow_table;
if (pri_buffer)
{
for( y=sy; y<ey; y++ )
{
UINT8 *source = source_base + (y_index>>16) * gfx->line_modulo;
UINT16 *dest = BITMAP_ADDR16(dest_bmp, y, 0);
UINT8 *pri = BITMAP_ADDR8(pri_buffer, y, 0);
int x, x_index = x_index_base;
for( x=sx; x<ex; x++ )
{
int c = source[x_index>>16];
if( c != transparent_color )
{
switch(gfx_drawmode_table[c])
{
case DRAWMODE_SOURCE:
ah = pri[x];
if (((1 << (ah & 0x1f)) & pri_mask) == 0)
{
if (ah & 0x80)
dest[x] = palette_shadow_table[color + c];
else
dest[x] = color + c;
}
pri[x] = (ah & 0x7f) | 31;
break;
case DRAWMODE_SHADOW:
if (((1 << pri[x]) & pri_mask) == 0)
dest[x] = palette_shadow_table[dest[x]];
pri[x] |= al;
break;
}
}
x_index += dx;
}
y_index += dy;
}
}
else
{
for( y=sy; y<ey; y++ )
{
UINT8 *source = source_base + (y_index>>16) * gfx->line_modulo;
UINT16 *dest = BITMAP_ADDR16(dest_bmp, y, 0);
int x, x_index = x_index_base;
for( x=sx; x<ex; x++ )
{
int c = source[x_index>>16];
if( c != transparent_color )
{
switch(gfx_drawmode_table[c])
{
case DRAWMODE_SOURCE:
dest[x] = color + c;
break;
case DRAWMODE_SHADOW:
dest[x] = palette_shadow_table[dest[x]];
break;
}
}
x_index += dx;
}
y_index += dy;
}
}
}
/* case 6: TRANSPARENCY_ALPHA */
if (transparency == TRANSPARENCY_ALPHA)
{
@ -3126,81 +2985,6 @@ INLINE void common_drawgfxzoom( mame_bitmap *dest_bmp,const gfx_element *gfx,
}
}
/* case 4b: TRANSPARENCY_PEN_TABLE_RAW */
if (transparency == TRANSPARENCY_PEN_TABLE_RAW)
{
pen_t *palette_shadow_table = Machine->shadow_table;
UINT8 *source, *pri;
UINT32 *dest;
int c, x, x_index;
if (pri_buffer)
{
for( y=sy; y<ey; y++ )
{
source = source_base + (y_index>>16) * gfx->line_modulo;
y_index += dy;
dest = BITMAP_ADDR32(dest_bmp, y, 0);
pri = BITMAP_ADDR8(pri_buffer, y, 0);
x_index = x_index_base;
for( x=sx; x<ex; x++ )
{
int ebx = x_index;
x_index += dx;
ebx >>= 16;
al = pri[x];
c = source[ebx];
ah = al;
al &= 0x1f;
if (gfx_drawmode_table[c] == DRAWMODE_NONE) continue;
if (!(1<<al & pri_mask))
{
if (gfx_drawmode_table[c] == DRAWMODE_SOURCE)
{
ah &= 0x7f;
ebx = color + c;
ah |= 0x1f;
dest[x] = ebx;
pri[x] = ah;
}
else if (!(ah & 0x80))
{
ebx = SHADOW32(palette_shadow_table,dest[x]);
pri[x] |= 0x80;
dest[x] = ebx;
}
}
}
}
}
else
{
for( y=sy; y<ey; y++ )
{
source = source_base + (y_index>>16) * gfx->line_modulo;
y_index += dy;
dest = BITMAP_ADDR32(dest_bmp, y, 0);
x_index = x_index_base;
for( x=sx; x<ex; x++ )
{
c = source[x_index>>16];
x_index += dx;
if (gfx_drawmode_table[c] == DRAWMODE_NONE) continue;
if (gfx_drawmode_table[c] == DRAWMODE_SOURCE)
dest[x] = color + c;
else
dest[x] = SHADOW32(palette_shadow_table,dest[x]);
}
}
}
}
/* case 6: TRANSPARENCY_ALPHA */
if (transparency == TRANSPARENCY_ALPHA)
{
@ -3402,6 +3186,7 @@ void mdrawgfxzoom( mame_bitmap *dest_bmp,const gfx_element *gfx,
#if (RAW == 0)
DECLARE_SWAP_RAW_PRI(blockmove_8toN_opaque,(COMMON_ARGS,
COLOR_ARG),
{
@ -3475,7 +3260,9 @@ DECLARE_SWAP_RAW_PRI(blockmove_8toN_opaque,(COMMON_ARGS,
}
}
})
#endif
#if (RAW == 0)
DECLARE_SWAP_RAW_PRI(blockmove_4toN_opaque,(COMMON_ARGS,
COLOR_ARG),
{
@ -3571,6 +3358,7 @@ DECLARE_SWAP_RAW_PRI(blockmove_4toN_opaque,(COMMON_ARGS,
}
}
})
#endif
DECLARE_SWAP_RAW_PRI(blockmove_8toN_transpen,(COMMON_ARGS,
COLOR_ARG,int transpen),
@ -3875,6 +3663,7 @@ DECLARE_SWAP_RAW_PRI(blockmove_8toN_transblend,(COMMON_ARGS,
#endif
#if (RAW == 0)
#define PEN_IS_OPAQUE ((1<<col)&transmask) == 0
DECLARE_SWAP_RAW_PRI(blockmove_8toN_transmask,(COMMON_ARGS,
@ -3982,6 +3771,7 @@ DECLARE_SWAP_RAW_PRI(blockmove_8toN_transmask,(COMMON_ARGS,
}
}
})
#endif
#if (RAW == 0)
DECLARE_SWAP_RAW_PRI(blockmove_8toN_transcolor,(COMMON_ARGS,
@ -4109,6 +3899,7 @@ DECLARE_SWAP_RAW_PRI(blockmove_4toN_transcolor,(COMMON_ARGS,
})
#endif
#if (RAW == 0)
#if DEPTH == 32
DECLARE_SWAP_RAW_PRI(blockmove_8toN_pen_table,(COMMON_ARGS,
COLOR_ARG,int transcolor),
@ -4268,195 +4059,9 @@ DECLARE_SWAP_RAW_PRI(blockmove_8toN_pen_table,(COMMON_ARGS,
}
})
#endif
#endif
#if DEPTH >= 16
#if (1 == 0)
DECLARE_SWAP_RAW_PRI(blockmove_8toN_alphaone,(COMMON_ARGS,
COLOR_ARG,int transpen, int alphapen),
{
pen_t *palette_shadow_table = Machine->shadow_table;
ADJUST_8
(void)palette_shadow_table;
if (flipx)
{
DATA_TYPE *end;
int trans4;
UINT32 *sd4;
UINT32 alphacolor = LOOKUP(alphapen);
trans4 = transpen * 0x01010101;
while (dstheight)
{
end = dstdata - dstwidth*HMODULO;
while (((FPTR)srcdata & 3) && dstdata > end) /* longword align */
{
int col;
col = *(srcdata++);
if (col != transpen)
{
if (col == alphapen)
SETPIXELCOLOR(0,alpha_blend(*dstdata,alphacolor))
else
SETPIXELCOLOR(0,LOOKUP(col))
}
INCREMENT_DST(-HMODULO);
}
sd4 = (UINT32 *)srcdata;
while (dstdata >= end + 4*HMODULO)
{
UINT32 col4;
INCREMENT_DST(-4*HMODULO);
if ((col4 = *(sd4++)) != trans4)
{
UINT32 xod4;
xod4 = col4 ^ trans4;
if (xod4 & (0xff<<SHIFT0))
{
if (((col4>>SHIFT0) & 0xff) == alphapen)
SETPIXELCOLOR(4*HMODULO,alpha_blend(dstdata[4*HMODULO], alphacolor))
else
SETPIXELCOLOR(4*HMODULO,LOOKUP((col4>>SHIFT0) & 0xff))
}
if (xod4 & (0xff<<SHIFT1))
{
if (((col4>>SHIFT1) & 0xff) == alphapen)
SETPIXELCOLOR(3*HMODULO,alpha_blend(dstdata[3*HMODULO], alphacolor))
else
SETPIXELCOLOR(3*HMODULO,LOOKUP((col4>>SHIFT1) & 0xff))
}
if (xod4 & (0xff<<SHIFT2))
{
if (((col4>>SHIFT2) & 0xff) == alphapen)
SETPIXELCOLOR(2*HMODULO,alpha_blend(dstdata[2*HMODULO], alphacolor))
else
SETPIXELCOLOR(2*HMODULO,LOOKUP((col4>>SHIFT2) & 0xff))
}
if (xod4 & (0xff<<SHIFT3))
{
if (((col4>>SHIFT3) & 0xff) == alphapen)
SETPIXELCOLOR(1*HMODULO,alpha_blend(dstdata[1*HMODULO], alphacolor))
else
SETPIXELCOLOR(1*HMODULO,LOOKUP((col4>>SHIFT3) & 0xff))
}
}
}
srcdata = (UINT8 *)sd4;
while (dstdata > end)
{
int col;
col = *(srcdata++);
if (col != transpen)
{
if (col == alphapen)
SETPIXELCOLOR(0,alpha_blend(*dstdata, alphacolor))
else
SETPIXELCOLOR(0,LOOKUP(col))
}
INCREMENT_DST(-HMODULO);
}
srcdata += srcmodulo;
INCREMENT_DST(ydir*VMODULO + dstwidth*HMODULO);
dstheight--;
}
}
else
{
DATA_TYPE *end;
int trans4;
UINT32 *sd4;
UINT32 alphacolor = LOOKUP(alphapen);
trans4 = transpen * 0x01010101;
while (dstheight)
{
end = dstdata + dstwidth*HMODULO;
while (((FPTR)srcdata & 3) && dstdata < end) /* longword align */
{
int col;
col = *(srcdata++);
if (col != transpen)
{
if (col == alphapen)
SETPIXELCOLOR(0,alpha_blend(*dstdata, alphacolor))
else
SETPIXELCOLOR(0,LOOKUP(col))
}
INCREMENT_DST(HMODULO);
}
sd4 = (UINT32 *)srcdata;
while (dstdata <= end - 4*HMODULO)
{
UINT32 col4;
if ((col4 = *(sd4++)) != trans4)
{
UINT32 xod4;
xod4 = col4 ^ trans4;
if (xod4 & (0xff<<SHIFT0))
{
if (((col4>>SHIFT0) & 0xff) == alphapen)
SETPIXELCOLOR(0*HMODULO,alpha_blend(dstdata[0*HMODULO], alphacolor))
else
SETPIXELCOLOR(0*HMODULO,LOOKUP((col4>>SHIFT0) & 0xff))
}
if (xod4 & (0xff<<SHIFT1))
{
if (((col4>>SHIFT1) & 0xff) == alphapen)
SETPIXELCOLOR(1*HMODULO,alpha_blend(dstdata[1*HMODULO], alphacolor))
else
SETPIXELCOLOR(1*HMODULO,LOOKUP((col4>>SHIFT1) & 0xff))
}
if (xod4 & (0xff<<SHIFT2))
{
if (((col4>>SHIFT2) & 0xff) == alphapen)
SETPIXELCOLOR(2*HMODULO,alpha_blend(dstdata[2*HMODULO], alphacolor))
else
SETPIXELCOLOR(2*HMODULO,LOOKUP((col4>>SHIFT2) & 0xff))
}
if (xod4 & (0xff<<SHIFT3))
{
if (((col4>>SHIFT3) & 0xff) == alphapen)
SETPIXELCOLOR(3*HMODULO,alpha_blend(dstdata[3*HMODULO], alphacolor))
else
SETPIXELCOLOR(3*HMODULO,LOOKUP((col4>>SHIFT3) & 0xff))
}
}
INCREMENT_DST(4*HMODULO);
}
srcdata = (UINT8 *)sd4;
while (dstdata < end)
{
int col;
col = *(srcdata++);
if (col != transpen)
{
if (col == alphapen)
SETPIXELCOLOR(0,alpha_blend(*dstdata, alphacolor))
else
SETPIXELCOLOR(0,LOOKUP(col))
}
INCREMENT_DST(HMODULO);
}
srcdata += srcmodulo;
INCREMENT_DST(ydir*VMODULO - dstwidth*HMODULO);
dstheight--;
}
}
})
#endif
#if (RAW == 0)
DECLARE_SWAP_RAW_PRI(blockmove_8toN_alpha,(COMMON_ARGS,
@ -4639,11 +4244,6 @@ DECLARE_SWAP_RAW_PRI(blockmove_8toN_alpharange,(COMMON_ARGS,
#else
#if (1 == 0)
DECLARE_SWAP_RAW_PRI(blockmove_8toN_alphaone,(COMMON_ARGS,
COLOR_ARG,int transpen, int alphapen),{})
#endif
#if (RAW == 0)
DECLARE_SWAP_RAW_PRI(blockmove_8toN_alpha,(COMMON_ARGS,
COLOR_ARG,int transpen),{})
@ -4746,33 +4346,6 @@ DECLARE(drawgfx_core,(
const pen_t *paldata = &Machine->remapped_colortable[gfx->color_base + gfx->color_granularity * color];
UINT8 *pribuf = (pri_buffer) ? BITMAP_ADDR8(pri_buffer, sy, sx) : NULL;
/* optimizations for 1:1 mapping */
if (Machine->drv->color_table_len == 0 &&
dest->format == BITMAP_FORMAT_INDEXED16 &&
paldata >= Machine->remapped_colortable &&
paldata < Machine->remapped_colortable + Machine->drv->total_colors)
{
switch (transparency)
{
case TRANSPARENCY_NONE:
transparency = TRANSPARENCY_NONE_RAW;
color = paldata - Machine->remapped_colortable;
break;
case TRANSPARENCY_PEN:
transparency = TRANSPARENCY_PEN_RAW;
color = paldata - Machine->remapped_colortable;
break;
case TRANSPARENCY_PENS:
transparency = TRANSPARENCY_PENS_RAW;
color = paldata - Machine->remapped_colortable;
break;
case TRANSPARENCY_PEN_TABLE:
transparency = TRANSPARENCY_PEN_TABLE_RAW;
color = paldata - Machine->remapped_colortable;
break;
}
}
switch (transparency)
{
case TRANSPARENCY_NONE:
@ -4792,23 +4365,6 @@ DECLARE(drawgfx_core,(
}
break;
case TRANSPARENCY_NONE_RAW:
if (gfx->flags & GFX_ELEMENT_PACKED)
{
if (pribuf)
BLOCKMOVERAWPRI(4toN_opaque,(sd,sw,sh,sm,ls,ts,flipx,flipy,dd,dw,dh,dm,color,pribuf,pri_mask));
else
BLOCKMOVERAW(4toN_opaque,(sd,sw,sh,sm,ls,ts,flipx,flipy,dd,dw,dh,dm,color));
}
else
{
if (pribuf)
BLOCKMOVERAWPRI(8toN_opaque,(sd,sw,sh,sm,ls,ts,flipx,flipy,dd,dw,dh,dm,color,pribuf,pri_mask));
else
BLOCKMOVERAW(8toN_opaque,(sd,sw,sh,sm,ls,ts,flipx,flipy,dd,dw,dh,dm,color));
}
break;
case TRANSPARENCY_PEN:
if (gfx->flags & GFX_ELEMENT_PACKED)
{
@ -4850,13 +4406,6 @@ DECLARE(drawgfx_core,(
BLOCKMOVELU(8toN_transmask,(sd,sw,sh,sm,ls,ts,flipx,flipy,dd,dw,dh,dm,paldata,transparent_color));
break;
case TRANSPARENCY_PENS_RAW:
if (pribuf)
BLOCKMOVERAWPRI(8toN_transmask,(sd,sw,sh,sm,ls,ts,flipx,flipy,dd,dw,dh,dm,color,pribuf,pri_mask,transparent_color));
else
BLOCKMOVERAW(8toN_transmask,(sd,sw,sh,sm,ls,ts,flipx,flipy,dd,dw,dh,dm,color,transparent_color));
break;
case TRANSPARENCY_COLOR:
if (gfx->flags & GFX_ELEMENT_PACKED)
{
@ -4881,13 +4430,6 @@ DECLARE(drawgfx_core,(
BLOCKMOVELU(8toN_pen_table,(sd,sw,sh,sm,ls,ts,flipx,flipy,dd,dw,dh,dm,paldata,transparent_color));
break;
case TRANSPARENCY_PEN_TABLE_RAW:
if (pribuf)
BLOCKMOVERAWPRI(8toN_pen_table,(sd,sw,sh,sm,ls,ts,flipx,flipy,dd,dw,dh,dm,color,pribuf,pri_mask,transparent_color));
else
BLOCKMOVERAW(8toN_pen_table,(sd,sw,sh,sm,ls,ts,flipx,flipy,dd,dw,dh,dm,color,transparent_color));
break;
case TRANSPARENCY_BLEND_RAW:
if (pribuf)
BLOCKMOVERAWPRI(8toN_transblend,(sd,sw,sh,sm,ls,ts,flipx,flipy,dd,dw,dh,dm,color,pribuf,pri_mask,transparent_color));
@ -4971,11 +4513,11 @@ DECLARE(copybitmap_core,(
switch (transparency)
{
case TRANSPARENCY_NONE_RAW:
case TRANSPARENCY_NONE:
BLOCKMOVE(NtoN_opaque_noremap,flipx,(sd,sw,sh,sm,dd,dm));
break;
case TRANSPARENCY_PEN_RAW:
case TRANSPARENCY_PEN:
BLOCKMOVE(NtoN_transpen_noremap,flipx,(sd,sw,sh,sm,dd,dm,transparent_color));
break;

20
src/emu/drawgfx.h
View File

@ -51,14 +51,11 @@
enum
{
TRANSPARENCY_NONE, /* opaque with remapping */
TRANSPARENCY_NONE_RAW, /* opaque with no remapping */
TRANSPARENCY_PEN, /* single pen transparency with remapping */
TRANSPARENCY_PEN_RAW, /* single pen transparency with no remapping */
TRANSPARENCY_PENS, /* multiple pen transparency with remapping */
TRANSPARENCY_PENS_RAW, /* multiple pen transparency with no remapping */
TRANSPARENCY_COLOR, /* single remapped pen transparency with remapping */
TRANSPARENCY_PEN_TABLE, /* special pen remapping modes (see DRAWMODE_xxx below) with remapping */
TRANSPARENCY_PEN_TABLE_RAW, /* special pen remapping modes (see DRAWMODE_xxx below) with no remapping */
TRANSPARENCY_BLEND_RAW, /* blend two bitmaps, shifting the source and ORing to the dest with no remapping */
TRANSPARENCY_ALPHA, /* single pen transparency, other pens alpha */
TRANSPARENCY_ALPHARANGE, /* single pen transparency, multiple pens alpha depending on array, see psikyosh.c */
@ -239,11 +236,20 @@ void extract_scanline16(mame_bitmap *bitmap,int x,int y,int length,UINT16 *dst);
void extract_scanline32(mame_bitmap *bitmap,int x,int y,int length,UINT32 *dst);
void copybitmap(mame_bitmap *dest,mame_bitmap *src,int flipx,int flipy,int sx,int sy,
const rectangle *clip,int transparency,int transparent_color);
void copybitmap(mame_bitmap *dest,mame_bitmap *src,int flipx,int flipy,
int sx,int sy,const rectangle *clip);
void copybitmap_trans(mame_bitmap *dest,mame_bitmap *src,int flipx,int flipy,
int sx,int sy,const rectangle *clip,pen_t transparent_pen);
void copyscrollbitmap(mame_bitmap *dest,mame_bitmap *src,
int rows,const int *rowscroll,int cols,const int *colscroll,
const rectangle *clip,int transparency,int transparent_color);
int rows,const int *rowscroll,int cols,const int *colscroll,
const rectangle *clip);
void copyscrollbitmap_trans(mame_bitmap *dest,mame_bitmap *src,
int rows,const int *rowscroll,int cols,const int *colscroll,
const rectangle *clip,pen_t transparent_pen);
/*
Copy a bitmap applying rotation, zooming, and arbitrary distortion.

2
src/emu/video/generic.c
View File

@ -336,7 +336,7 @@ VIDEO_START( generic_bitmapped )
VIDEO_UPDATE( generic_bitmapped )
{
copybitmap(bitmap, tmpbitmap, 0, 0, 0, 0, &machine->screen[0].visarea, TRANSPARENCY_NONE, 0);
copybitmap(bitmap, tmpbitmap, 0, 0, 0, 0, cliprect);
return 0;
}

2
src/emu/video/tms9928a.c
View File

@ -398,7 +398,7 @@ VIDEO_UPDATE( tms9928a )
{
(*ModeHandlers[TMS_MODE])(machine, tms.tmpbmp, cliprect);
copybitmap(bitmap, tms.tmpbmp, 0, 0, LEFT_BORDER, TOP_BORDER, cliprect, TRANSPARENCY_NONE, 0);
copybitmap(bitmap, tms.tmpbmp, 0, 0, LEFT_BORDER, TOP_BORDER, cliprect);
{
rectangle rt;

2
src/mame/drivers/ddenlovr.c
View File

@ -1211,7 +1211,7 @@ static void copylayer(mame_bitmap *bitmap,const rectangle *cliprect,int layer)
VIDEO_UPDATE(ddenlovr)
{
copybitmap(bitmap,framebuffer,0,0,0,0,cliprect,TRANSPARENCY_NONE,0);
copybitmap(bitmap,framebuffer,0,0,0,0,cliprect);
return 0;
}

2
src/mame/drivers/dgpix.c
View File

@ -313,7 +313,7 @@ static VIDEO_START( dgpix )
static VIDEO_UPDATE( dgpix )
{
copybitmap(bitmap,bitmaps[vbuffer ^ 1],0,0,0,0,cliprect,TRANSPARENCY_NONE,0);
copybitmap(bitmap,bitmaps[vbuffer ^ 1],0,0,0,0,cliprect);
return 0;
}

2
src/mame/drivers/lastfght.c
View File

@ -120,7 +120,7 @@ static VIDEO_UPDATE( lastfght )
#endif
#endif
copybitmap(bitmap,lastfght_bitmap[lastfght_dest^1],0,0,0,0,&machine->screen[0].visarea,TRANSPARENCY_NONE,0);
copybitmap(bitmap,lastfght_bitmap[lastfght_dest^1],0,0,0,0,cliprect);
return 0;
}

3
src/mame/drivers/madalien.c
View File

@ -321,8 +321,7 @@ static VIDEO_UPDATE( madalien )
}
}
copybitmap(bitmap, tmp_bitmap, flip_screen, flip_screen,
0, 0, cliprect, TRANSPARENCY_NONE, 0);
copybitmap(bitmap, tmp_bitmap, flip_screen, flip_screen, 0, 0, cliprect);
return 0;
}

6
src/mame/drivers/marinedt.c
View File

@ -501,12 +501,12 @@ static VIDEO_UPDATE( marinedt )
fillbitmap(bitmap, machine->pens[0], NULL);
if (marinedt_pd & 0x02)
copybitmap(bitmap, obj2, 0, 0, OBJ_X(marinedt_obj2_x), OBJ_Y(marinedt_obj2_y), cliprect, TRANSPARENCY_COLOR, machine->pens[0]);
copybitmap_trans(bitmap, obj2, 0, 0, OBJ_X(marinedt_obj2_x), OBJ_Y(marinedt_obj2_y), cliprect, machine->pens[0]);
if (marinedt_pd & 0x01)
copybitmap(bitmap, obj1, 0, 0, OBJ_X(marinedt_obj1_x), OBJ_Y(marinedt_obj1_y), cliprect, TRANSPARENCY_COLOR, machine->pens[0]);
copybitmap_trans(bitmap, obj1, 0, 0, OBJ_X(marinedt_obj1_x), OBJ_Y(marinedt_obj1_y), cliprect, machine->pens[0]);
copybitmap(bitmap, tile, 0, 0, 0, 0, cliprect, TRANSPARENCY_COLOR, machine->pens[0]);
copybitmap_trans(bitmap, tile, 0, 0, 0, 0, cliprect, machine->pens[0]);
coll = cx = cyr = cyq = 0;
if (marinedt_pd & 0x01)

24
src/mame/drivers/mazerbla.c
View File

@ -140,21 +140,21 @@ VIDEO_UPDATE( test_vcu )
if (planes_enabled[3])
copybitmap(bitmap,tmpbitmaps[3],0,0,0,0,&machine->screen[0].visarea,TRANSPARENCY_NONE, 0 );
copybitmap(bitmap,tmpbitmaps[3],0,0,0,0,cliprect);
if (planes_enabled[2])
copybitmap(bitmap,tmpbitmaps[2],0,0,0,0,&machine->screen[0].visarea,TRANSPARENCY_PEN, machine->pens[color_base] );
copybitmap_trans(bitmap,tmpbitmaps[2],0,0,0,0,cliprect,machine->pens[color_base] );
fillbitmap(tmpbitmaps[2],machine->pens[color_base],NULL);
if (planes_enabled[1])
copybitmap(bitmap,tmpbitmaps[1],0,0,0,0,&machine->screen[0].visarea,TRANSPARENCY_PEN, machine->pens[color_base] );
copybitmap_trans(bitmap,tmpbitmaps[1],0,0,0,0,cliprect,machine->pens[color_base] );
fillbitmap(tmpbitmaps[1],machine->pens[color_base],NULL);
if (planes_enabled[0])
copybitmap(bitmap,tmpbitmaps[0],0,0,0,0,&machine->screen[0].visarea,TRANSPARENCY_PEN, machine->pens[color_base] );
copybitmap_trans(bitmap,tmpbitmaps[0],0,0,0,0,cliprect,machine->pens[color_base] );
fillbitmap(tmpbitmaps[0],machine->pens[color_base],NULL);
if (input_code_pressed_once(KEYCODE_1)) /* plane 1 */
@ -250,10 +250,10 @@ static VIDEO_UPDATE( greatgun )
//fillbitmap(bitmap,0,NULL);
copybitmap(bitmap,tmpbitmaps[3],0,0,0,0,&machine->screen[0].visarea,TRANSPARENCY_NONE, 0 );
copybitmap(bitmap,tmpbitmaps[2],0,0,0,0,&machine->screen[0].visarea,TRANSPARENCY_PEN, machine->pens[color_base] );
copybitmap(bitmap,tmpbitmaps[1],0,0,0,0,&machine->screen[0].visarea,TRANSPARENCY_PEN, machine->pens[color_base] );
copybitmap(bitmap,tmpbitmaps[0],0,0,0,0,&machine->screen[0].visarea,TRANSPARENCY_PEN, machine->pens[color_base] );
copybitmap (bitmap,tmpbitmaps[3],0,0,0,0,cliprect);
copybitmap_trans(bitmap,tmpbitmaps[2],0,0,0,0,cliprect,machine->pens[color_base] );
copybitmap_trans(bitmap,tmpbitmaps[1],0,0,0,0,cliprect,machine->pens[color_base] );
copybitmap_trans(bitmap,tmpbitmaps[0],0,0,0,0,cliprect,machine->pens[color_base] );
return 0;
}
@ -270,10 +270,10 @@ static VIDEO_UPDATE( mazerbla )
//fillbitmap(bitmap,0,NULL);
copybitmap(bitmap,tmpbitmaps[3],0,0,0,0,&machine->screen[0].visarea,TRANSPARENCY_NONE, 0 ); //text
copybitmap(bitmap,tmpbitmaps[2],0,0,0,0,&machine->screen[0].visarea,TRANSPARENCY_PEN, machine->pens[0] );
copybitmap(bitmap,tmpbitmaps[1],0,0,0,0,&machine->screen[0].visarea,TRANSPARENCY_PEN, machine->pens[0] ); //haircross
copybitmap(bitmap,tmpbitmaps[0],0,0,0,0,&machine->screen[0].visarea,TRANSPARENCY_PEN, machine->pens[0] ); //sprites
copybitmap (bitmap,tmpbitmaps[3],0,0,0,0,cliprect); //text
copybitmap_trans(bitmap,tmpbitmaps[2],0,0,0,0,cliprect,machine->pens[0] );
copybitmap_trans(bitmap,tmpbitmaps[1],0,0,0,0,cliprect,machine->pens[0] ); //haircross
copybitmap_trans(bitmap,tmpbitmaps[0],0,0,0,0,cliprect,machine->pens[0] ); //sprites
return 0;
}

2
src/mame/drivers/megadriv.c
View File

@ -2609,7 +2609,7 @@ VIDEO_START(megadriv)
VIDEO_UPDATE(megadriv)
{
/* Copy our screen buffer here */
copybitmap(bitmap, render_bitmap, 0, 0, 0, 0, cliprect, TRANSPARENCY_NONE, 0);
copybitmap(bitmap, render_bitmap, 0, 0, 0, 0, cliprect);
// int xxx;
/* reference */

2
src/mame/drivers/mlanding.c
View File

@ -270,7 +270,7 @@ static VIDEO_UPDATE(mlanding)
int i;
for(i=0;i<7;i++)
{
copybitmap(bitmap,ml_bitmap[i], 0, 0, 0, 0, cliprect, TRANSPARENCY_PEN, 0);
copybitmap_trans(bitmap,ml_bitmap[i], 0, 0, 0, 0, cliprect, 0);
}
}
status_bit=0;

2
src/mame/drivers/quizo.c
View File

@ -99,7 +99,7 @@ static VIDEO_UPDATE( quizo )
}
}
}
copybitmap(bitmap,tmpbitmap,0,0,0,0,&machine->screen[0].visarea,TRANSPARENCY_NONE,0);
copybitmap(bitmap,tmpbitmap,0,0,0,0,cliprect);
dirty=0;
return 0;
}

2
src/mame/drivers/sbowling.c
View File

@ -96,7 +96,7 @@ static VIDEO_UPDATE(sbowling)
{
fillbitmap(bitmap,machine->pens[0x18],cliprect);
tilemap_draw(bitmap,cliprect,sb_tilemap,0,0);
copybitmap(bitmap,tmpbitmap,0,0,0,0,cliprect, TRANSPARENCY_PEN, color_prom_address);
copybitmap_trans(bitmap,tmpbitmap,0,0,0,0,cliprect, color_prom_address);
return 0;
}

4
src/mame/drivers/sliver.c
View File

@ -447,8 +447,8 @@ static VIDEO_START(sliver)
static VIDEO_UPDATE(sliver)
{
copybitmap(bitmap, sliver_bitmap_bg, 0, 0, 0, 0, cliprect, TRANSPARENCY_NONE, 0);
copybitmap(bitmap, sliver_bitmap_fg, 0, 0, 0, 0, cliprect, TRANSPARENCY_PEN, 0);
copybitmap (bitmap, sliver_bitmap_bg, 0, 0, 0, 0, cliprect);
copybitmap_trans(bitmap, sliver_bitmap_fg, 0, 0, 0, 0, cliprect, 0);
return 0;
}

2
src/mame/drivers/tmaster.c
View File

@ -142,7 +142,7 @@ static VIDEO_START( tmaster )
static VIDEO_UPDATE( tmaster )
{
// double buffering
copybitmap(bitmap,tmaster_bitmap[(tmaster_regs[0x02/2]>>8)&1],0,0,0,0,&machine->screen[0].visarea,TRANSPARENCY_NONE,0);
copybitmap(bitmap,tmaster_bitmap[(tmaster_regs[0x02/2]>>8)&1],0,0,0,0,cliprect);
show_touchscreen();
return 0;

10
src/mame/drivers/wheelfir.c
View File

@ -301,9 +301,9 @@ static VIDEO_UPDATE(wheelfir)
if (base<0x000000) base = 0x000000;
if (base>0x3c0000) base = 0x3c0000;
copybitmap(bitmap, wheelfir_tmp_bitmap[2], 0, 0, 0, 0, cliprect, TRANSPARENCY_NONE, 0);
//copybitmap(bitmap, wheelfir_tmp_bitmap[1], 0, 0, 0, 0, cliprect, TRANSPARENCY_PEN, 0);
copybitmap(bitmap, wheelfir_tmp_bitmap[0], 0, 0, 0, 0, cliprect, TRANSPARENCY_PEN, 0);
copybitmap(bitmap, wheelfir_tmp_bitmap[2], 0, 0, 0, 0, cliprect);
//copybitmap_trans(bitmap, wheelfir_tmp_bitmap[1], 0, 0, 0, 0, cliprect, 0);
copybitmap_trans(bitmap, wheelfir_tmp_bitmap[0], 0, 0, 0, 0, cliprect, 0);
fillbitmap(wheelfir_tmp_bitmap[0], 0,&machine->screen[0].visarea);
if ( input_code_pressed(KEYCODE_R) )
@ -325,8 +325,8 @@ static VIDEO_UPDATE(wheelfir)
}
*/
copybitmap(bitmap, render_bitmap, 0, 0, 0, 0, cliprect, TRANSPARENCY_NONE, 0);
copybitmap(bitmap, wheelfir_tmp_bitmap[0], 0, 0, 0, 0, cliprect, TRANSPARENCY_PEN, 0);
copybitmap(bitmap, render_bitmap, 0, 0, 0, 0, cliprect);
copybitmap_trans(bitmap, wheelfir_tmp_bitmap[0], 0, 0, 0, 0, cliprect, 0);
{
int x;

4
src/mame/video/40love.c
View File

@ -333,9 +333,9 @@ static void draw_pixram( mame_bitmap *bitmap, const rectangle *cliprect )
}
if (pixram_sel)
copybitmap(bitmap,pixel_bitmap1,f,f,fortyl_xoffset,0,cliprect,TRANSPARENCY_NONE,0);
copybitmap(bitmap,pixel_bitmap1,f,f,fortyl_xoffset,0,cliprect);
else
copybitmap(bitmap,pixel_bitmap2,f,f,fortyl_xoffset,0,cliprect,TRANSPARENCY_NONE,0);
copybitmap(bitmap,pixel_bitmap2,f,f,fortyl_xoffset,0,cliprect);
}
VIDEO_UPDATE( fortyl )

6
src/mame/video/atarifb.c
View File

@ -116,9 +116,9 @@ static void draw_playfield_and_alpha(running_machine *machine, mame_bitmap *bitm
scroll_x[0] = - *atarifb_scroll_register + 32 + playfield_x_offset;
scroll_y[0] = 8 + playfield_y_offset;
copybitmap(bitmap, tilemap_get_pixmap(alpha1_tilemap), 0, 0, 35*8, 1*8, NULL, TRANSPARENCY_NONE, 0);
copybitmap(bitmap, tilemap_get_pixmap(alpha2_tilemap), 0, 0, 0*8, 1*8, NULL, TRANSPARENCY_NONE, 0);
copyscrollbitmap(bitmap, tilemap_get_pixmap(field_tilemap), 1, scroll_x, 1, scroll_y, &bigfield_area, TRANSPARENCY_NONE, 0);
copybitmap(bitmap, tilemap_get_pixmap(alpha1_tilemap), 0, 0, 35*8, 1*8, NULL);
copybitmap(bitmap, tilemap_get_pixmap(alpha2_tilemap), 0, 0, 0*8, 1*8, NULL);
copyscrollbitmap(bitmap, tilemap_get_pixmap(field_tilemap), 1, scroll_x, 1, scroll_y, &bigfield_area);
}

2
src/mame/video/atarig1.c
View File

@ -220,7 +220,7 @@ VIDEO_UPDATE( atarig1 )
tilemap_draw(bitmap, cliprect, atarigen_playfield_tilemap, 0, 0);
/* copy the motion objects on top */
copybitmap(bitmap, atarirle_get_vram(0, 0), 0, 0, 0, 0, cliprect, TRANSPARENCY_PEN, 0);
copybitmap_trans(bitmap, atarirle_get_vram(0, 0), 0, 0, 0, 0, cliprect, 0);
/* add the alpha on top */
tilemap_draw(bitmap, cliprect, atarigen_alpha_tilemap, 0, 0);

4
src/mame/video/battlera.c
View File

@ -365,7 +365,7 @@ static void screenrefresh(running_machine *machine, mame_bitmap *bitmap,const re
scrollx=-HuC6270_registers[7];
scrolly=-HuC6270_registers[8]+clip->min_y-1;
copyscrollbitmap(bitmap,tile_bitmap,1,&scrollx,1,&scrolly,clip,TRANSPARENCY_NONE,0);
copyscrollbitmap(bitmap,tile_bitmap,1,&scrollx,1,&scrolly,clip);
/* Todo: Background enable (not used anyway) */
@ -373,7 +373,7 @@ static void screenrefresh(running_machine *machine, mame_bitmap *bitmap,const re
if (sb_enable) draw_sprites(machine,bitmap,clip,0);
/* Render background over sprites */
copyscrollbitmap(bitmap,front_bitmap,1,&scrollx,1,&scrolly,clip,TRANSPARENCY_COLOR,256);
copyscrollbitmap_trans(bitmap,front_bitmap,1,&scrollx,1,&scrolly,clip,machine->pens[256]);
/* Render high priority sprites, if enabled */
if (sb_enable) draw_sprites(machine,bitmap,clip,1);

2
src/mame/video/bigevglf.c
View File

@ -90,7 +90,7 @@ static void draw_sprites(running_machine *machine, mame_bitmap *bitmap, const re
VIDEO_UPDATE( bigevglf )
{
copybitmap(bitmap,tmp_bitmap[ plane_visible ],0,0,0,0,cliprect,TRANSPARENCY_NONE, 0);
copybitmap(bitmap,tmp_bitmap[ plane_visible ],0,0,0,0,cliprect);
draw_sprites(machine,bitmap,cliprect);
return 0;
}

2
src/mame/video/blockout.c
View File

@ -108,7 +108,7 @@ WRITE16_HANDLER( blockout_videoram_w )
VIDEO_UPDATE( blockout )
{
copybitmap(bitmap,tmpbitmap,0,0,0,0,cliprect,TRANSPARENCY_NONE,0);
copybitmap(bitmap,tmpbitmap,0,0,0,0,cliprect);
{
int x,y;

2
src/mame/video/btime.c
View File

@ -584,7 +584,7 @@ VIDEO_UPDATE( bnj )
scroll = (bnj_scroll1 & 0x02) * 128 + 511 - bnj_scroll2;
if (!flip_screen)
scroll = 767-scroll;
copyscrollbitmap (bitmap, background_bitmap, 1, &scroll, 0, 0, cliprect,TRANSPARENCY_NONE, 0);
copyscrollbitmap (bitmap, background_bitmap, 1, &scroll, 0, 0, cliprect);
/* copy the low priority characters followed by the sprites
then the high priority characters */

4
src/mame/video/buggychl.c
View File

@ -130,13 +130,13 @@ static void draw_bg(running_machine *machine, mame_bitmap *bitmap, const rectang
for (offs = 0;offs < 256;offs++)
scroll[offs] = -buggychl_scrollv[offs/8];
copyscrollbitmap(tmpbitmap2,tmpbitmap1,1,&bg_scrollx,256,scroll,NULL,TRANSPARENCY_NONE,0);
copyscrollbitmap(tmpbitmap2,tmpbitmap1,1,&bg_scrollx,256,scroll,NULL);
/* then copy to the screen doing row scroll */
for (offs = 0;offs < 256;offs++)
scroll[offs] = -buggychl_scrollh[offs];
copyscrollbitmap(bitmap,tmpbitmap2,256,scroll,0,0,cliprect,TRANSPARENCY_COLOR,32);
copyscrollbitmap_trans(bitmap,tmpbitmap2,256,scroll,0,0,cliprect,machine->pens[32]);
}

8
src/mame/video/cclimber.c
View File

@ -395,7 +395,7 @@ VIDEO_UPDATE( cclimber )
}
}
copyscrollbitmap(bitmap,tmpbitmap,0,0,32,scroll,cliprect,TRANSPARENCY_NONE,0);
copyscrollbitmap(bitmap,tmpbitmap,0,0,32,scroll,cliprect);
}
@ -502,7 +502,7 @@ VIDEO_UPDATE( cannonb )
}
}
copyscrollbitmap(bitmap,tmpbitmap,0,0,32,scroll,cliprect,TRANSPARENCY_NONE,0);
copyscrollbitmap(bitmap,tmpbitmap,0,0,32,scroll,cliprect);
}
@ -606,7 +606,7 @@ VIDEO_UPDATE( swimmer )
scroll[offs] = -cclimber_column_scroll[offs];
}
copyscrollbitmap(bitmap,tmpbitmap,0,0,32,scroll,cliprect,TRANSPARENCY_NONE,0);
copyscrollbitmap(bitmap,tmpbitmap,0,0,32,scroll,cliprect);
}
@ -724,7 +724,7 @@ VIDEO_UPDATE( yamato )
}
}
copyscrollbitmap(bitmap,tmpbitmap,0,0,32,scroll,cliprect,TRANSPARENCY_PEN,0);
copyscrollbitmap(bitmap,tmpbitmap,0,0,32,scroll,cliprect);
}

8
src/mame/video/changela.c
View File

@ -743,10 +743,10 @@ static TIMER_CALLBACK( changela_scanline_callback )
VIDEO_UPDATE( changela )
{
copybitmap(bitmap, river_bitmap, 0, 0, 0, 0, &machine->screen[0].visarea, TRANSPARENCY_NONE, 0);
copybitmap(bitmap, obj0_bitmap, 0, 0, 0, 0, &machine->screen[0].visarea, TRANSPARENCY_PEN, 0);
copybitmap(bitmap, tree0_bitmap, 0, 0, 0, 0, &machine->screen[0].visarea, TRANSPARENCY_PEN, 0);
copybitmap(bitmap, tree1_bitmap, 0, 0, 0, 0, &machine->screen[0].visarea, TRANSPARENCY_PEN, 0);
copybitmap (bitmap, river_bitmap, 0, 0, 0, 0, cliprect);
copybitmap_trans(bitmap, obj0_bitmap, 0, 0, 0, 0, cliprect, 0);
copybitmap_trans(bitmap, tree0_bitmap, 0, 0, 0, 0, cliprect, 0);
copybitmap_trans(bitmap, tree1_bitmap, 0, 0, 0, 0, cliprect, 0);
draw_obj1(machine, bitmap);
return 0;

2
src/mame/video/cloak.c
View File

@ -226,7 +226,7 @@ static void draw_sprites(running_machine *machine, mame_bitmap *bitmap, const re
VIDEO_UPDATE( cloak )
{
tilemap_draw(bitmap, cliprect, bg_tilemap, 0, 0);
copybitmap(bitmap, (bmap ? tmpbitmap2 : tmpbitmap),flip_screen,flip_screen,0,0,cliprect,TRANSPARENCY_COLOR,16);
copybitmap_trans(bitmap, (bmap ? tmpbitmap2 : tmpbitmap),flip_screen,flip_screen,0,0,cliprect,machine->pens[16]);
draw_sprites(machine, bitmap, cliprect);
return 0;
}

4
src/mame/video/cvs.c
View File

@ -288,8 +288,8 @@ VIDEO_UPDATE( cvs )
scroll[6] = 0;
scroll[7] = 0;
copyscrollbitmap(bitmap,background_bitmap,0,0,8,scroll,&machine->screen[0].visarea,TRANSPARENCY_NONE,0);
copyscrollbitmap(scrolled_background,cvs_collision_background,0,0,8,scroll,&machine->screen[0].visarea,TRANSPARENCY_NONE,0);
copyscrollbitmap(bitmap,background_bitmap,0,0,8,scroll,&machine->screen[0].visarea);
copyscrollbitmap(scrolled_background,cvs_collision_background,0,0,8,scroll,&machine->screen[0].visarea);
/* 2636's */

19
src/mame/video/dday.c
View File

@ -346,34 +346,23 @@ VIDEO_UPDATE( dday )
if (sl_enable)
{
/* apply shadow */
mame_bitmap *sl_bitmap;
int x, y;
sl_bitmap = tilemap_get_pixmap(sl_tilemap);
mame_bitmap *sl_bitmap = tilemap_get_pixmap(sl_tilemap);
for (x = cliprect->min_x; x <= cliprect->max_x; x++)
{
for (y = cliprect->min_y; y <= cliprect->max_y; y++)
{
UINT32 src_pixel;
src_pixel = *BITMAP_ADDR16(main_bitmap, y, x);
UINT16 src_pixel = *BITMAP_ADDR16(main_bitmap, y, x);
if (*BITMAP_ADDR16(sl_bitmap, y, x) == 0xff)
{
src_pixel += machine->drv->total_colors;
}
*BITMAP_ADDR16(bitmap, y, x) = src_pixel;
}
}
}
else
{
copybitmap(bitmap,main_bitmap,0,0,0,0,cliprect,TRANSPARENCY_NONE,0);
}
copybitmap(bitmap,main_bitmap,0,0,0,0,cliprect);
return 0;
}

2
src/mame/video/dogfgt.c
View File

@ -238,6 +238,6 @@ VIDEO_UPDATE( dogfgt )
draw_sprites(machine, bitmap, cliprect);
copybitmap(bitmap,pixbitmap,0,0,0,0,cliprect,TRANSPARENCY_COLOR,PIXMAP_COLOR_BASE + 8*pixcolor);
copybitmap_trans(bitmap,pixbitmap,0,0,0,0,cliprect,machine->pens[PIXMAP_COLOR_BASE + 8*pixcolor]);
return 0;
}

2
src/mame/video/eolith.c
View File

@ -69,6 +69,6 @@ VIDEO_START( eolith )
VIDEO_UPDATE( eolith )
{
copybitmap(bitmap,bitmaps[eolith_buffer ^ 1],0,0,0,0,cliprect,TRANSPARENCY_NONE, 0);
copybitmap(bitmap,bitmaps[eolith_buffer ^ 1],0,0,0,0,cliprect);
return 0;
}

2
src/mame/video/exidy.c
View File

@ -377,7 +377,7 @@ VIDEO_UPDATE( exidy )
/* update the background and draw it */
draw_background();
copybitmap(bitmap, background_bitmap, 0, 0, 0, 0, cliprect, TRANSPARENCY_NONE, 0);
copybitmap(bitmap, background_bitmap, 0, 0, 0, 0, cliprect);
/* draw the sprites */
draw_sprites(machine, bitmap, NULL);

2
src/mame/video/finalizr.c
View File

@ -114,7 +114,7 @@ VIDEO_UPDATE( finalizr )
scroll = -*finalizr_scroll + 16;
copyscrollbitmap(bitmap,tmpbitmap,1,&scroll,0,0,cliprect,TRANSPARENCY_NONE,0);
copyscrollbitmap(bitmap,tmpbitmap,1,&scroll,0,0,cliprect);
}

2
src/mame/video/gaelco3d.c
View File

@ -490,7 +490,7 @@ VIDEO_UPDATE( gaelco3d )
else
{
if (video_changed)
copybitmap(bitmap, screenbits, 0,1, 0,0, cliprect, TRANSPARENCY_NONE, 0);
copybitmap(bitmap, screenbits, 0,1, 0,0, cliprect);
ret = video_changed;
video_changed = FALSE;
}

6
src/mame/video/galaxian.c
View File

@ -1710,7 +1710,7 @@ static void dambustr_draw_upper_background(mame_bitmap *bitmap)
clip.max_x = dambustr_bg_split_line;
clip.min_y = 0;
clip.max_y = 255;
copybitmap(bitmap, dambustr_tmpbitmap, 0, 0, 0, 0, &clip, TRANSPARENCY_NONE, 0);
copybitmap(bitmap, dambustr_tmpbitmap, 0, 0, 0, 0, &clip);
}
else
{
@ -1718,7 +1718,7 @@ static void dambustr_draw_upper_background(mame_bitmap *bitmap)
clip.max_x = 254 - dambustr_bg_split_line;
clip.min_y = 0;
clip.max_y = 255;
copybitmap(bitmap, dambustr_tmpbitmap, 0, 0, 0, 0, &clip, TRANSPARENCY_NONE, 0);
copybitmap(bitmap, dambustr_tmpbitmap, 0, 0, 0, 0, &clip);
}
}
@ -2214,7 +2214,7 @@ VIDEO_UPDATE( dambustr )
}
/* save the background for drawing it again later, if background has priority over characters */
copybitmap(dambustr_tmpbitmap, bitmap, 0, 0, 0, 0, &machine->screen[0].visarea, TRANSPARENCY_NONE, 0);
copybitmap(dambustr_tmpbitmap, bitmap, 0, 0, 0, 0, &machine->screen[0].visarea);
tilemap_draw(bitmap, 0, bg_tilemap, 0, 0);

18
src/mame/video/galpani2.c
View File

@ -171,9 +171,9 @@ if (input_code_pressed(KEYCODE_Z))
{
int x = 0;
int y = 0;
copyscrollbitmap( bitmap, galpani2_bg15_bitmap,
1, &x, 1, &y,
cliprect,TRANSPARENCY_PEN,machine->pens[0x4200 + 0]);
copyscrollbitmap_trans(bitmap, galpani2_bg15_bitmap,
1, &x, 1, &y,
cliprect,machine->pens[0x4200 + 0]);
}
/* test mode:
@ -186,18 +186,18 @@ if (input_code_pressed(KEYCODE_Z))
{
int x = - ( *galpani2_bg8_0_scrollx + 0x200 - 0x0f5 );
int y = - ( *galpani2_bg8_0_scrolly + 0x200 - 0x1be );
copyscrollbitmap( bitmap, galpani2_bg8_bitmap_0,
1, &x, 1, &y,
cliprect,TRANSPARENCY_PEN,machine->pens[0x4000 + 0]);
copyscrollbitmap_trans(bitmap, galpani2_bg8_bitmap_0,
1, &x, 1, &y,
cliprect,machine->pens[0x4000 + 0]);
}
if (layers_ctrl & 0x4)
{
int x = - ( *galpani2_bg8_1_scrollx + 0x200 - 0x0f5 );
int y = - ( *galpani2_bg8_1_scrolly + 0x200 - 0x1be );
copyscrollbitmap( bitmap, galpani2_bg8_bitmap_1,
1, &x, 1, &y,
cliprect,TRANSPARENCY_PEN,machine->pens[0x4000 + 0]);
copyscrollbitmap_trans(bitmap, galpani2_bg8_bitmap_1,
1, &x, 1, &y,
cliprect,machine->pens[0x4000 + 0]);
}
if (layers_ctrl & 0x8) kaneko16_draw_sprites(machine, bitmap, cliprect);

6
src/mame/video/galpanic.c
View File

@ -105,7 +105,7 @@ static void draw_fgbitmap(running_machine *machine, mame_bitmap *bitmap, const r
VIDEO_UPDATE( galpanic )
{
/* copy the temporary bitmap to the screen */
copybitmap(bitmap,tmpbitmap,0,0,0,0,cliprect,TRANSPARENCY_NONE,0);
copybitmap(bitmap,tmpbitmap,0,0,0,0,cliprect);
draw_fgbitmap(machine, bitmap, cliprect);
@ -117,7 +117,7 @@ VIDEO_UPDATE( galpanic )
VIDEO_UPDATE( comad )
{
/* copy the temporary bitmap to the screen */
copybitmap(bitmap,tmpbitmap,0,0,0,0,cliprect,TRANSPARENCY_NONE,0);
copybitmap(bitmap,tmpbitmap,0,0,0,0,cliprect);
draw_fgbitmap(machine,bitmap,cliprect);
@ -131,7 +131,7 @@ VIDEO_UPDATE( comad )
// {
// /* keep sprites on the bitmap without clearing them */
// comad_draw_sprites(machine,sprites_bitmap,0);
// copybitmap(bitmap,sprites_bitmap,0,0,0,0,cliprect,TRANSPARENCY_PEN,0);
// copybitmap_trans(bitmap,sprites_bitmap,0,0,0,0,cliprect,0);
// }
return 0;
}

2
src/mame/video/galspnbl.c
View File

@ -114,7 +114,7 @@ VIDEO_UPDATE( galspnbl )
/* copy the temporary bitmap to the screen */
copyscrollbitmap(bitmap,tmpbitmap,1,&screenscroll,0,0,cliprect,TRANSPARENCY_NONE,0);
copyscrollbitmap(bitmap,tmpbitmap,1,&screenscroll,0,0,cliprect);
draw_sprites(machine,bitmap,cliprect,0);

2
src/mame/video/glass.c
View File

@ -204,7 +204,7 @@ VIDEO_UPDATE( glass )
/* draw layers + sprites */
fillbitmap(bitmap, get_black_pen(machine), cliprect);
copybitmap(bitmap,screen_bitmap,0,0,0x18,0x24,cliprect,TRANSPARENCY_NONE,0);
copybitmap(bitmap,screen_bitmap,0,0,0x18,0x24,cliprect);
tilemap_draw(bitmap,cliprect,pant[1],0,0);
tilemap_draw(bitmap,cliprect,pant[0],0,0);
draw_sprites(machine,bitmap,cliprect);

14
src/mame/video/goldstar.c
View File

@ -77,7 +77,7 @@ VIDEO_UPDATE( goldstar )
0,TRANSPARENCY_NONE,0);
}
copybitmap(bitmap,tmpbitmap4,0,0,0,0,cliprect,TRANSPARENCY_NONE,0);
copybitmap(bitmap,tmpbitmap4,0,0,0,0,cliprect);
for (offs = goldstar_video_size - 1;offs >= 0;offs--)
@ -114,20 +114,20 @@ VIDEO_UPDATE( goldstar )
for (i= 0;i < 64;i++)
scrolly[i] = -goldstar_scroll1[i];
copyscrollbitmap(bitmap,tmpbitmap1,0,0,64,scrolly,&visible1,TRANSPARENCY_NONE,0);
copybitmap(bitmap,tmpbitmap4,0,0,0,0,&visible1,TRANSPARENCY_PEN,0);
copyscrollbitmap(bitmap,tmpbitmap1,0,0,64,scrolly,&visible1);
copybitmap_trans(bitmap,tmpbitmap4,0,0,0,0,&visible1,0);
for (i= 0;i < 64;i++)
scrolly[i] = -goldstar_scroll2[i];
copyscrollbitmap(bitmap,tmpbitmap2,0,0,64,scrolly,&visible2,TRANSPARENCY_NONE,0);
copybitmap(bitmap,tmpbitmap4,0,0,0,0,&visible2,TRANSPARENCY_PEN,0);
copyscrollbitmap(bitmap,tmpbitmap2,0,0,64,scrolly,&visible2);
copybitmap_trans(bitmap,tmpbitmap4,0,0,0,0,&visible2,0);
for (i= 0;i < 64;i++)
scrolly[i] = -goldstar_scroll3[i];
copyscrollbitmap(bitmap,tmpbitmap3,0,0,64,scrolly,&visible3,TRANSPARENCY_NONE,0);
copybitmap(bitmap,tmpbitmap4,0,0,0,0,&visible3,TRANSPARENCY_PEN,0);
copyscrollbitmap(bitmap,tmpbitmap3,0,0,64,scrolly,&visible3);
copybitmap_trans(bitmap,tmpbitmap4,0,0,0,0,&visible3,0);
}
return 0;
}

2
src/mame/video/gomoku.c
View File

@ -167,7 +167,7 @@ VIDEO_UPDATE( gomoku )
if (gomoku_bg_dispsw)
{
/* copy bg bitmap */
copybitmap(bitmap, gomoku_bg_bitmap, 0, 0, 0, 0, cliprect, TRANSPARENCY_NONE, 0);
copybitmap(bitmap, gomoku_bg_bitmap, 0, 0, 0, 0, cliprect);
// stone
for (y = 0; y < 256; y++)

2
src/mame/video/hyhoo.c
View File

@ -239,7 +239,7 @@ VIDEO_START( hyhoo )
VIDEO_UPDATE( hyhoo )
{
if (hyhoo_dispflag)
copybitmap(bitmap, hyhoo_tmpbitmap, hyhoo_flipscreen, hyhoo_flipscreen, 0, 0, cliprect, TRANSPARENCY_NONE, 0);
copybitmap(bitmap, hyhoo_tmpbitmap, hyhoo_flipscreen, hyhoo_flipscreen, 0, 0, cliprect);
else
fillbitmap(bitmap, RGB_BLACK, cliprect);

8
src/mame/video/ikki.c
View File

@ -119,7 +119,7 @@ VIDEO_UPDATE( ikki )
col,
f,f,
px,py,
&machine->screen[0].visarea,TRANSPARENCY_NONE,0);
cliprect,TRANSPARENCY_NONE,0);
}
/* draw sprites */
@ -156,10 +156,10 @@ VIDEO_UPDATE( ikki )
col,
f,f,
px,py,
&machine->screen[0].visarea,TRANSPARENCY_COLOR,0);
cliprect,TRANSPARENCY_COLOR,0);
}
copybitmap(bitmap,tmpbitmap,0,0,0,0,&machine->screen[0].visarea,TRANSPARENCY_COLOR,256);
copybitmap_trans(bitmap,tmpbitmap,0,0,0,0,cliprect,machine->pens[256]);
/* mask sprites */
@ -193,7 +193,7 @@ VIDEO_UPDATE( ikki )
col,
f,f,
px,py,
&machine->screen[0].visarea,TRANSPARENCY_NONE,0);
cliprect,TRANSPARENCY_NONE,0);
}
}

2
src/mame/video/jaguar.c
View File

@ -838,7 +838,7 @@ VIDEO_UPDATE( cojag )
}
/* render the object list */
copybitmap(bitmap, screen_bitmap, 0, 0, 0, 0, cliprect, TRANSPARENCY_NONE, 0);
copybitmap(bitmap, screen_bitmap, 0, 0, 0, 0, cliprect);
return 0;
}

2
src/mame/video/kan_pand.c
View File

@ -67,7 +67,7 @@ void pandora_update(running_machine *machine, mame_bitmap *bitmap, const rectang
return;
}
copybitmap(bitmap,pandora_sprites_bitmap,0,0,0,0,cliprect,TRANSPARENCY_PEN,0);
copybitmap_trans(bitmap,pandora_sprites_bitmap,0,0,0,0,cliprect,0);
}

8
src/mame/video/kaneko16.c
View File

@ -905,7 +905,7 @@ static void kaneko16_render_sprites(running_machine *machine, mame_bitmap *bitma
{
/* keep sprites on screen */
kaneko16_draw_sprites(machine,sprites_bitmap,cliprect);
copybitmap(bitmap,sprites_bitmap,0,0,0,0,cliprect,TRANSPARENCY_PEN,0);
copybitmap_trans(bitmap,sprites_bitmap,0,0,0,0,cliprect,0);
}
else
{
@ -928,11 +928,7 @@ static void kaneko16_render_15bpp_bitmap(running_machine *machine, mame_bitmap *
sx = (select & 0x1f) * 256;
sy = 0;
copybitmap(
bitmap, kaneko16_bg15_bitmap,
flip, flip,
-sx, -sy,
cliprect, TRANSPARENCY_NONE,0 );
copybitmap(bitmap, kaneko16_bg15_bitmap, flip, flip, -sx, -sy, cliprect);
// flag = 0;
}

8
src/mame/video/kangaroo.c
View File

@ -296,14 +296,14 @@ VIDEO_UPDATE( kangaroo )
if (*kangaroo_bank_select & 0x01)
{
/* Plane B is primary */
copybitmap(bitmap,tmpbitmap2,0,0,0,0,&machine->screen[0].visarea,TRANSPARENCY_NONE,0);
copyscrollbitmap(bitmap,tmpbitmap,1,&scrollx,1,&scrolly,&machine->screen[0].visarea,TRANSPARENCY_COLOR,8);
copybitmap(bitmap,tmpbitmap2,0,0,0,0,cliprect);
copyscrollbitmap_trans(bitmap,tmpbitmap,1,&scrollx,1,&scrolly,cliprect,machine->pens[8]);
}
else
{
/* Plane A is primary */
copyscrollbitmap(bitmap,tmpbitmap,1,&scrollx,1,&scrolly,&machine->screen[0].visarea,TRANSPARENCY_NONE,0);
copybitmap(bitmap,tmpbitmap2,0,0,0,0,&machine->screen[0].visarea,TRANSPARENCY_COLOR,16);
copyscrollbitmap(bitmap,tmpbitmap,1,&scrollx,1,&scrolly,cliprect);
copybitmap_trans(bitmap,tmpbitmap2,0,0,0,0,cliprect,machine->pens[16]);
}
return 0;
}

2
src/mame/video/karnov.c
View File

@ -136,7 +136,7 @@ static void draw_background(running_machine *machine, mame_bitmap *bitmap, const
scrolly=scrolly+256;
scrollx=scrollx+256;
}
copyscrollbitmap(bitmap,bitmap_f,1,&scrollx,1,&scrolly,cliprect,TRANSPARENCY_NONE,0);
copyscrollbitmap(bitmap,bitmap_f,1,&scrollx,1,&scrolly,cliprect);
}
static void draw_sprites(running_machine *machine, mame_bitmap *bitmap,const rectangle *cliprect)

6
src/mame/video/lemmings.c
View File

@ -183,14 +183,14 @@ VIDEO_UPDATE( lemmings )
/* Pixel layer can be windowed in hardware (two player mode) */
if ((lemmings_control_data[6]&2)==0) {
copyscrollbitmap(bitmap,bitmap0,1,&x1,1,&y,cliprect,TRANSPARENCY_PEN,0x100);
copyscrollbitmap_trans(bitmap,bitmap0,1,&x1,1,&y,cliprect,0x100);
} else {
rect.max_x=159;
rect.min_x=0;
copyscrollbitmap(bitmap,bitmap0,1,&x0,1,&y,&rect,TRANSPARENCY_PEN,0x100);
copyscrollbitmap_trans(bitmap,bitmap0,1,&x0,1,&y,&rect,0x100);
rect.max_x=319;
rect.min_x=160;
copyscrollbitmap(bitmap,bitmap0,1,&x1,1,&y,&rect,TRANSPARENCY_PEN,0x100);
copyscrollbitmap_trans(bitmap,bitmap0,1,&x1,1,&y,&rect,0x100);
}
draw_sprites(machine,bitmap,cliprect,sprite_triple_buffer_0,0,0x0000);
draw_sprites(machine,bitmap,cliprect,sprite_triple_buffer_1,1,0x2000);

11
src/mame/video/magmax.c
View File

@ -122,7 +122,7 @@ VIDEO_UPDATE( magmax )
/* copy the background graphics */
if (magmax_vreg & 0x40) /* background disable */
{
fillbitmap(bitmap, machine->pens[0], &machine->screen[0].visarea);
fillbitmap(bitmap, machine->pens[0], cliprect);
}
else
{
@ -334,13 +334,12 @@ VIDEO_UPDATE( magmax )
color,
flipx, flipy,
sx, sy,
&machine->screen[0].visarea, TRANSPARENCY_COLOR, 31);
cliprect, TRANSPARENCY_COLOR, 31);
}
}
if (!(magmax_vreg & 0x40)) /* background disable */
{
copybitmap(bitmap, tmpbitmap, flipscreen,flipscreen,0,0, &machine->screen[0].visarea, TRANSPARENCY_PEN, 0);
}
copybitmap_trans(bitmap, tmpbitmap, flipscreen,flipscreen,0,0, cliprect, 0);
/* draw the foreground characters */
@ -366,7 +365,7 @@ VIDEO_UPDATE( magmax )
0,
flipscreen, flipscreen,
8 * sx, 8 * sy,
&machine->screen[0].visarea, TRANSPARENCY_PEN, 15);
cliprect, TRANSPARENCY_PEN, 15);
}
}
return 0;

2
src/mame/video/mappy.c
View File

@ -538,7 +538,7 @@ VIDEO_UPDATE( superpac )
fillbitmap(sprite_bitmap,15,cliprect);
mappy_draw_sprites(machine,sprite_bitmap,cliprect,0,0,15);
copybitmap(bitmap,sprite_bitmap,0,0,0,0,cliprect,TRANSPARENCY_PEN,15);
copybitmap_trans(bitmap,sprite_bitmap,0,0,0,0,cliprect,15);
/* Redraw the high priority characters */
tilemap_draw(bitmap,cliprect,bg_tilemap,1,0);

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

@ -181,9 +181,9 @@ VIDEO_UPDATE( matmania )
scrolly = -*matmania_scroll;
if (matmania_pageselect[0]&0x01) // maniach sets 0x20 sometimes, which must have a different meaning
copyscrollbitmap(bitmap,tmpbitmap2,0,0,1,&scrolly,&machine->screen[0].visarea,TRANSPARENCY_NONE,0);
copyscrollbitmap(bitmap,tmpbitmap2,0,0,1,&scrolly,cliprect);
else
copyscrollbitmap(bitmap,tmpbitmap,0,0,1,&scrolly,&machine->screen[0].visarea,TRANSPARENCY_NONE,0);
copyscrollbitmap(bitmap,tmpbitmap,0,0,1,&scrolly,cliprect);
}
@ -197,7 +197,7 @@ VIDEO_UPDATE( matmania )
(spriteram[offs] & 0x08) >> 3,
spriteram[offs] & 0x04,spriteram[offs] & 0x02,
239 - spriteram[offs+3],(240 - spriteram[offs+2]) & 0xff,
&machine->screen[0].visarea,TRANSPARENCY_PEN,0);
cliprect,TRANSPARENCY_PEN,0);
}
}
@ -216,7 +216,7 @@ VIDEO_UPDATE( matmania )
(matmania_colorram2[offs] & 0x30) >> 4,
0,0,
8*sx,8*sy,
&machine->screen[0].visarea,TRANSPARENCY_PEN,0);
cliprect,TRANSPARENCY_PEN,0);
}
return 0;
}
@ -269,9 +269,9 @@ VIDEO_UPDATE( maniach )
scrolly = -*matmania_scroll;
if (matmania_pageselect[0]&0x01) // this sets 0x20 sometimes, which must have a different meaning
copyscrollbitmap(bitmap,tmpbitmap2,0,0,1,&scrolly,&machine->screen[0].visarea,TRANSPARENCY_NONE,0);
copyscrollbitmap(bitmap,tmpbitmap2,0,0,1,&scrolly,cliprect);
else
copyscrollbitmap(bitmap,tmpbitmap,0,0,1,&scrolly,&machine->screen[0].visarea,TRANSPARENCY_NONE,0);
copyscrollbitmap(bitmap,tmpbitmap,0,0,1,&scrolly,cliprect);
}
@ -285,7 +285,7 @@ VIDEO_UPDATE( maniach )
(spriteram[offs] & 0x08) >> 3,
spriteram[offs] & 0x04,spriteram[offs] & 0x02,
239 - spriteram[offs+3],(240 - spriteram[offs+2]) & 0xff,
&machine->screen[0].visarea,TRANSPARENCY_PEN,0);
cliprect,TRANSPARENCY_PEN,0);
}
}
@ -304,7 +304,7 @@ VIDEO_UPDATE( maniach )
(matmania_colorram2[offs] & 0x30) >> 4,
0,0,
8*sx,8*sy,
&machine->screen[0].visarea,TRANSPARENCY_PEN,0);
cliprect,TRANSPARENCY_PEN,0);
}
return 0;
}

6
src/mame/video/megazone.c
View File

@ -141,7 +141,7 @@ VIDEO_UPDATE( megazone )
}
copyscrollbitmap(bitmap,tmpbitmap,1,&scrollx,1,&scrolly,&machine->screen[0].visarea,TRANSPARENCY_NONE,0);
copyscrollbitmap(bitmap,tmpbitmap,1,&scrollx,1,&scrolly,cliprect);
}
@ -165,7 +165,7 @@ VIDEO_UPDATE( megazone )
spriteram[offs + 0] & 0x0f,
flipx,flipy,
sx,sy,
&machine->screen[0].visarea,TRANSPARENCY_COLOR,0);
cliprect,TRANSPARENCY_COLOR,0);
}
}
@ -198,7 +198,7 @@ VIDEO_UPDATE( megazone )
(megazone_colorram2[offs] & 0x0f) + 0x10,
flipx,flipy,
8*sx,8*sy,
0,TRANSPARENCY_NONE,0);
cliprect,TRANSPARENCY_NONE,0);
offs++;
}
}

4
src/mame/video/mjsister.c
View File

@ -103,8 +103,8 @@ VIDEO_UPDATE( mjsister )
*BITMAP_ADDR16(bitmap, i, 256+j) = machine->pens[mjsister_colorbank * 0x20];
}
copybitmap(bitmap,mjsister_tmpbitmap0,f,f,0,0,cliprect,TRANSPARENCY_NONE,0);
copybitmap(bitmap,mjsister_tmpbitmap1,f,f,2,0,cliprect,TRANSPARENCY_PEN,0);
copybitmap (bitmap,mjsister_tmpbitmap0,f,f,0,0,cliprect);
copybitmap_trans(bitmap,mjsister_tmpbitmap1,f,f,2,0,cliprect,0);
}
else
fillbitmap(bitmap, get_black_pen(machine), &machine->screen[0].visarea);

2
src/mame/video/model3.c
View File

@ -413,7 +413,7 @@ VIDEO_UPDATE( model3 )
// fillbitmap(bitmap3d, 0x8000, cliprect);
// real3d_traverse_display_list();
// }
copybitmap(bitmap, bitmap3d, 0, 0, 0, 0, cliprect, TRANSPARENCY_PEN, 0x8000);
copybitmap_trans(bitmap, bitmap3d, 0, 0, 0, 0, cliprect, 0x8000);
}
if (!(debug_layer_disable & 0x2))

4
src/mame/video/munchmo.c
View File

@ -124,9 +124,7 @@ static void draw_background(running_machine *machine, mame_bitmap *bitmap, const
int scrollx = -(mnchmobl_vreg[6]*2+(mnchmobl_vreg[7]>>7))-64-128-16;
int scrolly = 0;
copyscrollbitmap(bitmap,tmpbitmap,
1,&scrollx,1,&scrolly,
cliprect,TRANSPARENCY_NONE,0);
copyscrollbitmap(bitmap,tmpbitmap, 1,&scrollx,1,&scrolly, cliprect);
}
}

6
src/mame/video/naughtyb.c
View File

@ -285,11 +285,11 @@ VIDEO_UPDATE( naughtyb )
{
int scrollx;
copybitmap(bitmap,tmpbitmap,0,0,-66*8,0,&leftvisiblearea,TRANSPARENCY_NONE,0);
copybitmap(bitmap,tmpbitmap,0,0,-30*8,0,&rightvisiblearea,TRANSPARENCY_NONE,0);
copybitmap(bitmap,tmpbitmap,0,0,-66*8,0,&leftvisiblearea);
copybitmap(bitmap,tmpbitmap,0,0,-30*8,0,&rightvisiblearea);
scrollx = ( naughtyb_cocktail ) ? *naughtyb_scrollreg - 239 : -*naughtyb_scrollreg + 16;
copyscrollbitmap(bitmap,tmpbitmap,1,&scrollx,0,0,&scrollvisiblearea,TRANSPARENCY_NONE,0);
copyscrollbitmap(bitmap,tmpbitmap,1,&scrollx,0,0,&scrollvisiblearea);
}
return 0;
}

4
src/mame/video/nbmj8688.c
View File

@ -698,8 +698,8 @@ VIDEO_UPDATE( mbmj8688 )
if (mjsikaku_flipscreen) scrolly = mjsikaku_scrolly;
else scrolly = (-mjsikaku_scrolly) & 0xff;
copybitmap(bitmap, mjsikaku_tmpbitmap, 0, 0, 0, scrolly, cliprect, TRANSPARENCY_NONE, 0);
copybitmap(bitmap, mjsikaku_tmpbitmap, 0, 0, 0, scrolly - 256, cliprect, TRANSPARENCY_NONE, 0);
copybitmap(bitmap, mjsikaku_tmpbitmap, 0, 0, 0, scrolly, cliprect);
copybitmap(bitmap, mjsikaku_tmpbitmap, 0, 0, 0, scrolly - 256, cliprect);
}
else
{

11
src/mame/video/nbmj8891.c
View File

@ -554,17 +554,14 @@ VIDEO_UPDATE( nbmj8891 )
if (gfxdraw_mode)
{
copyscrollbitmap(bitmap, nbmj8891_tmpbitmap0, 0, 0, 0, 0, &machine->screen[0].visarea, TRANSPARENCY_NONE, 0);
copyscrollbitmap(bitmap, nbmj8891_tmpbitmap1, 0, 0, 1, &scrolly, &machine->screen[0].visarea, TRANSPARENCY_PEN, machine->pens[0xff]);
copyscrollbitmap (bitmap, nbmj8891_tmpbitmap0, 0, 0, 0, 0, cliprect);
copyscrollbitmap_trans(bitmap, nbmj8891_tmpbitmap1, 0, 0, 1, &scrolly, cliprect, machine->pens[0xff]);
}
else
{
copyscrollbitmap(bitmap, nbmj8891_tmpbitmap0, 0, 0, 1, &scrolly, &machine->screen[0].visarea, TRANSPARENCY_NONE, 0);
}
copyscrollbitmap(bitmap, nbmj8891_tmpbitmap0, 0, 0, 1, &scrolly, cliprect);
}
else
{
fillbitmap(bitmap, machine->pens[0xff], 0);
}
return 0;
}

10
src/mame/video/nbmj8991.c
View File

@ -335,12 +335,11 @@ VIDEO_UPDATE( nbmj8991_type1 )
scrolly = (( nbmj8991_scrolly) + 0x0f1) & 0x1ff;
}
copyscrollbitmap(bitmap, nbmj8991_tmpbitmap, 1, &scrollx, 1, &scrolly, &machine->screen[0].visarea, TRANSPARENCY_NONE, 0);
copyscrollbitmap(bitmap, nbmj8991_tmpbitmap, 1, &scrollx, 1, &scrolly, cliprect);
}
else
{
fillbitmap(bitmap, machine->pens[0x00], 0);
}
return 0;
}
@ -376,11 +375,10 @@ VIDEO_UPDATE( nbmj8991_type2 )
scrolly = (( nbmj8991_scrolly) + 0x0f1) & 0x1ff;
}
copyscrollbitmap(bitmap, nbmj8991_tmpbitmap, 1, &scrollx, 1, &scrolly, &machine->screen[0].visarea, TRANSPARENCY_NONE, 0);
copyscrollbitmap(bitmap, nbmj8991_tmpbitmap, 1, &scrollx, 1, &scrolly, cliprect);
}
else
{
fillbitmap(bitmap, machine->pens[0x00], 0);
}
return 0;
}

15
src/mame/video/nbmj9195.c
View File

@ -501,27 +501,20 @@ VIDEO_UPDATE( nbmj9195 )
}
if (nbmj9195_dispflag[0])
{
// nbmj9195 1layer
copyscrollbitmap(bitmap, nbmj9195_tmpbitmap[0], SCANLINE_MAX, nbmj9195_scrollx_raster[0], 1, &scrolly[0], &machine->screen[0].visarea, TRANSPARENCY_NONE, 0);
}
copyscrollbitmap(bitmap, nbmj9195_tmpbitmap[0], SCANLINE_MAX, nbmj9195_scrollx_raster[0], 1, &scrolly[0], cliprect);
else
{
fillbitmap(bitmap, machine->pens[0x0ff], 0);
}
if (nbmj9195_dispflag[1])
{
if (gfxdraw_mode == 1)
{
// nbmj9195 2layer
copyscrollbitmap(bitmap, nbmj9195_tmpbitmap[1], SCANLINE_MAX, nbmj9195_scrollx_raster[1], 1, &scrolly[1], &machine->screen[0].visarea, TRANSPARENCY_PEN, machine->pens[0x0ff]);
}
copyscrollbitmap_trans(bitmap, nbmj9195_tmpbitmap[1], SCANLINE_MAX, nbmj9195_scrollx_raster[1], 1, &scrolly[1], cliprect, machine->pens[0x0ff]);
if (gfxdraw_mode == 2)
{
// nbmj9195 nb22090 2layer
copyscrollbitmap(bitmap, nbmj9195_tmpbitmap[1], SCANLINE_MAX, nbmj9195_scrollx_raster[1], 1, &scrolly[1], &machine->screen[0].visarea, TRANSPARENCY_PEN, machine->pens[0x1ff]);
}
copyscrollbitmap_trans(bitmap, nbmj9195_tmpbitmap[1], SCANLINE_MAX, nbmj9195_scrollx_raster[1], 1, &scrolly[1], cliprect, machine->pens[0x1ff]);
}
return 0;
}

6
src/mame/video/ninjakd2.c
View File

@ -443,7 +443,7 @@ VIDEO_UPDATE( ninjakd2 )
tilemap_draw(bitmap, cliprect, bg_tilemap, 0, 0);
copybitmap(bitmap, sp_bitmap, 0, 0, 0, 0, cliprect, TRANSPARENCY_PEN, 15);
copybitmap_trans(bitmap, sp_bitmap, 0, 0, 0, 0, cliprect, 15);
tilemap_draw(bitmap, cliprect, fg_tilemap, 0, 0);
@ -458,7 +458,7 @@ VIDEO_UPDATE( robokid )
tilemap_draw(bitmap, cliprect, bg1_tilemap, 0, 0);
copybitmap(bitmap, sp_bitmap, 0, 0, 0, 0, cliprect, TRANSPARENCY_PEN, 15);
copybitmap_trans(bitmap, sp_bitmap, 0, 0, 0, 0, cliprect, 15);
tilemap_draw(bitmap, cliprect, bg2_tilemap, 0, 0);
@ -477,7 +477,7 @@ VIDEO_UPDATE( omegaf )
tilemap_draw(bitmap, cliprect, bg2_tilemap, 0, 0);
copybitmap(bitmap, sp_bitmap, 0, 0, 0, 0, cliprect, TRANSPARENCY_PEN, 15);
copybitmap_trans(bitmap, sp_bitmap, 0, 0, 0, 0, cliprect, 15);
tilemap_draw(bitmap, cliprect, fg_tilemap, 0, 0);

15
src/mame/video/niyanpai.c
View File

@ -434,22 +434,15 @@ VIDEO_UPDATE( niyanpai )
}
if (niyanpai_dispflag[0])
{
copyscrollbitmap(bitmap, niyanpai_tmpbitmap[0], 1, &scrollx[0], 1, &scrolly[0], &machine->screen[0].visarea, TRANSPARENCY_NONE, 0);
}
copyscrollbitmap(bitmap, niyanpai_tmpbitmap[0], 1, &scrollx[0], 1, &scrolly[0], cliprect);
else
{
fillbitmap(bitmap, machine->pens[0x00ff], 0);
}
if (niyanpai_dispflag[1])
{
copyscrollbitmap(bitmap, niyanpai_tmpbitmap[1], 1, &scrollx[1], 1, &scrolly[1], &machine->screen[0].visarea, TRANSPARENCY_PEN, machine->pens[0x01ff]);
}
copyscrollbitmap_trans(bitmap, niyanpai_tmpbitmap[1], 1, &scrollx[1], 1, &scrolly[1], cliprect, machine->pens[0x01ff]);
if (niyanpai_dispflag[2])
{
copyscrollbitmap(bitmap, niyanpai_tmpbitmap[2], 1, &scrollx[2], 1, &scrolly[2], &machine->screen[0].visarea, TRANSPARENCY_PEN, machine->pens[0x02ff]);
}
copyscrollbitmap_trans(bitmap, niyanpai_tmpbitmap[2], 1, &scrollx[2], 1, &scrolly[2], cliprect, machine->pens[0x02ff]);
return 0;
}

2
src/mame/video/nmk16.c
View File

@ -800,7 +800,7 @@ VIDEO_UPDATE( bioship )
}
}
copyscrollbitmap(bitmap,background_bitmap,1,&scrollx,1,&scrolly,cliprect,TRANSPARENCY_NONE,0);
copyscrollbitmap(bitmap,background_bitmap,1,&scrollx,1,&scrolly,cliprect);
tilemap_draw(bitmap,cliprect,bg_tilemap,0,0);
nmk16_draw_sprites(machine, bitmap,cliprect,3);

2
src/mame/video/ojankohs.c
View File

@ -329,6 +329,6 @@ VIDEO_UPDATE( ojankoc )
ojankoc_screen_refresh = 0;
}
copybitmap(bitmap, ojankoc_tmpbitmap, 0, 0, 0, 0, cliprect, TRANSPARENCY_NONE, 0);
copybitmap(bitmap, ojankoc_tmpbitmap, 0, 0, 0, 0, cliprect);
return 0;
}

2
src/mame/video/paradise.c
View File

@ -259,7 +259,7 @@ if (input_code_pressed(KEYCODE_Z))
if (layers_ctrl&1) tilemap_draw(bitmap,cliprect, tilemap_0, 0,0);
if (layers_ctrl&2) tilemap_draw(bitmap,cliprect, tilemap_1, 0,0);
if (layers_ctrl&4) copybitmap(bitmap,tmpbitmap,flip_screen,flip_screen,0,0,cliprect,TRANSPARENCY_PEN, 0x80f);
if (layers_ctrl&4) copybitmap_trans(bitmap,tmpbitmap,flip_screen,flip_screen,0,0,cliprect, 0x80f);
if (paradise_priority & 2)
{

7
src/mame/video/pastelg.c
View File

@ -293,12 +293,9 @@ VIDEO_UPDATE( pastelg )
}
if (pastelg_dispflag)
{
copybitmap(bitmap, pastelg_tmpbitmap, 0, 0, 0, 0, &machine->screen[0].visarea, TRANSPARENCY_NONE, 0);
}
copybitmap(bitmap, pastelg_tmpbitmap, 0, 0, 0, 0, cliprect);
else
{
fillbitmap(bitmap, machine->pens[0x00], 0);
}
return 0;
}

2
src/mame/video/pitnrun.c
View File

@ -280,7 +280,7 @@ VIDEO_UPDATE( pitnrun )
draw_sprites(machine,bitmap,&myclip);
if(pitnrun_ha&4)
copybitmap(bitmap,tmp_bitmap[pitnrun_ha&3],flip_screen_x,flip_screen_y,dx,dy,&myclip,TRANSPARENCY_PEN, 1);
copybitmap_trans(bitmap,tmp_bitmap[pitnrun_ha&3],flip_screen_x,flip_screen_y,dx,dy,&myclip, 1);
tilemap_draw(bitmap,cliprect,fg, 0,0);
return 0;
}

4
src/mame/video/popeye.c
View File

@ -304,9 +304,7 @@ static void draw_background(running_machine *machine, mame_bitmap *bitmap, const
set_background_palette(machine, (*popeye_palettebank & 0x08) >> 3);
if (popeye_background_pos[1] == 0) /* no background */
{
fillbitmap(bitmap,machine->pens[0],cliprect);
}
else
{
/* copy the background graphics */
@ -323,7 +321,7 @@ static void draw_background(running_machine *machine, mame_bitmap *bitmap, const
scrolly = -scrolly;
}
copyscrollbitmap(bitmap,tmpbitmap2,1,&scrollx,1,&scrolly,cliprect,TRANSPARENCY_NONE,0);
copyscrollbitmap(bitmap,tmpbitmap2,1,&scrollx,1,&scrolly,cliprect);
}
}

2
src/mame/video/ppu2c0x.c
View File

@ -1345,7 +1345,7 @@ void ppu2c0x_render( int num, mame_bitmap *bitmap, int flipx, int flipy, int sx,
return;
}
copybitmap( bitmap, chips[num].bitmap, flipx, flipy, sx, sy, 0, TRANSPARENCY_NONE, 0 );
copybitmap( bitmap, chips[num].bitmap, flipx, flipy, sx, sy, 0 );
}
/*************************************

4
src/mame/video/psikyosh.c
View File

@ -329,8 +329,8 @@ static void draw_bglayerscroll(running_machine *machine, int layer, mame_bitmap
}
/* Only ever seems to use one linescroll value, ok for now */
/* Disabled for now, as they doesn't even support alpha :( */
// copyscrollbitmap(bitmap,zoom_bitmap,1,bg_scrollx,512,bg_scrolly,cliprect,TRANSPARENCY_PEN,0);
// copyscrollbitmap(bitmap,zoom_bitmap,256,bg_scrollx,0,bg_scrolly,cliprect,TRANSPARENCY_PEN,0);
// copyscrollbitmap_trans(bitmap,zoom_bitmap,1,bg_scrollx,512,bg_scrolly,cliprect,0);
// copyscrollbitmap_trans(bitmap,zoom_bitmap,256,bg_scrollx,0,bg_scrolly,cliprect,0);
}
}

2
src/mame/video/psx.c
View File

@ -511,7 +511,7 @@ static int DebugMeshDisplay( mame_bitmap *bitmap, const rectangle *cliprect )
{
if( m_b_debugmesh )
{
copybitmap( bitmap, debugmesh, 0, 0, 0, 0, cliprect, TRANSPARENCY_NONE, 0 );
copybitmap( bitmap, debugmesh, 0, 0, 0, 0, cliprect );
}
m_b_debugclear = 1;
return m_b_debugmesh;

11
src/mame/video/punchout.c
View File

@ -430,7 +430,7 @@ static void armwrest_draw_big_sprite(mame_bitmap *bitmap, const rectangle *clipr
}
}
static void drawbs2(mame_bitmap *bitmap, const rectangle *cliprect)
static void drawbs2(running_machine *machine, mame_bitmap *bitmap, const rectangle *cliprect)
{
mame_bitmap *sprbitmap = tilemap_get_pixmap(spr2tilemap);
int sx,sy;
@ -442,10 +442,7 @@ static void drawbs2(mame_bitmap *bitmap, const rectangle *cliprect)
sy = -punchout_bigsprite2[2] + 256 * (punchout_bigsprite2[3] & 1);
sy += 3; /* adjustment to match the screen shots */
copybitmap(bitmap,sprbitmap,
punchout_bigsprite2[4] & 1,0,
sx,sy,
cliprect,TRANSPARENCY_COLOR,1024);
copybitmap_trans(bitmap,sprbitmap, punchout_bigsprite2[4] & 1, 0, sx, sy, cliprect, machine->pens[1024]);
}
VIDEO_UPDATE( punchout )
@ -469,7 +466,7 @@ VIDEO_UPDATE( punchout )
if (punchout_bigsprite1[7] & 2) /* display in bottom monitor */
draw_big_sprite(bitmap, cliprect);
drawbs2(bitmap, cliprect);
drawbs2(machine, bitmap, cliprect);
}
return 0;
}
@ -490,7 +487,7 @@ VIDEO_UPDATE( armwrest )
if (punchout_bigsprite1[7] & 2) /* display in bottom monitor */
armwrest_draw_big_sprite(bitmap, cliprect);
drawbs2(bitmap, cliprect);
drawbs2(machine, bitmap, cliprect);
tilemap_draw(bitmap, cliprect, fgtilemap, 0, 0);
}

4
src/mame/video/quasar.c
View File

@ -182,8 +182,8 @@ VIDEO_UPDATE( quasar )
/* Update screen */
copybitmap(bitmap,effect_bitmap,0,0,0,0,&machine->screen[0].visarea,TRANSPARENCY_NONE,0);
copybitmap(bitmap,background_bitmap,0,0,0,0,&machine->screen[0].visarea,TRANSPARENCY_PEN,0);
copybitmap (bitmap,effect_bitmap, 0,0,0,0,cliprect);
copybitmap_trans(bitmap,background_bitmap,0,0,0,0,cliprect,0);
/* 2636's */

8
src/mame/video/realbrk.c
View File

@ -324,7 +324,7 @@ static void draw_sprites(running_machine *machine, mame_bitmap *bitmap,const rec
(rot & 1 ? scaley : scalex) << 12, (rot & 1 ? scalex : scaley) << 12);
// peek at the unrotated sprite
// copybitmap( bitmap,tmpbitmap0, 0,0, 50+(x * xdim/0x10000),50+(y * ydim/0x10000), cliprect, TRANSPARENCY_PEN, 0 );
// copybitmap_trans( bitmap,tmpbitmap0, 0,0, 50+(x * xdim/0x10000),50+(y * ydim/0x10000), cliprect, 0 );
}
switch( rot )
@ -342,7 +342,7 @@ static void draw_sprites(running_machine *machine, mame_bitmap *bitmap,const rec
currx = (sx - (y+1) * ydim) / 0x10000;
curry = (sy + x * xdim) / 0x10000;
copybitmap( bitmap,tmpbitmap1, 0,0, currx,curry, cliprect, TRANSPARENCY_PEN, 0 );
copybitmap_trans( bitmap,tmpbitmap1, 0,0, currx,curry, cliprect, 0 );
break;
case 0x20: // rot 180
@ -358,7 +358,7 @@ static void draw_sprites(running_machine *machine, mame_bitmap *bitmap,const rec
currx = (sx - (x+1) * xdim) / 0x10000;
curry = (sy - (y+1) * ydim) / 0x10000;
copybitmap( bitmap,tmpbitmap1, 0,0, currx,curry, cliprect, TRANSPARENCY_PEN, 0 );
copybitmap_trans( bitmap,tmpbitmap1, 0,0, currx,curry, cliprect, 0 );
break;
case 0x30: // rot 270
@ -374,7 +374,7 @@ static void draw_sprites(running_machine *machine, mame_bitmap *bitmap,const rec
currx = (sx + y * ydim) / 0x10000;
curry = (sy - (x+1) * xdim) / 0x10000;
copybitmap( bitmap,tmpbitmap1, 0,0, currx,curry, cliprect, TRANSPARENCY_PEN, 0 );
copybitmap_trans( bitmap,tmpbitmap1, 0,0, currx,curry, cliprect, 0 );
break;
default:

2
src/mame/video/shangha3.c
View File

@ -264,6 +264,6 @@ else
VIDEO_UPDATE( shangha3 )
{
copybitmap(bitmap,rawbitmap,0,0,0,0,&machine->screen[0].visarea,TRANSPARENCY_NONE,0);
copybitmap(bitmap,rawbitmap,0,0,0,0,cliprect);
return 0;
}

6
src/mame/video/snk.c
View File

@ -105,7 +105,7 @@ static void tnk3_draw_background(running_machine *machine, mame_bitmap *bitmap,
drawgfx(tmpbitmap,gfx,tile_number,color,0,0,sx,sy,0,TRANSPARENCY_NONE,0);
}
copyscrollbitmap(bitmap,tmpbitmap,1,&scrollx,1,&scrolly,cliprect,TRANSPARENCY_NONE,0);
copyscrollbitmap(bitmap,tmpbitmap,1,&scrollx,1,&scrolly,cliprect);
}
void tnk3_draw_text(running_machine *machine, mame_bitmap *bitmap, const rectangle *cliprect, int bank, UINT8 *source )
@ -262,7 +262,7 @@ static void sgladiat_draw_background(running_machine *machine, mame_bitmap *bitm
drawgfx(tmpbitmap,gfx,tile_number,color,0,0,sx,sy,0,TRANSPARENCY_NONE,0);
}
copyscrollbitmap(bitmap,tmpbitmap,1,&scrollx,1,&scrolly,cliprect,TRANSPARENCY_NONE,0);
copyscrollbitmap(bitmap,tmpbitmap,1,&scrollx,1,&scrolly,cliprect);
}
VIDEO_UPDATE( sgladiat )
@ -386,7 +386,7 @@ static void tdfever_draw_bg(running_machine *machine, mame_bitmap *bitmap, const
else
drawgfx(tmpbitmap,gfx,tile_number,color,0,0,sx,sy,0,TRANSPARENCY_NONE,0);
}
copyscrollbitmap(bitmap,tmpbitmap,1,&xscroll,1,&yscroll,cliprect,TRANSPARENCY_NONE,0);
copyscrollbitmap(bitmap,tmpbitmap,1,&xscroll,1,&yscroll,cliprect);
}
/*

59
src/mame/video/stactics.c
View File

@ -531,7 +531,7 @@ VIDEO_UPDATE( stactics )
color_code,
0,0,
sx*8,sy*8,
&machine->screen[0].visarea,TRANSPARENCY_NONE,0);
cliprect,TRANSPARENCY_NONE,0);
dirty_videoram_d[offs] = 0;
}
@ -559,7 +559,7 @@ VIDEO_UPDATE( stactics )
color_code,
0,0,
sx*8,sy*8,
&machine->screen[0].visarea,TRANSPARENCY_NONE,0);
cliprect,TRANSPARENCY_NONE,0);
dirty_videoram_e[offs] = 0;
}
@ -587,7 +587,7 @@ VIDEO_UPDATE( stactics )
color_code,
0,0,
sx*8,sy*8,
&machine->screen[0].visarea,TRANSPARENCY_NONE,0);
cliprect,TRANSPARENCY_NONE,0);
dirty_videoram_f[offs] = 0;
}
@ -615,7 +615,7 @@ VIDEO_UPDATE( stactics )
color_code,
0,0,
sx*8,sy*8,
&machine->screen[0].visarea,TRANSPARENCY_NONE,0);
cliprect,TRANSPARENCY_NONE,0);
dirty_videoram_b[offs] = 0;
}
@ -623,19 +623,14 @@ VIDEO_UPDATE( stactics )
/* Now, composite the four layers together */
copyscrollbitmap(tmpbitmap2,bitmap_D,0,0,1,&d_offset,
&machine->screen[0].visarea,TRANSPARENCY_NONE,0);
copyscrollbitmap(tmpbitmap2,bitmap_E,0,0,1,&e_offset,
&machine->screen[0].visarea,TRANSPARENCY_COLOR,0);
copyscrollbitmap(tmpbitmap2,bitmap_F,0,0,1,&f_offset,
&machine->screen[0].visarea,TRANSPARENCY_COLOR,0);
copybitmap(tmpbitmap2,bitmap_B,0,0,0,0,
&machine->screen[0].visarea,TRANSPARENCY_COLOR,0);
copyscrollbitmap (tmpbitmap2,bitmap_D,0,0,1,&d_offset,NULL);
copyscrollbitmap_trans(tmpbitmap2,bitmap_E,0,0,1,&e_offset,NULL,machine->pens[0]);
copyscrollbitmap_trans(tmpbitmap2,bitmap_F,0,0,1,&f_offset,NULL,machine->pens[0]);
copybitmap_trans (tmpbitmap2,bitmap_B,0,0,0,0,NULL,machine->pens[0]);
/* Now flip X & simulate the monitor motion */
fillbitmap(bitmap, machine->pens[0], &machine->screen[0].visarea);
copybitmap(bitmap,tmpbitmap2,1,0,stactics_horiz_pos,stactics_vert_pos,
&visible_screen_area,TRANSPARENCY_NONE,0);
fillbitmap(bitmap, machine->pens[0], cliprect);
copybitmap(bitmap,tmpbitmap2,1,0,stactics_horiz_pos,stactics_vert_pos,&visible_screen_area);
/* Finally, draw stuff that is on the console or on top of the monitor (LED's) */
@ -650,7 +645,7 @@ VIDEO_UPDATE( stactics )
0,
0,0,
pixel_x,pixel_y,
&machine->screen[0].visarea,TRANSPARENCY_NONE,0);
cliprect,TRANSPARENCY_NONE,0);
pixel_x+=6;
/* Draw a colon */
drawgfx(bitmap,machine->gfx[5],
@ -658,7 +653,7 @@ VIDEO_UPDATE( stactics )
0,
0,0,
pixel_x,pixel_y,
&machine->screen[0].visarea,TRANSPARENCY_NONE,0);
cliprect,TRANSPARENCY_NONE,0);
pixel_x+=6;
/* Draw the digits */
for(i=1;i<7;i++)
@ -668,7 +663,7 @@ VIDEO_UPDATE( stactics )
16,
0,0,
pixel_x,pixel_y,
&machine->screen[0].visarea,TRANSPARENCY_NONE,0);
cliprect,TRANSPARENCY_NONE,0);
pixel_x+=6;
}
@ -682,7 +677,7 @@ VIDEO_UPDATE( stactics )
0,
0,0,
pixel_x,pixel_y,
&machine->screen[0].visarea,TRANSPARENCY_NONE,0);
cliprect,TRANSPARENCY_NONE,0);
pixel_x+=6;
/* Draw a colon */
drawgfx(bitmap,machine->gfx[5],
@ -690,7 +685,7 @@ VIDEO_UPDATE( stactics )
0,
0,0,
pixel_x,pixel_y,
&machine->screen[0].visarea,TRANSPARENCY_NONE,0);
cliprect,TRANSPARENCY_NONE,0);
pixel_x+=6;
/* Draw the pips */
for(i=7;i<9;i++)
@ -700,7 +695,7 @@ VIDEO_UPDATE( stactics )
16,
0,0,
pixel_x,pixel_y,
&machine->screen[0].visarea,TRANSPARENCY_NONE,0);
cliprect,TRANSPARENCY_NONE,0);
pixel_x+=2;
}
@ -714,7 +709,7 @@ VIDEO_UPDATE( stactics )
0,
0,0,
pixel_x,pixel_y,
&machine->screen[0].visarea,TRANSPARENCY_NONE,0);
cliprect,TRANSPARENCY_NONE,0);
pixel_x+=6;
/* Draw a colon */
drawgfx(bitmap,machine->gfx[5],
@ -722,7 +717,7 @@ VIDEO_UPDATE( stactics )
0,
0,0,
pixel_x,pixel_y,
&machine->screen[0].visarea,TRANSPARENCY_NONE,0);
cliprect,TRANSPARENCY_NONE,0);
pixel_x+=6;
/* Draw the pips */
for(i=9;i<12;i++)
@ -732,7 +727,7 @@ VIDEO_UPDATE( stactics )
16,
0,0,
pixel_x,pixel_y,
&machine->screen[0].visarea,TRANSPARENCY_NONE,0);
cliprect,TRANSPARENCY_NONE,0);
pixel_x+=2;
}
@ -745,7 +740,7 @@ VIDEO_UPDATE( stactics )
0,
0,0,
pixel_x,pixel_y,
&machine->screen[0].visarea,TRANSPARENCY_NONE,0);
cliprect,TRANSPARENCY_NONE,0);
pixel_x+=6;
/* Draw a colon */
drawgfx(bitmap,machine->gfx[5],
@ -753,7 +748,7 @@ VIDEO_UPDATE( stactics )
0,
0,0,
pixel_x,pixel_y,
&machine->screen[0].visarea,TRANSPARENCY_NONE,0);
cliprect,TRANSPARENCY_NONE,0);
pixel_x+=6;
/* Draw the pips */
for(i=12;i<16;i++)
@ -763,7 +758,7 @@ VIDEO_UPDATE( stactics )
16,
0,0,
pixel_x,pixel_y,
&machine->screen[0].visarea,TRANSPARENCY_NONE,0);
cliprect,TRANSPARENCY_NONE,0);
pixel_x+=2;
}
@ -810,13 +805,13 @@ VIDEO_UPDATE( stactics )
16*2, /* Make it green */
0,0,
pixel_x,pixel_y,
&machine->screen[0].visarea,TRANSPARENCY_COLOR,0);
cliprect,TRANSPARENCY_COLOR,0);
drawgfx(bitmap,machine->gfx[4],
beamdata[firebeam_state*8+i]&0x7f,
16*2, /* Make it green */
1,0,
255-pixel_x,pixel_y,
&machine->screen[0].visarea,TRANSPARENCY_COLOR,0);
cliprect,TRANSPARENCY_COLOR,0);
pixel_x+=14;
pixel_y-=7;
}
@ -828,13 +823,13 @@ VIDEO_UPDATE( stactics )
16*2, /* Make it green */
0,0,
pixel_x,pixel_y,
&machine->screen[0].visarea,TRANSPARENCY_COLOR,0);
cliprect,TRANSPARENCY_COLOR,0);
drawgfx(bitmap,machine->gfx[4],
beamdata[firebeam_state*8+i],
16*2, /* Make it green */
1,0,
255-pixel_x,pixel_y,
&machine->screen[0].visarea,TRANSPARENCY_COLOR,0);
cliprect,TRANSPARENCY_COLOR,0);
pixel_x+=16;
pixel_y-=8;
}
@ -853,7 +848,7 @@ VIDEO_UPDATE( stactics )
16, /* red */
0,0,
pixel_x,pixel_y,
&machine->screen[0].visarea,TRANSPARENCY_COLOR,0);
cliprect,TRANSPARENCY_COLOR,0);
}
/* Update vblank counter */

2
src/mame/video/superqix.c
View File

@ -254,7 +254,7 @@ VIDEO_UPDATE( pbillian )
VIDEO_UPDATE( superqix )
{
tilemap_draw(bitmap, cliprect, bg_tilemap, TILEMAP_DRAW_LAYER1, 0);
copybitmap(bitmap,fg_bitmap[show_bitmap],flip_screen,flip_screen,0,0,cliprect,TRANSPARENCY_PEN,0);
copybitmap_trans(bitmap,fg_bitmap[show_bitmap],flip_screen,flip_screen,0,0,cliprect,0);
superqix_draw_sprites(machine, bitmap,cliprect);
tilemap_draw(bitmap, cliprect, bg_tilemap, TILEMAP_DRAW_LAYER0, 0);
return 0;

10
src/mame/video/system1.c
View File

@ -458,9 +458,9 @@ static void system1_draw_bg(running_machine *machine, mame_bitmap *bitmap, const
/* copy the temporary bitmap to the screen */
if (flip_screen)
copyscrollbitmap(bitmap,tmp_bitmap,1,&background_scrollx_flip,1,&background_scrolly_flip,cliprect,TRANSPARENCY_NONE,0);
copyscrollbitmap(bitmap,tmp_bitmap,1,&background_scrollx_flip,1,&background_scrolly_flip,cliprect);
else
copyscrollbitmap(bitmap,tmp_bitmap,1,&background_scrollx,1,&background_scrolly,cliprect,TRANSPARENCY_NONE,0);
copyscrollbitmap(bitmap,tmp_bitmap,1,&background_scrollx,1,&background_scrolly,cliprect);
}
else
{
@ -608,13 +608,13 @@ static void chplft_draw_bg(running_machine *machine, mame_bitmap *bitmap, const
for (i = 0; i < 32; i++)
scrollx_row_flip[31-i] = (256-scrollx_row[i]) & 0xff;
copyscrollbitmap(bitmap,tmp_bitmap,32,scrollx_row_flip,0,0,cliprect,TRANSPARENCY_NONE,0);
copyscrollbitmap(bitmap,tmp_bitmap,32,scrollx_row_flip,0,0,cliprect);
}
else
copyscrollbitmap(bitmap,tmp_bitmap,32,scrollx_row,0,0,cliprect,TRANSPARENCY_NONE,0);
copyscrollbitmap(bitmap,tmp_bitmap,32,scrollx_row,0,0,cliprect);
}
else
copybitmap(bitmap,tmp_bitmap,0,0,0,0,cliprect,TRANSPARENCY_NONE,0);
copybitmap(bitmap,tmp_bitmap,0,0,0,0,cliprect);
}
else
{

2
src/mame/video/taito_b.c
View File

@ -612,7 +612,7 @@ VIDEO_UPDATE( taitob )
int scrolly = -pixel_scroll[1]; //+240;
/* bit 15 of pixel_scroll[0] is probably flip screen */
copyscrollbitmap(bitmap,pixel_bitmap,1,&scrollx,1,&scrolly,cliprect,TRANSPARENCY_COLOR,b_fg_color_base * 16);
copyscrollbitmap_trans(bitmap,pixel_bitmap,1,&scrollx,1,&scrolly,cliprect,machine->pens[b_fg_color_base * 16]);
}
draw_framebuffer(machine, bitmap,cliprect,0);

2
src/mame/video/taitojc.c
View File

@ -265,7 +265,7 @@ VIDEO_UPDATE( taitojc )
}
}
copybitmap(bitmap, framebuffer, 0, 0, 0, 0, cliprect, TRANSPARENCY_PEN, 0);
copybitmap_trans(bitmap, framebuffer, 0, 0, 0, 0, cliprect, 0);
for (i=(0xc00/4)-2; i >= 0; i-=2)
{

8
src/mame/video/taitosj.c
View File

@ -714,7 +714,7 @@ static void taitosj_copy_layer(running_machine *machine, mame_bitmap *bitmap, co
scrolly[i] = -taitosj_colscrolly[32 * which + i] - taitosj_scroll[2 * which + 1];
}
copyscrollbitmap(bitmap, taitosj_layer_bitmap[which], 1, &scrollx, 32, scrolly, cliprect, TRANSPARENCY_COLOR,0);
copyscrollbitmap_trans(bitmap, taitosj_layer_bitmap[which], 1, &scrollx, 32, scrolly, cliprect, machine->pens[0]);
/* store parts covered with sprites for sprites/layers collision detection */
for (i = 0; i < 0x20; i++)
@ -722,7 +722,7 @@ static void taitosj_copy_layer(running_machine *machine, mame_bitmap *bitmap, co
if ((i >= 0x10) && (i <= 0x17)) continue; /* no sprites here */
if (sprites_on[i])
copyscrollbitmap(sprite_layer_collbitmap2[which], taitosj_layer_bitmap[which], 1, &scrollx, 32, scrolly, &sprite_areas[i], TRANSPARENCY_NONE,0);
copyscrollbitmap(sprite_layer_collbitmap2[which], taitosj_layer_bitmap[which], 1, &scrollx, 32, scrolly, &sprite_areas[i]);
}
}
}
@ -758,7 +758,7 @@ static void kikstart_copy_layer(running_machine *machine, mame_bitmap *bitmap, c
}
scrolly = taitosj_scroll[2 * which + 1]; /* always 0 */
copyscrollbitmap(bitmap, taitosj_layer_bitmap[which], 32 * 8, scrollx, 1, &scrolly, cliprect, TRANSPARENCY_COLOR, 0);
copyscrollbitmap_trans(bitmap, taitosj_layer_bitmap[which], 32 * 8, scrollx, 1, &scrolly, cliprect, machine->pens[0]);
/* store parts covered with sprites for sprites/layers collision detection */
for (i = 0; i < 0x20; i++)
@ -766,7 +766,7 @@ static void kikstart_copy_layer(running_machine *machine, mame_bitmap *bitmap, c
if ((i >= 0x10) && (i <= 0x17)) continue; /* no sprites here */
if (sprites_on[i])
copyscrollbitmap(sprite_layer_collbitmap2[which], taitosj_layer_bitmap[which], 32 * 8, scrollx, 1, &scrolly, &sprite_areas[i], TRANSPARENCY_NONE,0);
copyscrollbitmap(sprite_layer_collbitmap2[which], taitosj_layer_bitmap[which], 32 * 8, scrollx, 1, &scrolly, &sprite_areas[i]);
}
}
}

4
src/mame/video/tceptor.c
View File

@ -513,10 +513,8 @@ static void draw_sprites(running_machine *machine, mame_bitmap *bitmap, const re
if (is_mask_spr[color])
{
if (!need_mask)
{
// backup previous bitmap
copybitmap(temp_bitmap, bitmap, 0, 0, 0, 0, cliprect, TRANSPARENCY_NONE, 0);
}
copybitmap(temp_bitmap, bitmap, 0, 0, 0, 0, cliprect);
need_mask = 1;
}

3
src/mame/video/tia.c
View File

@ -284,8 +284,7 @@ VIDEO_START( tia )
VIDEO_UPDATE( tia )
{
screen_height = machine->screen[0].height;
copybitmap(bitmap, helper[2], 0, 0, 0, 0,
cliprect, TRANSPARENCY_NONE, 0);
copybitmap(bitmap, helper[2], 0, 0, 0, 0, cliprect);
return 0;
}

2
src/mame/video/vdc.c
View File

@ -373,7 +373,7 @@ VIDEO_START( pce )
VIDEO_UPDATE( pce )
{
/* copy our rendering buffer to the display */
copybitmap (bitmap,vce.bmp,0,0,0,0,cliprect,TRANSPARENCY_NONE,0);
copybitmap (bitmap,vce.bmp,0,0,0,0,cliprect);
return 0;
}

2
src/mame/video/vigilant.c
View File

@ -229,7 +229,7 @@ static void draw_background(running_machine *machine, mame_bitmap *bitmap, const
rear_refresh=0;
}
copyscrollbitmap(bitmap,bg_bitmap,1,&scrollx,0,0,&bottomvisiblearea,TRANSPARENCY_NONE,0);
copyscrollbitmap(bitmap,bg_bitmap,1,&scrollx,0,0,&bottomvisiblearea);
}

8
src/mame/video/xxmissio.c
View File

@ -101,7 +101,7 @@ VIDEO_UPDATE( xxmissio )
sy = xxmissio_yscroll;
}
copyscrollbitmap(bitmap,tmpbitmap,1,&sx,1,&sy,&machine->screen[0].visarea,TRANSPARENCY_NONE,0);
copyscrollbitmap(bitmap,tmpbitmap,1,&sx,1,&sy,cliprect);
/* draw sprites */
@ -137,14 +137,14 @@ VIDEO_UPDATE( xxmissio )
col,
fx,fy,
px,py,
&machine->screen[0].visarea,TRANSPARENCY_PEN,0);
cliprect,TRANSPARENCY_PEN,0);
if (px>0x1e0)
drawgfx(bitmap,machine->gfx[1],
chr,
col,
fx,fy,
px-0x200,py,
&machine->screen[0].visarea,TRANSPARENCY_PEN,0);
cliprect,TRANSPARENCY_PEN,0);
}
@ -175,7 +175,7 @@ VIDEO_UPDATE( xxmissio )
col,
flipscreen,flipscreen,
px,py,
&machine->screen[0].visarea,TRANSPARENCY_PEN,0);
cliprect,TRANSPARENCY_PEN,0);
}
}

8
src/mame/video/yard.c
View File

@ -53,7 +53,7 @@ PALETTE_INIT( yard )
int i;
machine->colortable = colortable_alloc(machine, 256+16+256);
/* character palette */
for (i = 0;i < 256;i++)
{
@ -268,12 +268,12 @@ static void draw_panel( running_machine *machine, mame_bitmap *bitmap, const rec
rectangle clip = flip_screen ? clippanelflip : clippanel;
int sx = flip_screen ? cliprect->min_x - 8 : cliprect->max_x + 1 - SCROLL_PANEL_WIDTH;
int yoffs = flip_screen ? -40 : -16;
clip.min_y += machine->screen[0].visarea.min_y + yoffs;
clip.max_y += machine->screen[0].visarea.max_y + yoffs;
copybitmap(bitmap, scroll_panel_bitmap, flip_screen, flip_screen, sx, machine->screen[0].visarea.min_y + yoffs,
&clip, TRANSPARENCY_NONE, 0);
copybitmap(bitmap, scroll_panel_bitmap, flip_screen, flip_screen,
sx, machine->screen[0].visarea.min_y + yoffs, &clip);
}
}

8
src/mame/video/ygv608.c
View File

@ -895,9 +895,7 @@ VIDEO_UPDATE( ygv608 )
TRANSPARENCY_NONE, 0, 0 );
else
#endif
copybitmap( bitmap, work_bitmap, 0, 0, 0, 0,
cliprect,
TRANSPARENCY_NONE, 0 );
copybitmap( bitmap, work_bitmap, 0, 0, 0, 0, cliprect);
// for some reason we can't use an opaque tilemap_A
// so use a transparent but clear the work bitmap first
@ -922,9 +920,7 @@ VIDEO_UPDATE( ygv608 )
TRANSPARENCY_PEN, machine->pens[0], 0 );
else
#endif
copybitmap( bitmap, work_bitmap, 0, 0, 0, 0,
cliprect,
TRANSPARENCY_PEN, machine->pens[0] );
copybitmap_trans( bitmap, work_bitmap, 0, 0, 0, 0, cliprect, machine->pens[0] );
if ((ygv608.regs.s.r11 & r11_prm) == PRM_SABDEX ||
(ygv608.regs.s.r11 & r11_prm) == PRM_SEABDX)

2
src/mame/video/zac2650.c
View File

@ -154,7 +154,7 @@ static void draw_sprites(running_machine *machine, mame_bitmap *bitmap)
CollisionBackground = 0; /* Read from 0x1e80 bit 7 */
// for collision detection checking
copybitmap(tmpbitmap,bitmap,0,0,0,0,&machine->screen[0].visarea,TRANSPARENCY_NONE,0);
copybitmap(tmpbitmap,bitmap,0,0,0,0,&machine->screen[0].visarea);
for(offs=0;offs<0x50;offs+=0x10)
{