static void draw_sprites(running_machine *machine, bitmap_t *bitmap,const rectangle *cliprect)
{
int offs,map_offset,x,y,curx,cury,sprite_chunk;
UINT16 *spritemap = topspeed_spritemap;
UINT16 data,tilenum,code,color;
UINT8 flipx,flipy,priority,bad_chunks;
UINT8 j,k,px,py,zx,zy,zoomx,zoomy;
static const int primasks[2] = {0xff00,0xfffc}; /* Sprites are over bottom layer or under top layer */
/* Most of spriteram is not used by the 68000: rest is scratch space for the h/w perhaps ? */
for (offs = 0;offs <(0x2c0/2);offs += 4)
{
data = spriteram16[offs+2];
tilenum = spriteram16[offs+3] & 0xff;
color = (spriteram16[offs+3] & 0xff00) >> 8;
flipx = (data & 0x4000) >> 14;
flipy = (spriteram16[offs+1] & 0x8000) >> 15;
x = data & 0x1ff;
y = spriteram16[offs] & 0x1ff;
zoomx = (spriteram16[offs+1]& 0x7f);
zoomy = (spriteram16[offs] & 0xfe00) >> 9;
priority = (data & 0x8000) >> 15;
// unknown = (data & 0x2000) >> 13;
if (y == 0x180) continue; /* dead sprite */
map_offset = tilenum << 7;
zoomx += 1;
zoomy += 1;
y += 3 + (128-zoomy);
/* treat coords as signed */
if (x > 0x140) x -= 0x200;
if (y > 0x140) y -= 0x200;
bad_chunks = 0;
for (sprite_chunk = 0;sprite_chunk < 128;sprite_chunk++)
{
k = sprite_chunk % 8; /* 8 sprite chunks per row */
j = sprite_chunk / 8; /* 16 rows */
/* pick tiles back to front for x and y flips */
px = (flipx) ? (7-k) : (k);
py = (flipy) ? (15-j) : (j);
code = spritemap[map_offset + (py<<3) + px];
if (code & 0x8000)
{
bad_chunks += 1;
continue;
}
curx = x + ((k*zoomx)/8);
cury = y + ((j*zoomy)/16);
zx = x + (((k+1)*zoomx)/8) - curx;
zy = y + (((j+1)*zoomy)/16) - cury;
pdrawgfxzoom(bitmap,machine->gfx[0],
code,
color,
flipx,flipy,
curx,cury,
cliprect,TRANSPARENCY_PEN,0,
zx<<12,zy<<13,
primasks[priority]);
}
if (bad_chunks)
logerror("Sprite number %04x had %02x invalid chunks\n",tilenum,bad_chunks);
}
}
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 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);
}
}
static void f1gp_drawsprites(mame_bitmap *bitmap,const rectangle *cliprect,int chip,int primask)
{
int attr_start,first;
UINT16 *spram = chip ? f1gp_spr2vram : f1gp_spr1vram;
first = 4 * spram[0x1fe];
for (attr_start = 0x0200-8;attr_start >= first;attr_start -= 4)
{
int map_start;
int ox,oy,x,y,xsize,ysize,zoomx,zoomy,flipx,flipy,color,pri;
/* table hand made by looking at the ship explosion in attract mode */
/* it's almost a logarithmic scale but not exactly */
static const int zoomtable[16] = { 0,7,14,20,25,30,34,38,42,46,49,52,54,57,59,61 };
if (!(spram[attr_start + 2] & 0x0080)) continue;
ox = spram[attr_start + 1] & 0x01ff;
xsize = (spram[attr_start + 2] & 0x0700) >> 8;
zoomx = (spram[attr_start + 1] & 0xf000) >> 12;
oy = spram[attr_start + 0] & 0x01ff;
ysize = (spram[attr_start + 2] & 0x7000) >> 12;
zoomy = (spram[attr_start + 0] & 0xf000) >> 12;
flipx = spram[attr_start + 2] & 0x0800;
flipy = spram[attr_start + 2] & 0x8000;
color = (spram[attr_start + 2] & 0x000f);// + 16 * spritepalettebank;
pri = 0;//spram[attr_start + 2] & 0x0010;
map_start = spram[attr_start + 3];
zoomx = 16 - zoomtable[zoomx]/8;
zoomy = 16 - zoomtable[zoomy]/8;
for (y = 0;y <= ysize;y++)
{
int sx,sy;
if (flipy) sy = ((oy + zoomy * (ysize - y) + 16) & 0x1ff) - 16;
else sy = ((oy + zoomy * y + 16) & 0x1ff) - 16;
for (x = 0;x <= xsize;x++)
{
int code;
if (flipx) sx = ((ox + zoomx * (xsize - x) + 16) & 0x1ff) - 16;
else sx = ((ox + zoomx * x + 16) & 0x1ff) - 16;
if (chip == 0)
code = f1gp_spr1cgram[map_start % (f1gp_spr1cgram_size/2)];
else
code = f1gp_spr2cgram[map_start % (f1gp_spr2cgram_size/2)];
pdrawgfxzoom(bitmap,Machine->gfx[1 + chip],
code,
color,
flipx,flipy,
sx,sy,
cliprect,TRANSPARENCY_PEN,15,
0x1000 * zoomx,0x1000 * zoomy,
// pri ? 0 : 0x2);
primask);
map_start++;
}
if (xsize == 2) map_start += 1;
if (xsize == 4) map_start += 3;
if (xsize == 5) map_start += 2;
if (xsize == 6) map_start += 1;
}
}
}
static void draw_sprites(running_machine *machine, bitmap_t *bitmap, const rectangle *cliprect)
{
int offs;
for (offs = (inufuku_spriteram1_size / 16) - 1; offs >= 0; offs--) {
if ((inufuku_spriteram1[offs] & 0x8000) == 0x0000) {
int attr_start;
int map_start;
int ox, oy, x, y, xsize, ysize, zoomx, zoomy, flipx, flipy, color;
int priority, priority_mask;
attr_start = 4 * (inufuku_spriteram1[offs] & 0x03ff);
/*
attr_start + 0x0000
---- ---x xxxx xxxx oy
---- xxx- ---- ---- ysize
xxxx ---- ---- ---- zoomy
attr_start + 0x0001
---- ---x xxxx xxxx ox
---- xxx- ---- ---- xsize
xxxx ---- ---- ---- zoomx
attr_start + 0x0002
-x-- ---- ---- ---- flipx
x--- ---- ---- ---- flipy
--xx xxxx ---- ---- color
--xx ---- ---- ---- priority?
---- ---- xxxx xxxx unused?
attr_start + 0x0003
-xxx xxxx xxxx xxxx map start
x--- ---- ---- ---- unused?
*/
ox = (inufuku_spriteram1[attr_start + 1] & 0x01ff) + 0;
xsize = (inufuku_spriteram1[attr_start + 1] & 0x0e00) >> 9;
zoomx = (inufuku_spriteram1[attr_start + 1] & 0xf000) >> 12;
oy = (inufuku_spriteram1[attr_start + 0] & 0x01ff) + 1;
ysize = (inufuku_spriteram1[attr_start + 0] & 0x0e00) >> 9;
zoomy = (inufuku_spriteram1[attr_start + 0] & 0xf000) >> 12;
flipx = inufuku_spriteram1[attr_start + 2] & 0x4000;
flipy = inufuku_spriteram1[attr_start + 2] & 0x8000;
color = (inufuku_spriteram1[attr_start + 2] & 0x3f00) >> 8;
priority = (inufuku_spriteram1[attr_start + 2] & 0x3000) >> 12;
map_start = (inufuku_spriteram1[attr_start + 3] & 0x7fff) << 1;
switch (priority) {
default:
case 0: priority_mask = 0x00; break;
case 3: priority_mask = 0xfe; break;
case 2: priority_mask = 0xfc; break;
case 1: priority_mask = 0xf0; break;
}
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;
else
sy = (oy + zoomy * y / 2 + 16) & 0x1ff;
for (x = 0; x <= xsize; x++) {
int code;
if (flipx)
sx = (ox + zoomx * (xsize - x) / 2 + 16) & 0x1ff;
else
sx = (ox + zoomx * x / 2 + 16) & 0x1ff;
code = ((inufuku_spriteram2[map_start] & 0x0007) << 16) + inufuku_spriteram2[map_start + 1];
pdrawgfxzoom(bitmap, machine->gfx[2],
code,
color,
flipx, flipy,
sx - 16, sy - 16,
cliprect, TRANSPARENCY_PEN, 15,
zoomx << 11, zoomy << 11,
priority_mask);
map_start += 2;
}
}
}
}