static void draw_ship(struct mame_bitmap* bitmap, const struct rectangle* cliprect)
{
static const UINT32 scaler[] =
{
0x00000, 0x00500, 0x00A00, 0x01000,
0x01000, 0x01200, 0x01500, 0x01800,
0x01800, 0x01D00, 0x02200, 0x02800,
0x02800, 0x02800, 0x02800, 0x02800,
0x02800, 0x03000, 0x03800, 0x04000,
0x04000, 0x04500, 0x04A00, 0x05000,
0x05000, 0x05500, 0x05A00, 0x06000,
0x06000, 0x06A00, 0x07500, 0x08000,
0x08000, 0x08A00, 0x09500, 0x0A000,
0x0A000, 0x0B000, 0x0C000, 0x0D000,
0x0D000, 0x0E000, 0x0F000, 0x10000,
0x10000, 0x11A00, 0x13500, 0x15000,
0x15000, 0x17500, 0x19A00, 0x1C000,
0x1C000, 0x1EA00, 0x21500, 0x24000,
0x24000, 0x26A00, 0x29500, 0x2C000,
0x2C000, 0x2FA00, 0x33500, 0x37000
};
int chop = (scaler[wolfpack_ship_size] * wolfpack_ship_h_precess) >> 16;
drawgfxzoom(bitmap, Machine->gfx[1],
wolfpack_ship_pic,
0,
wolfpack_ship_reflect, 0,
2 * (wolfpack_ship_h - chop),
128,
cliprect,
TRANSPARENCY_PEN, 0,
2 * scaler[wolfpack_ship_size], scaler[wolfpack_ship_size]);
}
static void flower_drawsprites( struct mame_bitmap *bitmap, const struct rectangle *cliprect )
{
unsigned char *floweram = memory_region(REGION_CPU1);
const struct GfxElement *gfx = Machine->gfx[1];
data8_t *source = &floweram[0xde00]+0x200;
data8_t *finish = source - 0x200;
source -= 8;
while( source>=finish )
{
int xblock,yblock;
int sy = 256-32-source[0]+1;
int sx = source[4]-55;
int code = source[1] & 0x3f;
int flipy = source[1] & 0x80; // wrong? sunflower needs it, ship afterwards breaks with it
int flipx = source[1] & 0x40;
int size = source[3];
int xsize = ((size & 0x08)>>3);
int ysize = ((size & 0x80)>>7);
xsize++;
ysize++;
if (ysize==2) sy-=16;
code |= ((source[2] & 0x01) << 6);
code |= ((source[2] & 0x08) << 4);
for (xblock = 0; xblock<xsize; xblock++)
{
for (yblock = 0; yblock<ysize; yblock++)
{
drawgfxzoom(bitmap,gfx,
code+yblock+(8*xblock),
0,
flipx,flipy,
sx+16*xblock,sy+16*yblock,
cliprect,TRANSPARENCY_PEN,0,
((size&7)+1)<<13,((size&0x70)+0x10)<<9);
}
}
source -= 8;
}
}
static void orbit_draw_sprites(mame_bitmap* bitmap, const rectangle* cliprect)
{
const UINT8* p = orbit_sprite_ram;
int i;
for (i = 0; i < 16; i++)
{
int code = *p++;
int vpos = *p++;
int hpos = *p++;
int flag = *p++;
int layout =
((flag & 0xc0) == 0x80) ? 1 :
((flag & 0xc0) == 0xc0) ? 2 : 0;
int flip_x = code & 0x40;
int flip_y = code & 0x80;
int zoom_x = 0x10000;
int zoom_y = 0x10000;
code &= 0x3f;
if (flag & 1)
{
code |= 0x40;
}
if (flag & 2)
{
zoom_x *= 2;
}
vpos = 240 - vpos;
hpos <<= 1;
vpos <<= 1;
drawgfxzoom(bitmap, Machine->gfx[layout], code, 0, flip_x, flip_y,
hpos, vpos, cliprect, TRANSPARENCY_PEN, 0, zoom_x, zoom_y);
}
}
static void flower_drawsprites( mame_bitmap *bitmap, const rectangle *cliprect )
{
const gfx_element *gfx = Machine->gfx[1];
UINT8 *source = spriteram + 0x200;
UINT8 *finish = source - 0x200;
source -= 8;
while( source>=finish )
{
int xblock,yblock;
int sy = 256-32-source[0]+1;
int sx = (source[4]|(source[5]<<8))-55;
int code = source[1] & 0x3f;
int color = (source[6]>>4);
/*
Byte 0: Y
Byte 1:
0x80 - FlipY
0x40 - FlipX
0x3f - Tile
Byte 2:
0x08 - Tile MSB
0x01 - Tile MSB
Byte 3:
0x07 - X Zoom
0x08 - X Size
0x70 - Y Zoom
0x80 - Y Size
Byte 4: X LSB
Byte 5: X MSB
Byte 6:
0xf0 - Colour
*/
int flipy = source[1] & 0x80;
int flipx = source[1] & 0x40;
int size = source[3];
int xsize = ((size & 0x08)>>3);
int ysize = ((size & 0x80)>>7);
xsize++;
ysize++;
if (ysize==2) sy -= 16;
code |= ((source[2] & 0x01) << 6);
code |= ((source[2] & 0x08) << 4);
if(flip_screen)
{
flipx = !flipx;
flipy = !flipy;
sx = sx+16;
sy = 250-sy;
if (ysize==2) sy += 16;
}
for (xblock = 0; xblock<xsize; xblock++)
{
int xoffs=!flipx ? (xblock*8) : ((xsize-xblock-1)*8);
int zoomx=((size&7)+1)<<13;
int zoomy=((size&0x70)+0x10)<<9;
int xblocksizeinpixels=(zoomx*16)>>16;
int yblocksizeinpixels=(zoomy*16)>>16;
for (yblock = 0; yblock<ysize; yblock++)
{
int yoffs=!flipy ? yblock : (ysize-yblock-1);
int sxoffs=(16-xblocksizeinpixels)/2;
int syoffs=(16-yblocksizeinpixels)/2;
if (xblock) sxoffs+=xblocksizeinpixels;
if (yblock) syoffs+=yblocksizeinpixels;
drawgfxzoom(bitmap,gfx,
code+yoffs+xoffs,
color,
flipx,flipy,
sx+sxoffs,sy+syoffs,
cliprect,TRANSPARENCY_PEN,15,
zoomx,zoomy);
}
}
source -= 8;
}
}
static void superchs_draw_sprites_16x16(mame_bitmap *bitmap,const rectangle *cliprect,int *primasks,int x_offs,int y_offs)
{
UINT16 *spritemap = (UINT16 *)memory_region(REGION_USER1);
int offs, data, tilenum, color, flipx, flipy;
int x, y, priority, dblsize, curx, cury;
int sprites_flipscreen = 0;
int zoomx, zoomy, zx, zy;
int sprite_chunk,map_offset,code,j,k,px,py;
int dimension,total_chunks,bad_chunks;
/* pdrawgfx() needs us to draw sprites front to back, so we have to build a list
while processing sprite ram and then draw them all at the end */
struct tempsprite *sprite_ptr = spritelist;
for (offs = (spriteram_size/4-4);offs >= 0;offs -= 4)
{
data = spriteram32[offs+0];
flipx = (data & 0x00800000) >> 23;
zoomx = (data & 0x007f0000) >> 16;
tilenum = (data & 0x00007fff);
data = spriteram32[offs+2];
priority = (data & 0x000c0000) >> 18;
color = (data & 0x0003fc00) >> 10;
x = (data & 0x000003ff);
data = spriteram32[offs+3];
dblsize = (data & 0x00040000) >> 18;
flipy = (data & 0x00020000) >> 17;
zoomy = (data & 0x0001fc00) >> 10;
y = (data & 0x000003ff);
color |= 0x100;
if (!tilenum) continue;
flipy = !flipy;
zoomx += 1;
zoomy += 1;
y += y_offs;
/* treat coords as signed */
if (x>0x340) x -= 0x400;
if (y>0x340) y -= 0x400;
x -= x_offs;
bad_chunks = 0;
dimension = ((dblsize*2) + 2); /* 2 or 4 */
total_chunks = ((dblsize*3) + 1) << 2; /* 4 or 16 */
map_offset = tilenum << 2;
{
for (sprite_chunk=0;sprite_chunk<total_chunks;sprite_chunk++)
{
j = sprite_chunk / dimension; /* rows */
k = sprite_chunk % dimension; /* chunks per row */
px = k;
py = j;
/* pick tiles back to front for x and y flips */
if (flipx) px = dimension-1-k;
if (flipy) py = dimension-1-j;
code = spritemap[map_offset + px + (py<<(dblsize+1))];
if (code==0xffff)
{
bad_chunks += 1;
continue;
}
curx = x + ((k*zoomx)/dimension);
cury = y + ((j*zoomy)/dimension);
zx= x + (((k+1)*zoomx)/dimension) - curx;
zy= y + (((j+1)*zoomy)/dimension) - cury;
if (sprites_flipscreen)
{
/* -zx/y is there to fix zoomed sprite coords in screenflip.
drawgfxzoom does not know to draw from flip-side of sprites when
screen is flipped; so we must correct the coords ourselves. */
curx = 320 - curx - zx;
cury = 256 - cury - zy;
flipx = !flipx;
flipy = !flipy;
}
sprite_ptr->gfx = 0;
sprite_ptr->code = code;
sprite_ptr->color = color;
sprite_ptr->flipx = !flipx;
sprite_ptr->flipy = flipy;
sprite_ptr->x = curx;
sprite_ptr->y = cury;
sprite_ptr->zoomx = zx << 12;
sprite_ptr->zoomy = zy << 12;
if (primasks)
{
sprite_ptr->primask = primasks[priority];
sprite_ptr++;
}
else
{
drawgfxzoom(bitmap,Machine->gfx[sprite_ptr->gfx],
sprite_ptr->code,
sprite_ptr->color,
sprite_ptr->flipx,sprite_ptr->flipy,
sprite_ptr->x,sprite_ptr->y,
cliprect,TRANSPARENCY_PEN,0,
sprite_ptr->zoomx,sprite_ptr->zoomy);
}
}
}
if (bad_chunks)
logerror("Sprite number %04x had %02x invalid chunks\n",tilenum,bad_chunks);
}
/* this happens only if primsks != NULL */
while (sprite_ptr != spritelist)
{
sprite_ptr--;
pdrawgfxzoom(bitmap,Machine->gfx[sprite_ptr->gfx],
sprite_ptr->code,
sprite_ptr->color,
sprite_ptr->flipx,sprite_ptr->flipy,
sprite_ptr->x,sprite_ptr->y,
cliprect,TRANSPARENCY_PEN,0,
sprite_ptr->zoomx,sprite_ptr->zoomy,
sprite_ptr->primask);
}
}
static void taitoair_draw_sprites(mame_bitmap *bitmap, const rectangle *cliprect, int priority)
{
/* Y chain size is 16/32?/64/64? pixels. X chain size
is always 64 pixels. */
static const int size[] = { 1, 2, 4, 4 };
int x0, y0, x, y, dx, dy, ex, ey, zx, zy;
int ysize;
int j, k;
int offs; /* sprite RAM offset */
int tile_offs; /* sprite chain offset */
int zoomx, zoomy; /* zoom value */
for (offs = 0x03f8 / 2 ; offs >= 0 ; offs -= 0x008 / 2)
{
if (offs < 0x01b0 && priority == 0) continue;
if (offs >= 0x01b0 && priority == 1) continue;
x0 = TC0080VCO_spriteram[offs + 1] & 0x3ff;
y0 = TC0080VCO_spriteram[offs + 0] & 0x3ff;
zoomx = (TC0080VCO_spriteram[offs + 2] & 0x7f00) >> 8;
zoomy = (TC0080VCO_spriteram[offs + 2] & 0x007f);
tile_offs = (TC0080VCO_spriteram[offs + 3] & 0x1fff) << 2;
ysize = size[ ( TC0080VCO_spriteram[ offs ] & 0x0c00 ) >> 10 ];
if (tile_offs)
{
/* Convert zoomy value to real value as zoomx */
zoomy = zoomy_conv_table[zoomy];
if (zoomx < 63)
{
dx = 8 + (zoomx + 2) / 8;
ex = (zoomx + 2) % 8;
zx = ((dx << 1) + ex) << 11;
}
else
{
dx = 16 + (zoomx - 63) / 4;
ex = (zoomx - 63) % 4;
zx = (dx + ex) << 12;
}
if (zoomy < 63)
{
dy = 8 + (zoomy + 2) / 8;
ey = (zoomy + 2) % 8;
zy = ((dy << 1) + ey) << 11;
}
else
{
dy = 16 + (zoomy - 63) / 4;
ey = (zoomy - 63) % 4;
zy = (dy + ey) << 12;
}
if (x0 >= 0x200) x0 -= 0x400;
if (y0 >= 0x200) y0 -= 0x400;
if (TC0080VCO_flipscreen)
{
x0 = 497 - x0;
y0 = 498 - y0;
dx = -dx;
dy = -dy;
}
else
{
x0 += 1;
y0 += 2;
}
y = y0;
for (j = 0 ; j < ysize ; j ++)
{
x = x0;
for (k = 0 ; k < 4 ; k ++)
{
if (tile_offs >= 0x1000)
{
int tile, color, flipx, flipy;
tile = TC0080VCO_chain_ram_0[tile_offs] & 0x7fff;
color = TC0080VCO_chain_ram_1[tile_offs] & 0x001f;
flipx = TC0080VCO_chain_ram_1[tile_offs] & 0x0040;
flipy = TC0080VCO_chain_ram_1[tile_offs] & 0x0080;
if (TC0080VCO_flipscreen)
{
flipx ^= 0x0040;
flipy ^= 0x0080;
}
drawgfxzoom( bitmap, Machine -> gfx[0],
tile,
color,
flipx, flipy,
x, y,
cliprect,
TRANSPARENCY_PEN, 0,
zx, zy
);
}
tile_offs ++;
x += dx;
}
y += dy;
}
}
}
}
static void taotaido_drawsprite( UINT16 spriteno, struct mame_bitmap *bitmap, const struct rectangle *cliprect )
{
/*- SPR RAM Format -**
4 words per sprite
zzzz sssp pppp pppp (y zoom, y size, y position)
zzzz sssp pppp pppp (x zoom, x size, x position)
yxpc cccc ---- ---- (flipy, flipx, priority?, colour)
-nnn nnnn nnnn nnnn (tile lookup)
*/
int x,y;
data16_t *source = &taotaido_spriteram_older[spriteno*4];
const struct GfxElement *gfx = Machine->gfx[0];
int yzoom = (source[0] & 0xf000) >> 12;
int xzoom = (source[1] & 0xf000) >> 12;
int ysize = (source[0] & 0x0e00) >> 9;
int xsize = (source[1] & 0x0e00) >> 9;
int ypos = source[0] & 0x01ff;
int xpos = source[1] & 0x01ff;
int yflip = source[2] & 0x8000;
int xflip = source[2] & 0x4000;
int color = (source[2] & 0x1f00) >> 8;
int tile = source[3] & 0xffff;
xpos += (xsize*xzoom+2)/4;
ypos += (ysize*yzoom+2)/4;
xzoom = 32 - xzoom;
yzoom = 32 - yzoom;
for (y = 0;y <= ysize;y++)
{
int sx,sy;
if (yflip) sy = ((ypos + yzoom * (ysize - y)/2 + 16) & 0x1ff) - 16;
else sy = ((ypos + yzoom * y / 2 + 16) & 0x1ff) - 16;
for (x = 0;x <= xsize;x++)
{
/* this indirection is a bit different to the other video system games */
int realtile;
realtile = taotaido_spriteram2_older[tile];
if (realtile > 0x3fff)
{
int block;
block = (realtile & 0x3800)>>11;
realtile &= 0x07ff;
realtile |= taotaido_sprite_character_bank_select[block] * 0x800;
}
if (xflip) sx = ((xpos + xzoom * (xsize - x) / 2 + 16) & 0x1ff) - 16;
else sx = ((xpos + xzoom * x / 2 + 16) & 0x1ff) - 16;
drawgfxzoom(bitmap,gfx,
realtile,
color,
xflip,yflip,
sx,sy,
cliprect,TRANSPARENCY_PEN,15,
xzoom << 11, yzoom << 11);
tile++;
}
}
static void f1gp2_drawsprites(mame_bitmap *bitmap,const rectangle *cliprect)
{
int offs;
offs = 0;
while (offs < 0x0400 && (f1gp2_spritelist[offs] & 0x4000) == 0)
{
int attr_start;
int map_start;
int ox,oy,x,y,xsize,ysize,zoomx,zoomy,flipx,flipy,color;
attr_start = 4 * (f1gp2_spritelist[offs++] & 0x01ff);
ox = f1gp2_spritelist[attr_start + 1] & 0x01ff;
xsize = (f1gp2_spritelist[attr_start + 1] & 0x0e00) >> 9;
zoomx = (f1gp2_spritelist[attr_start + 1] & 0xf000) >> 12;
oy = f1gp2_spritelist[attr_start + 0] & 0x01ff;
ysize = (f1gp2_spritelist[attr_start + 0] & 0x0e00) >> 9;
zoomy = (f1gp2_spritelist[attr_start + 0] & 0xf000) >> 12;
flipx = f1gp2_spritelist[attr_start + 2] & 0x4000;
flipy = f1gp2_spritelist[attr_start + 2] & 0x8000;
color = (f1gp2_spritelist[attr_start + 2] & 0x1f00) >> 8;
map_start = f1gp2_spritelist[attr_start + 3] & 0x7fff;
// aerofgt has the following adjustment, but doing it here would break the title screen
// ox += (xsize*zoomx+2)/4;
// oy += (ysize*zoomy+2)/4;
zoomx = 32 - zoomx;
zoomy = 32 - zoomy;
if (f1gp2_spritelist[attr_start + 2] & 0x20ff) color = rand();
for (y = 0;y <= ysize;y++)
{
int sx,sy;
if (flipy) sy = ((oy + zoomy * (ysize - y)/2 + 16) & 0x1ff) - 16;
else sy = ((oy + zoomy * y / 2 + 16) & 0x1ff) - 16;
for (x = 0;x <= xsize;x++)
{
int code;
if (flipx) sx = ((ox + zoomx * (xsize - x) / 2 + 16) & 0x1ff) - 16;
else sx = ((ox + zoomx * x / 2 + 16) & 0x1ff) - 16;
code = f1gp2_sprcgram[map_start & 0x3fff];
map_start++;
if (flipscreen)
drawgfxzoom(bitmap,Machine->gfx[1],
code,
color,
!flipx,!flipy,
304-sx,208-sy,
cliprect,TRANSPARENCY_PEN,15,
zoomx << 11,zoomy << 11);
else
drawgfxzoom(bitmap,Machine->gfx[1],
code,
color,
flipx,flipy,
sx,sy,
cliprect,TRANSPARENCY_PEN,15,
zoomx << 11,zoomy << 11);
}
}
}
}
static void aerofgt_drawsprites(mame_bitmap *bitmap,const rectangle *cliprect,int priority)
{
int offs;
priority <<= 12;
offs = 0;
while (offs < 0x0400 && (aerofgt_spriteram3[offs] & 0x8000) == 0)
{
int attr_start;
attr_start = 4 * (aerofgt_spriteram3[offs] & 0x03ff);
/* is the way I handle priority correct? Or should I just check bit 13? */
if ((aerofgt_spriteram3[attr_start + 2] & 0x3000) == priority)
{
int map_start;
int ox,oy,x,y,xsize,ysize,zoomx,zoomy,flipx,flipy,color;
ox = aerofgt_spriteram3[attr_start + 1] & 0x01ff;
xsize = (aerofgt_spriteram3[attr_start + 1] & 0x0e00) >> 9;
zoomx = (aerofgt_spriteram3[attr_start + 1] & 0xf000) >> 12;
oy = aerofgt_spriteram3[attr_start + 0] & 0x01ff;
ysize = (aerofgt_spriteram3[attr_start + 0] & 0x0e00) >> 9;
zoomy = (aerofgt_spriteram3[attr_start + 0] & 0xf000) >> 12;
flipx = aerofgt_spriteram3[attr_start + 2] & 0x4000;
flipy = aerofgt_spriteram3[attr_start + 2] & 0x8000;
color = (aerofgt_spriteram3[attr_start + 2] & 0x0f00) >> 8;
map_start = aerofgt_spriteram3[attr_start + 3] & 0x3fff;
ox += (xsize*zoomx+2)/4;
oy += (ysize*zoomy+2)/4;
zoomx = 32 - zoomx;
zoomy = 32 - zoomy;
for (y = 0;y <= ysize;y++)
{
int sx,sy;
if (flipy) sy = ((oy + zoomy * (ysize - y)/2 + 16) & 0x1ff) - 16;
else sy = ((oy + zoomy * y / 2 + 16) & 0x1ff) - 16;
for (x = 0;x <= xsize;x++)
{
int code;
if (flipx) sx = ((ox + zoomx * (xsize - x) / 2 + 16) & 0x1ff) - 16;
else sx = ((ox + zoomx * x / 2 + 16) & 0x1ff) - 16;
if (map_start < 0x2000)
code = aerofgt_spriteram1[map_start & 0x1fff] & 0x1fff;
else
code = aerofgt_spriteram2[map_start & 0x1fff] & 0x1fff;
drawgfxzoom(bitmap,Machine->gfx[sprite_gfx + (map_start >= 0x2000 ? 1 : 0)],
code,
color,
flipx,flipy,
sx,sy,
cliprect,TRANSPARENCY_PEN,15,
zoomx << 11, zoomy << 11);
map_start++;
}
}
}
offs++;
}
static void othunder_draw_sprites_16x8(mame_bitmap *bitmap,const rectangle *cliprect,int *primasks,int y_offs)
{
UINT16 *spritemap = (UINT16 *)memory_region(REGION_USER1);
UINT16 tile_mask = (Machine->gfx[0]->total_elements) - 1;
int offs, data, tilenum, color, flipx, flipy;
int x, y, priority, curx, cury;
int sprites_flipscreen = 0;
int zoomx, zoomy, zx, zy;
int sprite_chunk,map_offset,code,j,k,px,py;
int bad_chunks;
/* pdrawgfx() needs us to draw sprites front to back, so we have to build a list
while processing sprite ram and then draw them all at the end */
struct tempsprite *sprite_ptr = spritelist;
for (offs = (spriteram_size/2)-4;offs >=0;offs -= 4)
{
data = spriteram16[offs+0];
zoomy = (data & 0xfe00) >> 9;
y = data & 0x1ff;
data = spriteram16[offs+1];
flipx = (data & 0x4000) >> 14;
priority = (data & 0x8000) >> 15;
x = data & 0x1ff;
data = spriteram16[offs+2];
color = (data & 0xff00) >> 8;
zoomx = (data & 0x7f);
data = spriteram16[offs+3];
tilenum = data & 0x1fff; /* $80000 spritemap rom maps up to $2000 64x64 sprites */
flipy = (data & 0x8000) >> 15;
if (!tilenum) continue;
map_offset = tilenum << 5;
zoomx += 1;
zoomy += 1;
y += y_offs;
/* treat coords as signed */
if (x>0x140) x -= 0x200;
if (y>0x140) y -= 0x200;
bad_chunks = 0;
for (sprite_chunk=0;sprite_chunk<32;sprite_chunk++)
{
k = sprite_chunk % 4; /* 4 chunks per row */
j = sprite_chunk / 4; /* 8 rows */
px = k;
py = j;
if (flipx) px = 3-k; /* pick tiles back to front for x and y flips */
if (flipy) py = 7-j;
code = spritemap[map_offset + px + (py<<2)] &tile_mask;
if (code==0xffff)
{
bad_chunks += 1;
continue;
}
curx = x + ((k*zoomx)/4);
cury = y + ((j*zoomy)/8);
zx= x + (((k+1)*zoomx)/4) - curx;
zy= y + (((j+1)*zoomy)/8) - cury;
if (sprites_flipscreen)
{
/* -zx/y is there to fix zoomed sprite coords in screenflip.
drawgfxzoom does not know to draw from flip-side of sprites when
screen is flipped; so we must correct the coords ourselves. */
curx = 320 - curx - zx;
cury = 256 - cury - zy;
flipx = !flipx;
flipy = !flipy;
}
sprite_ptr->code = code;
sprite_ptr->color = color;
sprite_ptr->flipx = flipx;
sprite_ptr->flipy = flipy;
sprite_ptr->x = curx;
sprite_ptr->y = cury;
sprite_ptr->zoomx = zx << 12;
sprite_ptr->zoomy = zy << 13;
if (primasks)
{
sprite_ptr->primask = primasks[priority];
sprite_ptr++;
}
else
{
drawgfxzoom(bitmap,Machine->gfx[0],
sprite_ptr->code,
sprite_ptr->color,
sprite_ptr->flipx,sprite_ptr->flipy,
sprite_ptr->x,sprite_ptr->y,
cliprect,TRANSPARENCY_PEN,0,
sprite_ptr->zoomx,sprite_ptr->zoomy);
}
}
if (bad_chunks)
logerror("Sprite number %04x had %02x invalid chunks\n",tilenum,bad_chunks);
}
/* this happens only if primsks != NULL */
while (sprite_ptr != spritelist)
{
sprite_ptr--;
pdrawgfxzoom(bitmap,Machine->gfx[0],
sprite_ptr->code,
sprite_ptr->color,
sprite_ptr->flipx,sprite_ptr->flipy,
sprite_ptr->x,sprite_ptr->y,
cliprect,TRANSPARENCY_PEN,0,
sprite_ptr->zoomx,sprite_ptr->zoomy,
sprite_ptr->primask);
}
}
/* todo, fix zooming correctly, its _not_ like aerofgt */
static void suprslam_drawsprites( mame_bitmap *bitmap, const rectangle *cliprect )
{
/* SPRITE INFO
Video System hardware, like aerofgt etc.
the sprites use 2 areas of ram, one containing a spritelist + sprite attributes, the other
contains the sprite tile #'s to use
sprite attribute info (4 words per sprite)
| ZZZZ hhhy yyyy yyyy | zzzz wwwx xxxx xxxx | -fpp pppp ---- ---- | -ooo oooo oooo oooo |
x = x position
y = y position
w = width
h = height
zZ = y zoom / x zoom
f = xflip
p = palette / colour
o = offset to tile data in other ram area
*/
const gfx_element *gfx = Machine->gfx[1];
UINT16 *source = suprslam_spriteram;
UINT16 *source2 = suprslam_spriteram;
UINT16 *finish = source + 0x2000/2;
while( source<finish )
{
UINT32 sprnum = source[0] & 0x03ff;
if (source[0] == 0x4000) break;
sprnum *= 4;
source++;
/* DRAW START */
{
int ypos = source2[sprnum+0] & 0x1ff;
int high = (source2[sprnum+0] & 0x0e00) >> 9;
int yzoom = (source2[sprnum+0] & 0xf000) >> 12;
int xpos = source2[sprnum+1] & 0x1ff;
int wide = (source2[sprnum+1] & 0x0e00) >> 9;
int xzoom = (source2[sprnum+1] & 0xf000) >> 12;
int col = (source2[sprnum+2] & 0x3f00) >> 8;
int flipx = (source2[sprnum+2] & 0x4000) >> 14;
/* int flipy = (source2[sprnum+2] & 0x8000) >> 15; */
int word_offset = source2[sprnum+3] & 0x7fff;
int xcnt, ycnt;
int loopno = 0;
xzoom = 32 - xzoom;
yzoom = 32 - yzoom;
if (ypos > 0xff) ypos -=0x200;
for (ycnt = 0; ycnt < high+1; ycnt ++) {
if (!flipx) {
for (xcnt = 0; xcnt < wide+1; xcnt ++) {
int tileno = suprslam_sp_videoram[word_offset+loopno];
drawgfxzoom(bitmap, gfx, tileno, col, 0, 0,xpos + xcnt * xzoom/2, ypos + ycnt * yzoom/2, cliprect, TRANSPARENCY_PEN, 15,xzoom << 11, yzoom << 11);
drawgfxzoom(bitmap, gfx, tileno, col, 0, 0,-0x200+xpos + xcnt * xzoom/2, ypos + ycnt * yzoom/2, cliprect, TRANSPARENCY_PEN, 15,xzoom << 11, yzoom << 11);
loopno ++;
}
} else {
for (xcnt = wide; xcnt >= 0; xcnt --) {
int tileno = suprslam_sp_videoram[word_offset+loopno];
drawgfxzoom(bitmap, gfx, tileno, col, 1, 0,xpos + xcnt * xzoom/2, ypos + ycnt * yzoom/2, cliprect, TRANSPARENCY_PEN, 15,xzoom << 11, yzoom << 11);
drawgfxzoom(bitmap, gfx, tileno, col, 1, 0,-0x200+xpos + xcnt * xzoom/2, ypos + ycnt * yzoom/2, cliprect, TRANSPARENCY_PEN, 15,xzoom << 11, yzoom << 11);
loopno ++;
}
}
}
}
}
}
static void dleague_draw_sprites(struct osd_bitmap *bitmap, int priority)
{
/* Y chain size is 16/32?/64/64? pixels. X chain size
is always 64 pixels. */
int size[] = { 1, 2, 4, 4 };
int x0, y0, x, y, dx, ex, zx;
int ysize;
int j, k;
int offs; /* sprite RAM offset */
int tile_offs; /* sprite chain offset */
int zoomx; /* zoomx value */
int pribit;
for (offs = 0x03f8 / 2 ; offs >= 0 ; offs -= 0x008 / 2)
{
x0 = TC0080VCO_spriteram[offs + 1] & 0x3ff;
y0 = TC0080VCO_spriteram[offs + 0] & 0x3ff;
zoomx = (TC0080VCO_spriteram[offs + 2] & 0x7f00) >> 8;
tile_offs = (TC0080VCO_spriteram[offs + 3] & 0x1fff) << 2;
pribit = (TC0080VCO_spriteram[offs + 0] & 0x1000) >> 12;
ysize = size[ ( TC0080VCO_spriteram[ offs ] & 0x0c00 ) >> 10 ];
if (tile_offs)
{
/* The increasing ratio of expansion is different whether zoom value */
/* is less or more than 63. */
if (zoomx < 63)
{
dx = 8 + (zoomx + 2) / 8;
ex = (zoomx + 2) % 8;
zx = ((dx << 1) + ex) << 11;
pribit = 0;
}
else
{
dx = 16 + (zoomx - 63) / 4;
ex = (zoomx - 63) % 4;
zx = (dx + ex) << 12;
}
if (TC0080VCO_scroll_ram[0x0002] & 0x8000)
pribit = 1;
if (x0 >= 0x200) x0 -= 0x400;
if (y0 >= 0x200) y0 -= 0x400;
if (TC0080VCO_flipscreen)
{
x0 = 497 - x0;
y0 = 498 - y0;
dx = -dx;
}
else
{
x0 += 1;
y0 += 2;
}
if ( priority == pribit )
{
y = y0;
for ( j = 0 ; j < ysize ; j ++ )
{
x = x0;
for (k = 0 ; k < 4 ; k ++ )
{
if (tile_offs >= 0x1000) /* or pitcher gets blanked */
{
int tile, color, flipx, flipy;
tile = TC0080VCO_chain_ram_0[tile_offs] & 0x7fff;
color = TC0080VCO_chain_ram_1[tile_offs] & 0x001f;
flipx = TC0080VCO_chain_ram_1[tile_offs] & 0x0040;
flipy = TC0080VCO_chain_ram_1[tile_offs] & 0x0080;
if (TC0080VCO_flipscreen)
{
flipx ^= 0x0040;
flipy ^= 0x0080;
}
drawgfxzoom( bitmap, Machine -> gfx[0],
tile,
color,
flipx, flipy,
x, y,
&Machine->visible_area,
TRANSPARENCY_PEN, 0,
zx, zx
);
}
tile_offs ++;
x += dx;
}
y += dx;
}
}
}
}
}
static void draw_sprites(mame_bitmap *bitmap, const rectangle *cliprect, int sprite_priority)
{
UINT16 *mem1 = &tceptor_sprite_ram[0x000/2];
UINT16 *mem2 = &tceptor_sprite_ram[0x100/2];
int need_mask = 0;
int i;
for (i = 0; i < 0x100; i += 2)
{
int scalex = (mem1[1 + i] & 0xfc00) << 1;
int scaley = (mem1[0 + i] & 0xfc00) << 1;
int pri = 7 - ((mem1[1 + i] & 0x3c0) >> 6);
if (pri == sprite_priority && scalex && scaley)
{
int x = mem2[1 + i] & 0x3ff;
int y = 512 - (mem2[0 + i] & 0x3ff);
int flipx = mem2[0 + i] & 0x4000;
int flipy = mem2[0 + i] & 0x8000;
int color = mem1[1 + i] & 0x3f;
int gfx;
int code;
if (mem2[0 + i] & 0x2000)
{
gfx = sprite32;
code = mem1[0 + i] & 0x3ff;
}
else
{
gfx = sprite16;
code = mem1[0 + i] & 0x1ff;
scaley *= 2;
}
if (is_mask_spr[color])
{
if (!need_mask)
{
// backup previous bitmap
copybitmap(temp_bitmap, bitmap, 0, 0, 0, 0, cliprect, TRANSPARENCY_NONE, 0);
}
need_mask = 1;
}
// round off
scalex += 0x800;
scaley += 0x800;
x -= 64;
y -= 78;
drawgfxzoom(bitmap,
Machine->gfx[gfx],
code,
color,
flipx, flipy,
x, y,
cliprect,
TRANSPARENCY_COLOR, SPR_TRANS_COLOR,
scalex,
scaley);
}
}
/* if SPR_MASK_COLOR pen is used, restore pixels from previous bitmap */
if (need_mask)
{
int x, y;
for (x = cliprect->min_x; x <= cliprect->max_x; x++)
for (y = cliprect->min_y; y <= cliprect->max_y; y++)
if (read_pixel(bitmap, x, y) == SPR_MASK_COLOR)
{
int color = read_pixel(temp_bitmap, x, y);
// restore pixel
plot_pixel(bitmap, x, y, color);
}
}
}
/* Very preliminary! */
static void draw_sprites(mame_bitmap *bitmap,const rectangle *cliprect)
{
int offs=0;
int index_x=0, index_y=0;
UINT16 *ROM_LUTA = (UINT16 *)memory_region(REGION_USER1);
UINT8 *ROM_LUTB = (UINT8 *)memory_region(REGION_USER2);
UINT8 *ROM_LUTC = (UINT8 *)memory_region(REGION_USER2)+0x8000; // Selected by bit 7...
for (offs = 0x0; offs <= (objectram_size); offs += 8)
{
int offs0 = object_ram[offs+6] << 8; // Lower 6-bits go into upper ROM portion
int bit7 = (object_ram[offs+6] >> 7) & 0x1; // Selects which ROM to use in calculating lookup
int lut;
if(!object_ram[offs+4] && !object_ram[offs+5])
continue;
if(object_ram[offs+7] == 0xfc || object_ram[offs+7] == 0xff) // ?
break;
if(!bit7)
lut = (ROM_LUTC[offs0 | (index_y<<4) | index_x]) & 0x7f;
else
lut = (ROM_LUTB[offs0 | (index_y<<4) | index_x]) & 0x7f;
// Bits 12,13,14 = bank
// Bits 0-11 obj
for(index_y=0; index_y<8; index_y++)
{
int index_x;
for(index_x=0; index_x<8; index_x++)
{
/* Index into the object lookup table */
int ROM_LUT_HI = object_ram[offs+5] << 8;
/* This is calculated from another LUT and current tile? */
int ROM_LUT_LO = object_ram[offs+4] + lut;
int ref = ROM_LUT_LO + ROM_LUT_HI;
int pix = ROM_LUTA[ref+index_x+(16*index_y)]; // ???
int flip_x = 0;//(object_ram[offs+3] >> 8) & 0x1; // Bit 15
int flip_y = 0;//(object_ram[offs+3] >> 7) & 0x1; // Bit 14
int scale_x = 0xffff; //+ object_ram[offs+2]; //0x1ffff;
int scale_y = 0xffff; //+ object_ram[offs+3]; //0x1ffff;
int sy = 255-object_ram[offs]+(index_y*8)*(scale_y/0xffff);
int sx = (object_ram[offs+1])+(index_x*8)*(scale_x/0xffff);
int bank = ((pix >> 12) & 0x7);
int index = pix & 0xfff;
int color = 1;
const gfx_element *gfx = Machine->gfx[bank];
drawgfxzoom(bitmap, gfx,
index,
color,
flip_x,flip_y, // FlipX, flipY
sx,sy,
cliprect,TRANSPARENCY_PEN,1,
scale_x,scale_y);
}
}
}
}
