Sprinter/mame
2
0
Fork 0
mirror of https://github.com/holub/mame synced 2025-04-30 19:57:11 +03:00
Code Issues Actions 6 Packages Projects Releases Wiki Activity

vsystem improvements by Haze (no whatsnew)

Browse Source
This commit is contained in:
Miodrag Milanovic 2012-10-12 09:07:03 +00:00
parent c084f5c65e
commit 63f0ed9b1d
4 changed files with 487 additions and 544 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

512
src/mame/video/vsystem_spr.c
View File

@ -1,6 +1,6 @@
// Video System Sprites // Video System Sprites
// todo: // todo:
// unify these functions (secondary stage tile lookup differs between games, use callback) // unify these functions (secondary stage lookup differs between games, use callback)
// according to gstriker this is probably the Fujitsu CG10103 // according to gstriker this is probably the Fujitsu CG10103
@ -38,7 +38,47 @@ void vsystem_spr_device::device_reset()
} }
void vsystem_spr_device::get_sprite_attributes(UINT16* ram)
{
/*
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? (upper color bits)
---- ---- ---- ---x map start (msb)
attr_start + 0x0003
xxxx xxxx xxxx xxxx map start (lsb)
*/
curr_sprite.oy = (ram[0] & 0x01ff);
curr_sprite.ysize = (ram[0] & 0x0e00) >> 9;
curr_sprite.zoomy = (ram[0] & 0xf000) >> 12;
curr_sprite.ox = (ram[1] & 0x01ff);
curr_sprite.xsize = (ram[1] & 0x0e00) >> 9;
curr_sprite.zoomx = (ram[1] & 0xf000) >> 12;
curr_sprite.flipx = (ram[2] & 0x4000);
curr_sprite.flipy = (ram[2] & 0x8000);
curr_sprite.color = (ram[2] & 0x3f00) >> 8;
curr_sprite.pri = (ram[2] & 0x3000) >> 12;
curr_sprite.map = (ram[2] & 0x0001) << 16;
curr_sprite.map |= (ram[3] & 0xffff);
}
// zooming is wrong for 3on3dunk ... suprslam implementation is probably better // zooming is wrong for 3on3dunk ... suprslam implementation is probably better
void vsystem_spr_device::draw_sprites_inufuku( UINT16* spriteram, int spriteram_bytes, UINT16* spriteram2, running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect ) void vsystem_spr_device::draw_sprites_inufuku( UINT16* spriteram, int spriteram_bytes, UINT16* spriteram2, running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect )
@ -57,48 +97,17 @@ void vsystem_spr_device::draw_sprites_inufuku( UINT16* spriteram, int spriteram_
if ((spriteram[offs] & 0x8000) == 0x0000) if ((spriteram[offs] & 0x8000) == 0x0000)
{ {
int attr_start; int attr_start;
int map_start; int x, y;
int ox, oy, x, y, xsize, ysize, zoomx, zoomy, flipx, flipy, color; int priority_mask;
int priority, priority_mask;
attr_start = 4 * (spriteram[offs] & 0x03ff); attr_start = 4 * (spriteram[offs] & 0x03ff);
/* get_sprite_attributes(&spriteram[attr_start]);
attr_start + 0x0000
---- ---x xxxx xxxx oy
---- xxx- ---- ---- ysize
xxxx ---- ---- ---- zoomy
attr_start + 0x0001 curr_sprite.oy += 1;
---- ---x xxxx xxxx ox curr_sprite.map &= 0x7fff;
---- xxx- ---- ---- xsize
xxxx ---- ---- ---- zoomx
attr_start + 0x0002 switch (curr_sprite.pri)
-x-- ---- ---- ---- flipx
x--- ---- ---- ---- flipy
--xx xxxx ---- ---- color
--xx ---- ---- ---- priority?
---- ---- xxxx xxxx unused?
attr_start + 0x0003
-xxx xxxx xxxx xxxx map start
x--- ---- ---- ---- unused?
*/
ox = (spriteram[attr_start + 1] & 0x01ff) + 0;
xsize = (spriteram[attr_start + 1] & 0x0e00) >> 9;
zoomx = (spriteram[attr_start + 1] & 0xf000) >> 12;
oy = (spriteram[attr_start + 0] & 0x01ff) + 1;
ysize = (spriteram[attr_start + 0] & 0x0e00) >> 9;
zoomy = (spriteram[attr_start + 0] & 0xf000) >> 12;
flipx = spriteram[attr_start + 2] & 0x4000;
flipy = spriteram[attr_start + 2] & 0x8000;
color = (spriteram[attr_start + 2] & 0x3f00) >> 8;
priority = (spriteram[attr_start + 2] & 0x3000) >> 12;
map_start = (spriteram[attr_start + 3] & 0x7fff) << 1;
switch (priority)
{ {
default: default:
case 0: priority_mask = 0x00; break; case 0: priority_mask = 0x00; break;
@ -107,41 +116,41 @@ void vsystem_spr_device::draw_sprites_inufuku( UINT16* spriteram, int spriteram_
case 1: priority_mask = 0xf0; break; case 1: priority_mask = 0xf0; break;
} }
ox += (xsize * zoomx + 2) / 4; curr_sprite.ox += (curr_sprite.xsize * curr_sprite.zoomx + 2) / 4;
oy += (ysize * zoomy + 2) / 4; curr_sprite.oy += (curr_sprite.ysize * curr_sprite.zoomy + 2) / 4;
zoomx = 32 - zoomx; curr_sprite.zoomx = 32 - curr_sprite.zoomx;
zoomy = 32 - zoomy; curr_sprite.zoomy = 32 - curr_sprite.zoomy;
for (y = 0; y <= ysize; y++) for (y = 0; y <= curr_sprite.ysize; y++)
{ {
int sx, sy; int sx, sy;
if (flipy) if (curr_sprite.flipy)
sy = (oy + zoomy * (ysize - y) / 2 + 16) & 0x1ff; sy = (curr_sprite.oy + curr_sprite.zoomy * (curr_sprite.ysize - y) / 2 + 16) & 0x1ff;
else else
sy = (oy + zoomy * y / 2 + 16) & 0x1ff; sy = (curr_sprite.oy + curr_sprite.zoomy * y / 2 + 16) & 0x1ff;
for (x = 0; x <= xsize; x++) for (x = 0; x <= curr_sprite.xsize; x++)
{ {
int code; int code;
if (flipx) if (curr_sprite.flipx)
sx = (ox + zoomx * (xsize - x) / 2 + 16) & 0x1ff; sx = (curr_sprite.ox + curr_sprite.zoomx * (curr_sprite.xsize - x) / 2 + 16) & 0x1ff;
else else
sx = (ox + zoomx * x / 2 + 16) & 0x1ff; sx = (curr_sprite.ox + curr_sprite.zoomx * x / 2 + 16) & 0x1ff;
code = ((spriteram2[map_start] & 0x0007) << 16) + spriteram2[map_start + 1]; code = ((spriteram2[curr_sprite.map*2] & 0x0007) << 16) + spriteram2[(curr_sprite.map*2)+ 1];
pdrawgfxzoom_transpen(bitmap, cliprect, machine.gfx[2], pdrawgfxzoom_transpen(bitmap, cliprect, machine.gfx[2],
code, code,
color, curr_sprite.color,
flipx, flipy, curr_sprite.flipx, curr_sprite.flipy,
sx - 16, sy - 16, sx - 16, sy - 16,
zoomx << 11, zoomy << 11, curr_sprite.zoomx << 11, curr_sprite.zoomy << 11,
machine.priority_bitmap,priority_mask, 15); machine.priority_bitmap,priority_mask, 15);
map_start += 2; curr_sprite.map ++;
} }
} }
} }
@ -153,28 +162,6 @@ void vsystem_spr_device::draw_sprites_inufuku( UINT16* spriteram, int spriteram_
/* todo, fix zooming correctly, it's _not_ like aerofgt */ /* todo, fix zooming correctly, it's _not_ like aerofgt */
void vsystem_spr_device::draw_sprites_suprslam( UINT16* spriteram, int spriteram_bytes, UINT16* spriteram2, running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect ) void vsystem_spr_device::draw_sprites_suprslam( UINT16* spriteram, int spriteram_bytes, UINT16* spriteram2, running_machine &machine, bitmap_ind16 &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
*/
gfx_element *gfx = machine.gfx[1]; gfx_element *gfx = machine.gfx[1];
UINT16 *source = spriteram; UINT16 *source = spriteram;
UINT16 *source2 = spriteram; UINT16 *source2 = spriteram;
@ -190,47 +177,38 @@ void vsystem_spr_device::draw_sprites_suprslam( UINT16* spriteram, int spriteram
source++; source++;
/* DRAW START */ /* DRAW START */
{ {
int ypos = source2[sprnum + 0] & 0x1ff; get_sprite_attributes(&source2[sprnum]);
int high = (source2[sprnum + 0] & 0x0e00) >> 9;
int yzoom = (source2[sprnum + 0] & 0xf000) >> 12;
int xpos = source2[sprnum + 1] & 0x1ff; curr_sprite.map &= 0x7fff;
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 xcnt, ycnt;
int loopno = 0; int loopno = 0;
xzoom = 32 - xzoom; curr_sprite.zoomx = 32 - curr_sprite.zoomx;
yzoom = 32 - yzoom; curr_sprite.zoomy = 32 - curr_sprite.zoomy;
if (ypos > 0xff) ypos -=0x200; if (curr_sprite.oy > 0xff) curr_sprite.oy -=0x200;
for (ycnt = 0; ycnt < high+1; ycnt ++) for (ycnt = 0; ycnt < curr_sprite.ysize+1; ycnt ++)
{ {
if (!flipx) if (!curr_sprite.flipx)
{ {
for (xcnt = 0; xcnt < wide+1; xcnt ++) for (xcnt = 0; xcnt < curr_sprite.xsize+1; xcnt ++)
{ {
int tileno = spriteram2[word_offset + loopno]; int startno = spriteram2[curr_sprite.map + loopno];
drawgfxzoom_transpen(bitmap, cliprect, gfx, tileno, col, 0, 0,xpos + xcnt * xzoom/2, ypos + ycnt * yzoom/2,xzoom << 11, yzoom << 11, 15); drawgfxzoom_transpen(bitmap, cliprect, gfx, startno, curr_sprite.color, 0, 0,curr_sprite.ox + xcnt * curr_sprite.zoomx/2, curr_sprite.oy + ycnt * curr_sprite.zoomy/2,curr_sprite.zoomx << 11, curr_sprite.zoomy << 11, 15);
drawgfxzoom_transpen(bitmap, cliprect, gfx, tileno, col, 0, 0,-0x200+xpos + xcnt * xzoom/2, ypos + ycnt * yzoom/2,xzoom << 11, yzoom << 11, 15); drawgfxzoom_transpen(bitmap, cliprect, gfx, startno, curr_sprite.color, 0, 0,-0x200+curr_sprite.ox + xcnt * curr_sprite.zoomx/2, curr_sprite.oy + ycnt * curr_sprite.zoomy/2,curr_sprite.zoomx << 11, curr_sprite.zoomy << 11, 15);
loopno ++; loopno ++;
} }
} }
else else
{ {
for (xcnt = wide; xcnt >= 0; xcnt --) for (xcnt = curr_sprite.xsize; xcnt >= 0; xcnt --)
{ {
int tileno = spriteram2[word_offset + loopno]; int startno = spriteram2[curr_sprite.map + loopno];
drawgfxzoom_transpen(bitmap, cliprect, gfx, tileno, col, 1, 0,xpos + xcnt * xzoom/2, ypos + ycnt * yzoom/2,xzoom << 11, yzoom << 11, 15); drawgfxzoom_transpen(bitmap, cliprect, gfx, startno, curr_sprite.color, 1, 0,curr_sprite.ox + xcnt * curr_sprite.zoomx/2, curr_sprite.oy + ycnt * curr_sprite.zoomy/2,curr_sprite.zoomx << 11, curr_sprite.zoomy << 11, 15);
drawgfxzoom_transpen(bitmap, cliprect, gfx, tileno, col, 1, 0,-0x200+xpos + xcnt * xzoom/2, ypos + ycnt * yzoom/2,xzoom << 11, yzoom << 11, 15); drawgfxzoom_transpen(bitmap, cliprect, gfx, startno, curr_sprite.color, 1, 0,-0x200+curr_sprite.ox + xcnt * curr_sprite.zoomx/2, curr_sprite.oy + ycnt * curr_sprite.zoomy/2,curr_sprite.zoomx << 11, curr_sprite.zoomy << 11, 15);
loopno ++; loopno ++;
} }
} }
@ -241,7 +219,7 @@ void vsystem_spr_device::draw_sprites_suprslam( UINT16* spriteram, int spriteram
static void draw_sprite_taotaido( UINT16* spriteram, int spriteram_bytes, UINT16* spriteram2, UINT16* spriteram3, running_machine &machine, UINT16 spriteno, bitmap_ind16 &bitmap, const rectangle &cliprect ) void vsystem_spr_device::draw_sprite_taotaido( UINT16* spriteram, int spriteram_bytes, UINT16* spriteram2, UINT16* spriteram3, running_machine &machine, UINT16 spriteno, bitmap_ind16 &bitmap, const rectangle &cliprect )
{ {
/*- SPR RAM Format -** /*- SPR RAM Format -**
@ -249,8 +227,8 @@ static void draw_sprite_taotaido( UINT16* spriteram, int spriteram_bytes, UINT16
zzzz sssp pppp pppp (y zoom, y size, y position) zzzz sssp pppp pppp (y zoom, y size, y position)
zzzz sssp pppp pppp (x zoom, x size, x position) zzzz sssp pppp pppp (x zoom, x size, x position)
yxpc cccc ---- ---- (flipy, flipx, priority?, colour) yxpc cccc ---- ---- (flipy, >flipx, priority?, color)
-nnn nnnn nnnn nnnn (tile lookup) -nnn nnnn nnnn nnnn (map_start lookup)
*/ */
@ -259,66 +237,55 @@ static void draw_sprite_taotaido( UINT16* spriteram, int spriteram_bytes, UINT16
UINT16 *source = &spriteram[spriteno*4]; UINT16 *source = &spriteram[spriteno*4];
gfx_element *gfx = machine.gfx[0]; gfx_element *gfx = machine.gfx[0];
get_sprite_attributes(&source[0]);
int yzoom = (source[0] & 0xf000) >> 12; curr_sprite.map &= 0xffff;
int xzoom = (source[1] & 0xf000) >> 12; curr_sprite.color &= 0x1f;
int ysize = (source[0] & 0x0e00) >> 9; curr_sprite.ox += (curr_sprite.xsize*curr_sprite.zoomx+2)/4;
int xsize = (source[1] & 0x0e00) >> 9; curr_sprite.oy += (curr_sprite.ysize*curr_sprite.zoomy+2)/4;
int ypos = source[0] & 0x01ff; curr_sprite.zoomx = 32 - curr_sprite.zoomx;
int xpos = source[1] & 0x01ff; curr_sprite.zoomy = 32 - curr_sprite.zoomy;
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++) for (y = 0;y <= curr_sprite.ysize;y++)
{ {
int sx,sy; int sx,sy;
if (yflip) sy = ((ypos + yzoom * (ysize - y)/2 + 16) & 0x1ff) - 16; if (curr_sprite.flipy) sy = ((curr_sprite.oy + curr_sprite.zoomy * (curr_sprite.ysize - y)/2 + 16) & 0x1ff) - 16;
else sy = ((ypos + yzoom * y / 2 + 16) & 0x1ff) - 16; else sy = ((curr_sprite.oy + curr_sprite.zoomy * y / 2 + 16) & 0x1ff) - 16;
for (x = 0;x <= xsize;x++) for (x = 0;x <= curr_sprite.xsize;x++)
{ {
/* this indirection is a bit different to the other video system games */ /* this indirection is a bit different to the other video system games */
int realtile; int realstart;
realtile = spriteram2[tile&0x7fff]; realstart = spriteram2[curr_sprite.map&0x7fff];
if (realtile > 0x3fff) if (realstart > 0x3fff)
{ {
int block; int block;
block = (realtile & 0x3800)>>11; block = (realstart & 0x3800)>>11;
realtile &= 0x07ff; realstart &= 0x07ff;
realtile |= spriteram3[block] * 0x800; realstart |= spriteram3[block] * 0x800;
} }
if (xflip) sx = ((xpos + xzoom * (xsize - x) / 2 + 16) & 0x1ff) - 16; if (curr_sprite.flipx) sx = ((curr_sprite.ox + curr_sprite.zoomx * (curr_sprite.xsize - x) / 2 + 16) & 0x1ff) - 16;
else sx = ((xpos + xzoom * x / 2 + 16) & 0x1ff) - 16; else sx = ((curr_sprite.ox + curr_sprite.zoomx * x / 2 + 16) & 0x1ff) - 16;
drawgfxzoom_transpen(bitmap,cliprect,gfx, drawgfxzoom_transpen(bitmap,cliprect,gfx,
realtile, realstart,
color, curr_sprite.color,
xflip,yflip, curr_sprite.flipx,curr_sprite.flipy,
sx,sy, sx,sy,
xzoom << 11, yzoom << 11,15); curr_sprite.zoomx << 11, curr_sprite.zoomy << 11,15);
tile++; curr_sprite.map++;
} }
} }
@ -349,61 +316,54 @@ void vsystem_spr_device::draw_sprites_crshrace(UINT16* spriteram, int spriteram_
while (offs < 0x0400 && (spriteram[offs] & 0x4000) == 0) while (offs < 0x0400 && (spriteram[offs] & 0x4000) == 0)
{ {
int attr_start; int attr_start;
int map_start; int x, y;
int ox, oy, x, y, xsize, ysize, zoomx, zoomy, flipx, flipy, color;
/* table hand made by looking at the ship explosion in aerofgt attract mode */ /* table hand made by looking at the ship explosion in aerofgt attract mode */
/* it's almost a logarithmic scale but not exactly */ /* 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 }; static const int zoomtable[16] = { 0,7,14,20,25,30,34,38,42,46,49,52,54,57,59,61 };
attr_start = 4 * (spriteram[offs++] & 0x03ff); attr_start = 4 * (spriteram[offs++] & 0x03ff);
ox = spriteram[attr_start + 1] & 0x01ff; get_sprite_attributes(&spriteram[attr_start]);
xsize = (spriteram[attr_start + 1] & 0x0e00) >> 9;
zoomx = (spriteram[attr_start + 1] & 0xf000) >> 12;
oy = spriteram[attr_start + 0] & 0x01ff;
ysize = (spriteram[attr_start + 0] & 0x0e00) >> 9;
zoomy = (spriteram[attr_start + 0] & 0xf000) >> 12;
flipx = spriteram[attr_start + 2] & 0x4000;
flipy = spriteram[attr_start + 2] & 0x8000;
color = (spriteram[attr_start + 2] & 0x1f00) >> 8;
map_start = spriteram[attr_start + 3] & 0x7fff;
zoomx = 16 - zoomtable[zoomx] / 8; curr_sprite.color &= 0x1f;
zoomy = 16 - zoomtable[zoomy] / 8; curr_sprite.map &= 0x7fff;
if (spriteram[attr_start + 2] & 0x20ff) color = machine.rand(); curr_sprite.zoomx = 16 - zoomtable[curr_sprite.zoomx] / 8;
curr_sprite.zoomy = 16 - zoomtable[curr_sprite.zoomy] / 8;
for (y = 0; y <= ysize; y++) if (spriteram[attr_start + 2] & 0x20ff) curr_sprite.color = machine.rand();
for (y = 0; y <= curr_sprite.ysize; y++)
{ {
int sx,sy; int sx,sy;
if (flipy) sy = ((oy + zoomy * (ysize - y) + 16) & 0x1ff) - 16; if (curr_sprite.flipy) sy = ((curr_sprite.oy + curr_sprite.zoomy * (curr_sprite.ysize - y) + 16) & 0x1ff) - 16;
else sy = ((oy + zoomy * y + 16) & 0x1ff) - 16; else sy = ((curr_sprite.oy + curr_sprite.zoomy * y + 16) & 0x1ff) - 16;
for (x = 0; x <= xsize; x++) for (x = 0; x <= curr_sprite.xsize; x++)
{ {
int code; int code;
if (flipx) sx = ((ox + zoomx * (xsize - x) + 16) & 0x1ff) - 16; if (curr_sprite.flipx) sx = ((curr_sprite.ox + curr_sprite.zoomx * (curr_sprite.xsize - x) + 16) & 0x1ff) - 16;
else sx = ((ox + zoomx * x + 16) & 0x1ff) - 16; else sx = ((curr_sprite.ox + curr_sprite.zoomx * x + 16) & 0x1ff) - 16;
code = spriteram2[map_start & 0x7fff]; code = spriteram2[curr_sprite.map & 0x7fff];
map_start++; curr_sprite.map++;
if (flipscreen) if (flipscreen)
drawgfxzoom_transpen(bitmap,cliprect,machine.gfx[2], drawgfxzoom_transpen(bitmap,cliprect,machine.gfx[2],
code, code,
color, curr_sprite.color,
!flipx,!flipy, !curr_sprite.flipx,!curr_sprite.flipy,
304-sx,208-sy, 304-sx,208-sy,
0x1000 * zoomx,0x1000 * zoomy,15); 0x1000 * curr_sprite.zoomx,0x1000 * curr_sprite.zoomy,15);
else else
drawgfxzoom_transpen(bitmap,cliprect,machine.gfx[2], drawgfxzoom_transpen(bitmap,cliprect,machine.gfx[2],
code, code,
color, curr_sprite.color,
flipx,flipy, curr_sprite.flipx,curr_sprite.flipy,
sx,sy, sx,sy,
0x1000 * zoomx,0x1000 * zoomy,15); 0x1000 * curr_sprite.zoomx,0x1000 * curr_sprite.zoomy,15);
} }
} }
} }
@ -411,69 +371,61 @@ void vsystem_spr_device::draw_sprites_crshrace(UINT16* spriteram, int spriteram_
void vsystem_spr_device::draw_sprites_aerofght( UINT16* spriteram3, int spriteram_bytes, UINT16* spriteram1, UINT16* spriteram2, running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect, int priority ) void vsystem_spr_device::draw_sprites_aerofght( UINT16* spriteram3, int spriteram_bytes, UINT16* spriteram1, UINT16* spriteram2, running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect, int pri )
{ {
int offs; int offs;
priority <<= 12; pri <<= 12;
offs = 0; offs = 0;
while (offs < 0x0400 && (spriteram3[offs] & 0x8000) == 0) while (offs < 0x0400 && (spriteram3[offs] & 0x8000) == 0)
{ {
int attr_start = 4 * (spriteram3[offs] & 0x03ff); int attr_start = 4 * (spriteram3[offs] & 0x03ff);
/* is the way I handle priority correct? Or should I just check bit 13? */ /* is the way I handle pri correct? Or should I just check bit 13? */
if ((spriteram3[attr_start + 2] & 0x3000) == priority) if ((spriteram3[attr_start + 2] & 0x3000) == pri)
{ {
int map_start; int x, y;
int ox, oy, x, y, xsize, ysize, zoomx, zoomy, flipx, flipy, color;
ox = spriteram3[attr_start + 1] & 0x01ff; get_sprite_attributes(&spriteram3[attr_start]);
xsize = (spriteram3[attr_start + 1] & 0x0e00) >> 9;
zoomx = (spriteram3[attr_start + 1] & 0xf000) >> 12;
oy = spriteram3[attr_start + 0] & 0x01ff;
ysize = (spriteram3[attr_start + 0] & 0x0e00) >> 9;
zoomy = (spriteram3[attr_start + 0] & 0xf000) >> 12;
flipx = spriteram3[attr_start + 2] & 0x4000;
flipy = spriteram3[attr_start + 2] & 0x8000;
color = (spriteram3[attr_start + 2] & 0x0f00) >> 8;
map_start = spriteram3[attr_start + 3] & 0x3fff;
ox += (xsize * zoomx + 2) / 4; curr_sprite.color &=0xf;
oy += (ysize * zoomy + 2) / 4; curr_sprite.map &= 0x3fff;
curr_sprite.ox += (curr_sprite.xsize * curr_sprite.zoomx + 2) / 4;
curr_sprite.oy += (curr_sprite.ysize * curr_sprite.zoomy + 2) / 4;
zoomx = 32 - zoomx; curr_sprite.zoomx = 32 - curr_sprite.zoomx;
zoomy = 32 - zoomy; curr_sprite.zoomy = 32 - curr_sprite.zoomy;
for (y = 0; y <= ysize; y++) for (y = 0; y <= curr_sprite.ysize; y++)
{ {
int sx, sy; int sx, sy;
if (flipy) if (curr_sprite.flipy)
sy = ((oy + zoomy * (ysize - y)/2 + 16) & 0x1ff) - 16; sy = ((curr_sprite.oy + curr_sprite.zoomy * (curr_sprite.ysize - y)/2 + 16) & 0x1ff) - 16;
else else
sy = ((oy + zoomy * y / 2 + 16) & 0x1ff) - 16; sy = ((curr_sprite.oy + curr_sprite.zoomy * y / 2 + 16) & 0x1ff) - 16;
for (x = 0; x <= xsize; x++) for (x = 0; x <= curr_sprite.xsize; x++)
{ {
int code; int code;
if (flipx) if (curr_sprite.flipx)
sx = ((ox + zoomx * (xsize - x) / 2 + 16) & 0x1ff) - 16; sx = ((curr_sprite.ox + curr_sprite.zoomx * (curr_sprite.xsize - x) / 2 + 16) & 0x1ff) - 16;
else else
sx = ((ox + zoomx * x / 2 + 16) & 0x1ff) - 16; sx = ((curr_sprite.ox + curr_sprite.zoomx * x / 2 + 16) & 0x1ff) - 16;
if (map_start < 0x2000) if (curr_sprite.map < 0x2000)
code = spriteram1[map_start & 0x1fff] & 0x1fff; code = spriteram1[curr_sprite.map & 0x1fff] & 0x1fff;
else else
code = spriteram2[map_start & 0x1fff] & 0x1fff; code = spriteram2[curr_sprite.map & 0x1fff] & 0x1fff;
drawgfxzoom_transpen(bitmap,cliprect,machine.gfx[2 + (map_start >= 0x2000 ? 1 : 0)], drawgfxzoom_transpen(bitmap,cliprect,machine.gfx[2 + (curr_sprite.map >= 0x2000 ? 1 : 0)],
code, code,
color, curr_sprite.color,
flipx,flipy, curr_sprite.flipx,curr_sprite.flipy,
sx,sy, sx,sy,
zoomx << 11, zoomy << 11,15); curr_sprite.zoomx << 11, curr_sprite.zoomy << 11,15);
map_start++; curr_sprite.map++;
} }
} }
} }
@ -490,63 +442,56 @@ void vsystem_spr_device::f1gp2_draw_sprites(UINT16* spritelist, UINT16* sprcgram
while (offs < 0x0400 && (spritelist[offs] & 0x4000) == 0) while (offs < 0x0400 && (spritelist[offs] & 0x4000) == 0)
{ {
int attr_start; int attr_start;
int map_start; int x, y;
int ox, oy, x, y, xsize, ysize, zoomx, zoomy, flipx, flipy, color;
attr_start = 4 * (spritelist[offs++] & 0x01ff); attr_start = 4 * (spritelist[offs++] & 0x01ff);
ox = spritelist[attr_start + 1] & 0x01ff; get_sprite_attributes(&spritelist[attr_start]);
xsize = (spritelist[attr_start + 1] & 0x0e00) >> 9;
zoomx = (spritelist[attr_start + 1] & 0xf000) >> 12; curr_sprite.color &= 0x1f;
oy = spritelist[attr_start + 0] & 0x01ff; curr_sprite.map &= 0x7fff;
ysize = (spritelist[attr_start + 0] & 0x0e00) >> 9;
zoomy = (spritelist[attr_start + 0] & 0xf000) >> 12;
flipx = spritelist[attr_start + 2] & 0x4000;
flipy = spritelist[attr_start + 2] & 0x8000;
color = (spritelist[attr_start + 2] & 0x1f00) >> 8;
map_start = spritelist[attr_start + 3] & 0x7fff;
// aerofgt has the following adjustment, but doing it here would break the title screen // aerofgt has the following adjustment, but doing it here would break the title screen
// ox += (xsize*zoomx+2)/4; // curr_sprite.ox += (curr_sprite.xsize*curr_sprite.zoomx+2)/4;
// oy += (ysize*zoomy+2)/4; // curr_sprite.oy += (curr_sprite.ysize*curr_sprite.zoomy+2)/4;
zoomx = 32 - zoomx; curr_sprite.zoomx = 32 - curr_sprite.zoomx;
zoomy = 32 - zoomy; curr_sprite.zoomy = 32 - curr_sprite.zoomy;
if (spritelist[attr_start + 2] & 0x20ff) if (spritelist[attr_start + 2] & 0x20ff)
color = machine.rand(); curr_sprite.color = machine.rand();
for (y = 0; y <= ysize; y++) for (y = 0; y <= curr_sprite.ysize; y++)
{ {
int sx,sy; int sx,sy;
if (flipy) sy = ((oy + zoomy * (ysize - y)/2 + 16) & 0x1ff) - 16; if (curr_sprite.flipy) sy = ((curr_sprite.oy + curr_sprite.zoomy * (curr_sprite.ysize - y)/2 + 16) & 0x1ff) - 16;
else sy = ((oy + zoomy * y / 2 + 16) & 0x1ff) - 16; else sy = ((curr_sprite.oy + curr_sprite.zoomy * y / 2 + 16) & 0x1ff) - 16;
for (x = 0; x <= xsize; x++) for (x = 0; x <= curr_sprite.xsize; x++)
{ {
int code; int code;
if (flipx) sx = ((ox + zoomx * (xsize - x) / 2 + 16) & 0x1ff) - 16; if (curr_sprite.flipx) sx = ((curr_sprite.ox + curr_sprite.zoomx * (curr_sprite.xsize - x) / 2 + 16) & 0x1ff) - 16;
else sx = ((ox + zoomx * x / 2 + 16) & 0x1ff) - 16; else sx = ((curr_sprite.ox + curr_sprite.zoomx * x / 2 + 16) & 0x1ff) - 16;
code = sprcgram[map_start & 0x3fff]; code = sprcgram[curr_sprite.map & 0x3fff];
map_start++; curr_sprite.map++;
if (flipscreen) if (flipscreen)
drawgfxzoom_transpen(bitmap,cliprect,machine.gfx[1], drawgfxzoom_transpen(bitmap,cliprect,machine.gfx[1],
code, code,
color, curr_sprite.color,
!flipx,!flipy, !curr_sprite.flipx,!curr_sprite.flipy,
304-sx,208-sy, 304-sx,208-sy,
zoomx << 11,zoomy << 11,15); curr_sprite.zoomx << 11,curr_sprite.zoomy << 11,15);
else else
drawgfxzoom_transpen(bitmap,cliprect,machine.gfx[1], drawgfxzoom_transpen(bitmap,cliprect,machine.gfx[1],
code, code,
color, curr_sprite.color,
flipx,flipy, curr_sprite.flipx,curr_sprite.flipy,
sx,sy, sx,sy,
zoomx << 11,zoomy << 11,15); curr_sprite.zoomx << 11,curr_sprite.zoomy << 11,15);
} }
} }
} }
@ -566,38 +511,22 @@ void vsystem_spr_device::f1gp2_draw_sprites(UINT16* spritelist, UINT16* sprcgram
- Scaling (x/y) - Scaling (x/y)
- Flipping - Flipping
- Indipendent sorting list - Indipendent sorting list
- 1 bit of priority for the mixer - 1 bit of pri for the mixer
Note that this chip can be connected to a VS9210 which adds a level of indirection for Note that this chip can be connected to a VS9210 which adds a level of indirection for
tile numbers. Basically, the VS9210 indirects the tile number through a table in its attached tile numbers. Basically, the VS9210 indirects the tilet number through a table in its attached
memory, before accessing the ROMs. memory, before accessing the ROMs.
Sorting list format (VideoRAM offset 0) Sorting list format (VideoRAM offset 0)
--------------------------------------- ---------------------------------------
?e-- ---f ssss ssss de-- ---f ssss ssss
e=end of list e=end of list
f=sprite present in this position f=sprite present in this position
s=sprite index s=sprite index
?=used together with 'e' almost always d=disable sprite?
Sprite format (VideoRAM offset 0x400)
-------------------------------------
0: nnnn jjjy yyyy yyyy
1: mmmm iiix xxxx xxxx
2: fFpc cccc ---- ---t
3: tttt tttt tttt tttt
t=tile, x=posx, y=posy, i=blockx, j=blocky
c=color, m=zoomx, n=zoomy, p=priority
The zoom (scaling) is probably non-linear, it would require a hand-made table unless we find the correct
formula. I'd probably try 1/x. I'm almost sure that it scales between full size (value=0) and half size
(value=0xF) but I couldn't get much more than that from a soccer game.
TODO: TODO:
@ -612,81 +541,71 @@ Abstracts the VS9210
void vsystem_spr_device::CG10103_draw_sprite(running_machine &machine, bitmap_ind16& screen, const rectangle &cliprect, UINT16* spr, int drawpri) void vsystem_spr_device::CG10103_draw_sprite(running_machine &machine, bitmap_ind16& screen, const rectangle &cliprect, UINT16* spr, int drawpri)
{ {
int ypos = spr[0] & 0x1FF; get_sprite_attributes(&spr[0]);
int xpos = (spr[1] & 0x1FF); curr_sprite.color &=0x1f;
UINT32 tile = (spr[3] & 0xFFFF) | ((spr[2] & 1) << 16); curr_sprite.pri >>= 1;
int ynum = (spr[0] >> 9) & 0x7;
int xnum = (spr[1] >> 9) & 0x7;
int color = (spr[2] >> 8) & 0x1F;
int flipx = (spr[2] >> 14) & 1;
int flipy = (spr[2] >> 15) & 1;
int yzoom = (spr[0] >> 12) & 0xF;
int xzoom = (spr[1] >> 12) & 0xF;
int pri = (spr[2] >> 13) & 1;
int x, y; int x, y;
int xstep, ystep; int xstep, ystep;
int xfact, yfact; int xfact, yfact;
// Check if we want to draw this sprite now // Check if we want to draw this sprite now
if (pri != drawpri) if (curr_sprite.pri != drawpri)
return; return;
// Convert in fixed point to handle the scaling // Convert in fixed point to handle the scaling
xpos <<= 16; curr_sprite.ox <<= 16;
ypos <<= 16; curr_sprite.oy <<= 16;
xnum++; curr_sprite.xsize++;
ynum++; curr_sprite.ysize++;
xstep = ystep = 16; xstep = ystep = 16;
// Linear scale, surely wrong // Linear scale, surely wrong
xfact = 0x10000 - ((0x8000 * xzoom) / 15); xfact = 0x10000 - ((0x8000 * curr_sprite.zoomx) / 15);
yfact = 0x10000 - ((0x8000 * yzoom) / 15); yfact = 0x10000 - ((0x8000 * curr_sprite.zoomy) / 15);
xstep *= xfact; xstep *= xfact;
ystep *= yfact; ystep *= yfact;
// Handle flipping // Handle flipping
if (flipy) if (curr_sprite.flipy)
{ {
ypos += (ynum-1) * ystep; curr_sprite.oy += (curr_sprite.ysize-1) * ystep;
ystep = -ystep; ystep = -ystep;
} }
if (flipx) if (curr_sprite.flipx)
{ {
xpos += (xnum-1) * xstep; curr_sprite.ox += (curr_sprite.xsize-1) * xstep;
xstep = -xstep; xstep = -xstep;
} }
// @@@ Add here optional connection to the VS9210 for extra level of tile number indirection
#if 0
if (m_CG10103_cur_chip->connected_vs9210)
{
// ...
}
#endif
// Draw the block // Draw the block
for (y=0;y<ynum;y++) for (y=0;y<curr_sprite.ysize;y++)
{ {
int xp = xpos; int xp = curr_sprite.ox;
for (x=0;x<xnum;x++) for (x=0;x<curr_sprite.xsize;x++)
{ {
// Hack to handle horizontal wrapping // Hack to handle horizontal wrapping
drawgfxzoom_transpen(screen, cliprect, machine.gfx[m_CG10103_cur_chip->gfx_region], tile, color+m_CG10103_cur_chip->pal_base, flipx, flipy, xp>>16, ypos>>16, xfact, yfact, m_CG10103_cur_chip->transpen); drawgfxzoom_transpen(screen, cliprect, machine.gfx[m_CG10103_cur_chip->gfx_region], curr_sprite.map, curr_sprite.color+m_CG10103_cur_chip->pal_base, curr_sprite.flipx, curr_sprite.flipy, xp>>16, curr_sprite.oy>>16, xfact, yfact, m_CG10103_cur_chip->transpen);
drawgfxzoom_transpen(screen, cliprect, machine.gfx[m_CG10103_cur_chip->gfx_region], tile, color+m_CG10103_cur_chip->pal_base, flipx, flipy, (xp>>16) - 0x200, ypos>>16, xfact, yfact, m_CG10103_cur_chip->transpen); drawgfxzoom_transpen(screen, cliprect, machine.gfx[m_CG10103_cur_chip->gfx_region], curr_sprite.map, curr_sprite.color+m_CG10103_cur_chip->pal_base, curr_sprite.flipx, curr_sprite.flipy, (xp>>16) - 0x200, curr_sprite.oy>>16, xfact, yfact, m_CG10103_cur_chip->transpen);
drawgfxzoom_transpen(screen, cliprect, machine.gfx[m_CG10103_cur_chip->gfx_region], curr_sprite.map, curr_sprite.color+m_CG10103_cur_chip->pal_base, curr_sprite.flipx, curr_sprite.flipy, xp>>16, (curr_sprite.oy>>16)-0x200, xfact, yfact, m_CG10103_cur_chip->transpen);
drawgfxzoom_transpen(screen, cliprect, machine.gfx[m_CG10103_cur_chip->gfx_region], curr_sprite.map, curr_sprite.color+m_CG10103_cur_chip->pal_base, curr_sprite.flipx, curr_sprite.flipy, (xp>>16) - 0x200, (curr_sprite.oy>>16)-0x200, xfact, yfact, m_CG10103_cur_chip->transpen);
xp += xstep; xp += xstep;
tile++; curr_sprite.map++;
} }
ypos += ystep; curr_sprite.oy += ystep;
} }
} }
void vsystem_spr_device::CG10103_draw(running_machine &machine, int numchip, bitmap_ind16& screen, const rectangle &cliprect, int priority) void vsystem_spr_device::CG10103_draw(running_machine &machine, int numchip, bitmap_ind16& screen, const rectangle &cliprect, int pri)
{ {
UINT16* splist; UINT16* splist;
int i; int i;
@ -704,14 +623,13 @@ void vsystem_spr_device::CG10103_draw(running_machine &machine, int numchip, bit
if (cmd & 0x4000) if (cmd & 0x4000)
break; break;
// Normal sprite here if (!(cmd & 0x8000))
if (cmd & 0x100)
{ {
// Extract sprite index // Extract sprite index
int num = cmd & 0xFF; int num = cmd & 0x3FF;
// Draw the sprite // Draw the sprite
CG10103_draw_sprite(machine, screen, cliprect, m_CG10103_cur_chip->vram + 0x400 + num*4, priority); CG10103_draw_sprite(machine, screen, cliprect, m_CG10103_cur_chip->vram + num*4, pri);
} }
} }
} }

18
src/mame/video/vsystem_spr.h
View File

@ -21,8 +21,26 @@ public:
tCG10103 m_CG10103; tCG10103 m_CG10103;
tCG10103* m_CG10103_cur_chip; tCG10103* m_CG10103_cur_chip;
struct vsystem_sprite_attributes
{
int ox;
int xsize;
int zoomx;
int oy;
int ysize;
int zoomy;
int flipx;
int flipy;
int color;
int pri;
UINT32 map;
} curr_sprite;
void get_sprite_attributes(UINT16* ram);
void draw_sprites_inufuku( UINT16* spriteram, int spriteram_bytes, UINT16* spriteram2, running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect ); void draw_sprites_inufuku( UINT16* spriteram, int spriteram_bytes, UINT16* spriteram2, running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect );
void draw_sprites_suprslam( UINT16* spriteram, int spriteram_bytes, UINT16* spriteram2, running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect ); void draw_sprites_suprslam( UINT16* spriteram, int spriteram_bytes, UINT16* spriteram2, running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect );
void draw_sprite_taotaido( UINT16* spriteram, int spriteram_bytes, UINT16* spriteram2, UINT16* spriteram3, running_machine &machine, UINT16 spriteno, bitmap_ind16 &bitmap, const rectangle &cliprect );
void draw_sprites_taotaido( UINT16* spriteram, int spriteram_bytes, UINT16* spriteram2, UINT16* spriteram3, running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect ); void draw_sprites_taotaido( UINT16* spriteram, int spriteram_bytes, UINT16* spriteram2, UINT16* spriteram3, running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect );
void draw_sprites_crshrace( UINT16* spriteram, int spriteram_bytes, UINT16* spriteram2, running_machine &machine, bitmap_ind16 &bitmap,const rectangle &cliprect, int flipscreen); void draw_sprites_crshrace( UINT16* spriteram, int spriteram_bytes, UINT16* spriteram2, running_machine &machine, bitmap_ind16 &bitmap,const rectangle &cliprect, int flipscreen);
void draw_sprites_aerofght( UINT16* spriteram3, int spriteram_bytes, UINT16* spriteram1, UINT16* spriteram2, running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect, int priority ); void draw_sprites_aerofght( UINT16* spriteram3, int spriteram_bytes, UINT16* spriteram1, UINT16* spriteram2, running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect, int priority );

481
src/mame/video/vsystem_spr2.c
View File

@ -40,6 +40,32 @@ void vsystem_spr2_device::device_reset()
} }
int vsystem_spr2_device::get_sprite_attributes(UINT16* ram)
{
// sprite is disabled
if (!(ram[2] & 0x0080))
return 0;
curr_sprite.oy = (ram[0] & 0x01ff);
curr_sprite.zoomy = (ram[0] & 0xf000) >> 12;
curr_sprite.ox = (ram[1] & 0x01ff);
curr_sprite.zoomx = (ram[1] & 0xf000) >> 12;
curr_sprite.xsize = (ram[2] & 0x0700) >> 8;
curr_sprite.flipx = (ram[2] & 0x0800);
curr_sprite.ysize = (ram[2] & 0x7000) >> 12;
curr_sprite.flipy = (ram[2] & 0x8000);
curr_sprite.color = (ram[2] & 0x000f);
curr_sprite.pri = (ram[2] & 0x0010);
curr_sprite.map = (ram[3]);
return 1;
}
template<class _BitmapClass> template<class _BitmapClass>
@ -51,78 +77,69 @@ void vsystem_spr2_device::turbofrc_draw_sprites_common( UINT16* spriteram3, int
for (attr_start = base + 0x0200 - 8; attr_start >= first + base; attr_start -= 4) for (attr_start = base + 0x0200 - 8; attr_start >= first + base; attr_start -= 4)
{ {
int map_start; int x, y;
int ox, oy, x, y, xsize, ysize, zoomx, zoomy, flipx, flipy, color, pri;
// some other drivers still use this wrong table, they have to be upgraded // some other drivers still use this wrong table, they have to be upgraded
// int zoomtable[16] = { 0,7,14,20,25,30,34,38,42,46,49,52,54,57,59,61 }; // int zoomtable[16] = { 0,7,14,20,25,30,34,38,42,46,49,52,54,57,59,61 };
if (!(spriteram3[attr_start + 2] & 0x0080))
if (!get_sprite_attributes(&spriteram3[attr_start]))
continue; continue;
pri = spriteram3[attr_start + 2] & 0x0010;
if ( chip_disabled_pri & !pri) if ( chip_disabled_pri & !curr_sprite.pri)
continue; continue;
if ((!chip_disabled_pri) & (pri >> 4)) if ((!chip_disabled_pri) & (curr_sprite.pri >> 4))
continue; continue;
ox = spriteram3[attr_start + 1] & 0x01ff;
xsize = (spriteram3[attr_start + 2] & 0x0700) >> 8;
zoomx = (spriteram3[attr_start + 1] & 0xf000) >> 12;
oy = spriteram3[attr_start + 0] & 0x01ff;
ysize = (spriteram3[attr_start + 2] & 0x7000) >> 12;
zoomy = (spriteram3[attr_start + 0] & 0xf000) >> 12;
flipx = spriteram3[attr_start + 2] & 0x0800;
flipy = spriteram3[attr_start + 2] & 0x8000;
color = (spriteram3[attr_start + 2] & 0x000f) + 16 * spritepalettebank;
map_start = spriteram3[attr_start + 3];
curr_sprite.color += 16 * spritepalettebank;
// aerofgt has this adjustment, but doing it here would break turbo force title screen // aerofgt has this adjustment, but doing it here would break turbo force title screen
// ox += (xsize*zoomx+2)/4; // curr_sprite.ox += (curr_sprite.xsize*curr_sprite.zoomx+2)/4;
// oy += (ysize*zoomy+2)/4; // curr_sprite.oy += (curr_sprite.ysize*curr_sprite.zoomy+2)/4;
zoomx = 32 - zoomx; curr_sprite.zoomx = 32 - curr_sprite.zoomx;
zoomy = 32 - zoomy; curr_sprite.zoomy = 32 - curr_sprite.zoomy;
for (y = 0; y <= ysize; y++) for (y = 0; y <= curr_sprite.ysize; y++)
{ {
int sx, sy; int sx, sy;
if (flipy) if (curr_sprite.flipy)
sy = ((oy + zoomy * (ysize - y)/2 + 16) & 0x1ff) - 16; sy = ((curr_sprite.oy + curr_sprite.zoomy * (curr_sprite.ysize - y)/2 + 16) & 0x1ff) - 16;
else else
sy = ((oy + zoomy * y / 2 + 16) & 0x1ff) - 16; sy = ((curr_sprite.oy + curr_sprite.zoomy * y / 2 + 16) & 0x1ff) - 16;
for (x = 0; x <= xsize; x++) for (x = 0; x <= curr_sprite.xsize; x++)
{ {
int code; int curr;
if (flipx) if (curr_sprite.flipx)
sx = ((ox + zoomx * (xsize - x) / 2 + 16) & 0x1ff) - 16; sx = ((curr_sprite.ox + curr_sprite.zoomx * (curr_sprite.xsize - x) / 2 + 16) & 0x1ff) - 16;
else else
sx = ((ox + zoomx * x / 2 + 16) & 0x1ff) - 16; sx = ((curr_sprite.ox + curr_sprite.zoomx * x / 2 + 16) & 0x1ff) - 16;
if (chip == 0) if (chip == 0)
code = spriteram1[map_start % (spriteram1_bytes/2)]; curr = spriteram1[curr_sprite.map % (spriteram1_bytes/2)];
else else
code = spriteram2[map_start % (spriteram2_bytes/2)]; curr = spriteram2[curr_sprite.map % (spriteram2_bytes/2)];
pdrawgfxzoom_transpen(bitmap,cliprect,machine.gfx[sprite_gfx + chip], pdrawgfxzoom_transpen(bitmap,cliprect,machine.gfx[sprite_gfx + chip],
code, curr,
color, curr_sprite.color,
flipx,flipy, curr_sprite.flipx,curr_sprite.flipy,
sx,sy, sx,sy,
zoomx << 11, zoomy << 11, curr_sprite.zoomx << 11, curr_sprite.zoomy << 11,
machine.priority_bitmap,pri ? 0 : 2,15); machine.priority_bitmap,curr_sprite.pri ? 0 : 2,15);
map_start++; curr_sprite.map++;
} }
if (xsize == 2) map_start += 1; if (curr_sprite.xsize == 2) curr_sprite.map += 1;
if (xsize == 4) map_start += 3; if (curr_sprite.xsize == 4) curr_sprite.map += 3;
if (xsize == 5) map_start += 2; if (curr_sprite.xsize == 5) curr_sprite.map += 2;
if (xsize == 6) map_start += 1; if (curr_sprite.xsize == 6) curr_sprite.map += 1;
} }
} }
} }
@ -143,77 +160,67 @@ void vsystem_spr2_device::spinlbrk_draw_sprites_common( UINT16* spriteram3, int
for (attr_start = base + 0x0200-8; attr_start >= first + base; attr_start -= 4) for (attr_start = base + 0x0200-8; attr_start >= first + base; attr_start -= 4)
{ {
int map_start; int x, y;
int ox, oy, x, y, xsize, ysize, zoomx, zoomy, flipx, flipy, color, pri;
// some other drivers still use this wrong table, they have to be upgraded // some other drivers still use this wrong table, they have to be upgraded
// int zoomtable[16] = { 0,7,14,20,25,30,34,38,42,46,49,52,54,57,59,61 }; // int zoomtable[16] = { 0,7,14,20,25,30,34,38,42,46,49,52,54,57,59,61 };
if (!(spriteram3[attr_start + 2] & 0x0080))
if (!get_sprite_attributes(&spriteram3[attr_start]))
continue; continue;
pri = spriteram3[attr_start + 2] & 0x0010;
if ( chip_disabled_pri & !pri) if ( chip_disabled_pri & !curr_sprite.pri)
continue; continue;
if ((!chip_disabled_pri) & (pri >> 4)) if ((!chip_disabled_pri) & (curr_sprite.pri >> 4))
continue; continue;
ox = spriteram3[attr_start + 1] & 0x01ff;
xsize = (spriteram3[attr_start + 2] & 0x0700) >> 8;
zoomx = (spriteram3[attr_start + 1] & 0xf000) >> 12;
oy = spriteram3[attr_start + 0] & 0x01ff;
ysize = (spriteram3[attr_start + 2] & 0x7000) >> 12;
zoomy = (spriteram3[attr_start + 0] & 0xf000) >> 12;
flipx = spriteram3[attr_start + 2] & 0x0800;
flipy = spriteram3[attr_start + 2] & 0x8000;
color = (spriteram3[attr_start + 2] & 0x000f) + 16 * spritepalettebank;
map_start = spriteram3[attr_start + 3]; curr_sprite.color += 16 * spritepalettebank;
// aerofgt has this adjustment, but doing it here would break turbo force title screen // aerofgt has this adjustment, but doing it here would break turbo force title screen
// ox += (xsize*zoomx+2)/4; // curr_sprite.ox += (curr_sprite.xsize*curr_sprite.zoomx+2)/4;
// oy += (ysize*zoomy+2)/4; // curr_sprite.oy += (curr_sprite.ysize*curr_sprite.zoomy+2)/4;
zoomx = 32 - zoomx; curr_sprite.zoomx = 32 - curr_sprite.zoomx;
zoomy = 32 - zoomy; curr_sprite.zoomy = 32 - curr_sprite.zoomy;
for (y = 0; y <= ysize; y++) for (y = 0; y <= curr_sprite.ysize; y++)
{ {
int sx, sy; int sx, sy;
if (flipy) if (curr_sprite.flipy)
sy = ((oy + zoomy * (ysize - y)/2 + 16) & 0x1ff) - 16; sy = ((curr_sprite.oy + curr_sprite.zoomy * (curr_sprite.ysize - y)/2 + 16) & 0x1ff) - 16;
else else
sy = ((oy + zoomy * y / 2 + 16) & 0x1ff) - 16; sy = ((curr_sprite.oy + curr_sprite.zoomy * y / 2 + 16) & 0x1ff) - 16;
for (x = 0; x <= xsize; x++) for (x = 0; x <= curr_sprite.xsize; x++)
{ {
int code; int curr;
if (flipx) if (curr_sprite.flipx)
sx = ((ox + zoomx * (xsize - x) / 2 + 16) & 0x1ff) - 16; sx = ((curr_sprite.ox + curr_sprite.zoomx * (curr_sprite.xsize - x) / 2 + 16) & 0x1ff) - 16;
else else
sx = ((ox + zoomx * x / 2 + 16) & 0x1ff) - 16; sx = ((curr_sprite.ox + curr_sprite.zoomx * x / 2 + 16) & 0x1ff) - 16;
if (chip == 0) if (chip == 0)
code = spriteram1[map_start % (spriteram1_bytes/2)]; curr = spriteram1[curr_sprite.map % (spriteram1_bytes/2)];
else else
code = spriteram2[map_start % (spriteram2_bytes/2)]; curr = spriteram2[curr_sprite.map % (spriteram2_bytes/2)];
pdrawgfxzoom_transpen(bitmap,cliprect,machine.gfx[sprite_gfx + chip], pdrawgfxzoom_transpen(bitmap,cliprect,machine.gfx[sprite_gfx + chip],
code, curr,
color, curr_sprite.color,
flipx,flipy, curr_sprite.flipx,curr_sprite.flipy,
sx,sy, sx,sy,
zoomx << 11, zoomy << 11, curr_sprite.zoomx << 11, curr_sprite.zoomy << 11,
machine.priority_bitmap,pri ? 2 : 0,15); machine.priority_bitmap,curr_sprite.pri ? 2 : 0,15);
map_start++; curr_sprite.map++;
} }
if (xsize == 2) map_start += 1; if (curr_sprite.xsize == 2) curr_sprite.map += 1;
if (xsize == 4) map_start += 3; if (curr_sprite.xsize == 4) curr_sprite.map += 3;
if (xsize == 5) map_start += 2; if (curr_sprite.xsize == 5) curr_sprite.map += 2;
if (xsize == 6) map_start += 1; if (curr_sprite.xsize == 6) curr_sprite.map += 1;
} }
} }
} }
@ -234,107 +241,101 @@ void vsystem_spr2_device::welltris_draw_sprites( UINT16* spriteram, int spritepa
const rectangle &visarea = machine.primary_screen->visible_area(); const rectangle &visarea = machine.primary_screen->visible_area();
/* draw the sprites */ /* draw the sprites */
for (offs = 0; offs < 0x200 - 4; offs += 4) { for (offs = 0; offs < 0x200 - 4; offs += 4)
int data0 = spriteram[offs + 0]; {
int data1 = spriteram[offs + 1]; if (!get_sprite_attributes(&spriteram[offs]))
int data2 = spriteram[offs + 2]; continue;
int data3 = spriteram[offs + 3];
int code = data3 & 0x1fff; curr_sprite.map&=0x1fff;
int color = (data2 & 0x0f) + (0x10 * spritepalettebank); curr_sprite.ysize++;
int y = (data0 & 0x1ff) + 1; curr_sprite.xsize++;
int x = (data1 & 0x1ff) + 6; curr_sprite.color += (0x10 * spritepalettebank);
int yzoom = (data0 >> 12) & 15;
int xzoom = (data1 >> 12) & 15; int zoomed = (curr_sprite.zoomx | curr_sprite.zoomy);
int zoomed = (xzoom | yzoom);
int ytiles = ((data2 >> 12) & 7) + 1;
int xtiles = ((data2 >> 8) & 7) + 1;
int yflip = (data2 >> 15) & 1;
int xflip = (data2 >> 11) & 1;
int xt, yt; int xt, yt;
if (!(spriteram[offs + 2] & 0x0080)) continue;
/* compute the zoom factor -- stolen from aerofgt.c */ /* compute the zoom factor -- stolen from aerofgt.c */
xzoom = 16 - zoomtable[xzoom] / 8; curr_sprite.zoomx = 16 - zoomtable[curr_sprite.zoomx] / 8;
yzoom = 16 - zoomtable[yzoom] / 8; curr_sprite.zoomy = 16 - zoomtable[curr_sprite.zoomy] / 8;
/* wrap around */ /* wrap around */
if (x > visarea.max_x) x -= 0x200; if (curr_sprite.ox > visarea.max_x) curr_sprite.ox -= 0x200;
if (y > visarea.max_y) y -= 0x200; if (curr_sprite.oy > visarea.max_y) curr_sprite.oy -= 0x200;
/* normal case */ /* normal case */
if (!xflip && !yflip) { if (!curr_sprite.flipx && !curr_sprite.flipy) {
for (yt = 0; yt < ytiles; yt++) { for (yt = 0; yt < curr_sprite.ysize; yt++) {
for (xt = 0; xt < xtiles; xt++, code++) { for (xt = 0; xt < curr_sprite.xsize; xt++, curr_sprite.map++) {
if (!zoomed) if (!zoomed)
drawgfx_transpen(bitmap, cliprect, machine.gfx[1], code, color, 0, 0, drawgfx_transpen(bitmap, cliprect, machine.gfx[1], curr_sprite.map, curr_sprite.color, 0, 0,
x + xt * 16, y + yt * 16, 15); curr_sprite.ox + xt * 16, curr_sprite.oy + yt * 16, 15);
else else
drawgfxzoom_transpen(bitmap, cliprect, machine.gfx[1], code, color, 0, 0, drawgfxzoom_transpen(bitmap, cliprect, machine.gfx[1], curr_sprite.map, curr_sprite.color, 0, 0,
x + xt * xzoom, y + yt * yzoom, curr_sprite.ox + xt * curr_sprite.zoomx, curr_sprite.oy + yt * curr_sprite.zoomy,
0x1000 * xzoom, 0x1000 * yzoom, 15); 0x1000 * curr_sprite.zoomx, 0x1000 * curr_sprite.zoomy, 15);
} }
if (xtiles == 3) code += 1; if (curr_sprite.xsize == 3) curr_sprite.map += 1;
if (xtiles == 5) code += 3; if (curr_sprite.xsize == 5) curr_sprite.map += 3;
if (xtiles == 6) code += 2; if (curr_sprite.xsize == 6) curr_sprite.map += 2;
if (xtiles == 7) code += 1; if (curr_sprite.xsize == 7) curr_sprite.map += 1;
} }
} }
/* xflipped case */ /* curr_sprite.flipxped case */
else if (xflip && !yflip) { else if (curr_sprite.flipx && !curr_sprite.flipy) {
for (yt = 0; yt < ytiles; yt++) { for (yt = 0; yt < curr_sprite.ysize; yt++) {
for (xt = 0; xt < xtiles; xt++, code++) { for (xt = 0; xt < curr_sprite.xsize; xt++, curr_sprite.map++) {
if (!zoomed) if (!zoomed)
drawgfx_transpen(bitmap, cliprect, machine.gfx[1], code, color, 1, 0, drawgfx_transpen(bitmap, cliprect, machine.gfx[1], curr_sprite.map, curr_sprite.color, 1, 0,
x + (xtiles - 1 - xt) * 16, y + yt * 16, 15); curr_sprite.ox + (curr_sprite.xsize - 1 - xt) * 16, curr_sprite.oy + yt * 16, 15);
else else
drawgfxzoom_transpen(bitmap, cliprect, machine.gfx[1], code, color, 1, 0, drawgfxzoom_transpen(bitmap, cliprect, machine.gfx[1], curr_sprite.map, curr_sprite.color, 1, 0,
x + (xtiles - 1 - xt) * xzoom, y + yt * yzoom, curr_sprite.ox + (curr_sprite.xsize - 1 - xt) * curr_sprite.zoomx, curr_sprite.oy + yt * curr_sprite.zoomy,
0x1000 * xzoom, 0x1000 * yzoom, 15); 0x1000 * curr_sprite.zoomx, 0x1000 * curr_sprite.zoomy, 15);
} }
if (xtiles == 3) code += 1; if (curr_sprite.xsize == 3) curr_sprite.map += 1;
if (xtiles == 5) code += 3; if (curr_sprite.xsize == 5) curr_sprite.map += 3;
if (xtiles == 6) code += 2; if (curr_sprite.xsize == 6) curr_sprite.map += 2;
if (xtiles == 7) code += 1; if (curr_sprite.xsize == 7) curr_sprite.map += 1;
} }
} }
/* yflipped case */ /* curr_sprite.flipyped case */
else if (!xflip && yflip) { else if (!curr_sprite.flipx && curr_sprite.flipy) {
for (yt = 0; yt < ytiles; yt++) { for (yt = 0; yt < curr_sprite.ysize; yt++) {
for (xt = 0; xt < xtiles; xt++, code++) { for (xt = 0; xt < curr_sprite.xsize; xt++, curr_sprite.map++) {
if (!zoomed) if (!zoomed)
drawgfx_transpen(bitmap, cliprect, machine.gfx[1], code, color, 0, 1, drawgfx_transpen(bitmap, cliprect, machine.gfx[1], curr_sprite.map, curr_sprite.color, 0, 1,
x + xt * 16, y + (ytiles - 1 - yt) * 16, 15); curr_sprite.ox + xt * 16, curr_sprite.oy + (curr_sprite.ysize - 1 - yt) * 16, 15);
else else
drawgfxzoom_transpen(bitmap, cliprect, machine.gfx[1], code, color, 0, 1, drawgfxzoom_transpen(bitmap, cliprect, machine.gfx[1], curr_sprite.map, curr_sprite.color, 0, 1,
x + xt * xzoom, y + (ytiles - 1 - yt) * yzoom, curr_sprite.ox + xt * curr_sprite.zoomx, curr_sprite.oy + (curr_sprite.ysize - 1 - yt) * curr_sprite.zoomy,
0x1000 * xzoom, 0x1000 * yzoom, 15); 0x1000 * curr_sprite.zoomx, 0x1000 * curr_sprite.zoomy, 15);
} }
if (xtiles == 3) code += 1; if (curr_sprite.xsize == 3) curr_sprite.map += 1;
if (xtiles == 5) code += 3; if (curr_sprite.xsize == 5) curr_sprite.map += 3;
if (xtiles == 6) code += 2; if (curr_sprite.xsize == 6) curr_sprite.map += 2;
if (xtiles == 7) code += 1; if (curr_sprite.xsize == 7) curr_sprite.map += 1;
} }
} }
/* x & yflipped case */ /* x & curr_sprite.flipyped case */
else { else {
for (yt = 0; yt < ytiles; yt++) { for (yt = 0; yt < curr_sprite.ysize; yt++) {
for (xt = 0; xt < xtiles; xt++, code++) { for (xt = 0; xt < curr_sprite.xsize; xt++, curr_sprite.map++) {
if (!zoomed) if (!zoomed)
drawgfx_transpen(bitmap, cliprect, machine.gfx[1], code, color, 1, 1, drawgfx_transpen(bitmap, cliprect, machine.gfx[1], curr_sprite.map, curr_sprite.color, 1, 1,
x + (xtiles - 1 - xt) * 16, y + (ytiles - 1 - yt) * 16, 15); curr_sprite.ox + (curr_sprite.xsize - 1 - xt) * 16, curr_sprite.oy + (curr_sprite.ysize - 1 - yt) * 16, 15);
else else
drawgfxzoom_transpen(bitmap, cliprect, machine.gfx[1], code, color, 1, 1, drawgfxzoom_transpen(bitmap, cliprect, machine.gfx[1], curr_sprite.map, curr_sprite.color, 1, 1,
x + (xtiles - 1 - xt) * xzoom, y + (ytiles - 1 - yt) * yzoom, curr_sprite.ox + (curr_sprite.xsize - 1 - xt) * curr_sprite.zoomx, curr_sprite.oy + (curr_sprite.ysize - 1 - yt) * curr_sprite.zoomy,
0x1000 * xzoom, 0x1000 * yzoom, 15); 0x1000 * curr_sprite.zoomx, 0x1000 * curr_sprite.zoomy, 15);
} }
if (xtiles == 3) code += 1; if (curr_sprite.xsize == 3) curr_sprite.map += 1;
if (xtiles == 5) code += 3; if (curr_sprite.xsize == 5) curr_sprite.map += 3;
if (xtiles == 6) code += 2; if (curr_sprite.xsize == 6) curr_sprite.map += 2;
if (xtiles == 7) code += 1; if (curr_sprite.xsize == 7) curr_sprite.map += 1;
} }
} }
} }
@ -351,64 +352,53 @@ void vsystem_spr2_device::f1gp_draw_sprites( UINT16* spr1vram, UINT16* spr2vram,
for (attr_start = 0x0200 - 8; attr_start >= first; attr_start -= 4) for (attr_start = 0x0200 - 8; attr_start >= first; attr_start -= 4)
{ {
int map_start; int x, y;
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 */ /* table hand made by looking at the ship explosion in attract mode */
/* it's almost a logarithmic scale but not exactly */ /* 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 }; 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; if (!get_sprite_attributes(&spram[attr_start]))
xsize = (spram[attr_start + 2] & 0x0700) >> 8; continue;
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 = spram[attr_start + 2] & 0x0010;
map_start = spram[attr_start + 3];
zoomx = 16 - zoomtable[zoomx] / 8; curr_sprite.zoomx = 16 - zoomtable[curr_sprite.zoomx] / 8;
zoomy = 16 - zoomtable[zoomy] / 8; curr_sprite.zoomy = 16 - zoomtable[curr_sprite.zoomy] / 8;
for (y = 0; y <= ysize; y++) for (y = 0; y <= curr_sprite.ysize; y++)
{ {
int sx, sy; int sx, sy;
if (flipy) sy = ((oy + zoomy * (ysize - y) + 16) & 0x1ff) - 16; if (curr_sprite.flipy) sy = ((curr_sprite.oy + curr_sprite.zoomy * (curr_sprite.ysize - y) + 16) & 0x1ff) - 16;
else sy = ((oy + zoomy * y + 16) & 0x1ff) - 16; else sy = ((curr_sprite.oy + curr_sprite.zoomy * y + 16) & 0x1ff) - 16;
for (x = 0; x <= xsize; x++) for (x = 0; x <= curr_sprite.xsize; x++)
{ {
int code; int curr;
if (flipx) sx = ((ox + zoomx * (xsize - x) + 16) & 0x1ff) - 16; if (curr_sprite.flipx) sx = ((curr_sprite.ox + curr_sprite.zoomx * (curr_sprite.xsize - x) + 16) & 0x1ff) - 16;
else sx = ((ox + zoomx * x + 16) & 0x1ff) - 16; else sx = ((curr_sprite.ox + curr_sprite.zoomx * x + 16) & 0x1ff) - 16;
if (chip == 0) if (chip == 0)
code = spr1cgram[map_start % (spr1cgram_bytes / 2)]; curr = spr1cgram[curr_sprite.map % (spr1cgram_bytes / 2)];
else else
code = spr2cgram[map_start % (spr2cgram_bytes / 2)]; curr = spr2cgram[curr_sprite.map % (spr2cgram_bytes / 2)];
pdrawgfxzoom_transpen(bitmap,cliprect,machine.gfx[1 + chip], pdrawgfxzoom_transpen(bitmap,cliprect,machine.gfx[1 + chip],
code, curr,
color, curr_sprite.color,
flipx,flipy, curr_sprite.flipx,curr_sprite.flipy,
sx,sy, sx,sy,
0x1000 * zoomx,0x1000 * zoomy, 0x1000 * curr_sprite.zoomx,0x1000 * curr_sprite.zoomy,
machine.priority_bitmap, machine.priority_bitmap,
// pri ? 0 : 0x2); // pri ? 0 : 0x2);
primask,15); primask,15);
map_start++; curr_sprite.map++;
} }
if (xsize == 2) map_start += 1; if (curr_sprite.xsize == 2) curr_sprite.map += 1;
if (xsize == 4) map_start += 3; if (curr_sprite.xsize == 4) curr_sprite.map += 3;
if (xsize == 5) map_start += 2; if (curr_sprite.xsize == 5) curr_sprite.map += 2;
if (xsize == 6) map_start += 1; if (curr_sprite.xsize == 6) curr_sprite.map += 1;
} }
} }
} }
@ -428,97 +418,96 @@ void vsystem_spr2_device::draw_sprites_pipedrm( UINT8* spriteram, int spriteram_
int priority = (data2 >> 4) & 1; int priority = (data2 >> 4) & 1;
/* turns out the sprites are the same as in aerofgt.c */ /* turns out the sprites are the same as in aerofgt.c */
if ((data2 & 0x80) && priority == draw_priority) if (priority == draw_priority)
{ {
int data0 = spriteram[offs + 0] | (spriteram[offs + 1] << 8); if (!get_sprite_attributes((UINT16*)&spriteram[offs]))
int data1 = spriteram[offs + 2] | (spriteram[offs + 3] << 8); continue;
int data3 = spriteram[offs + 6] | (spriteram[offs + 7] << 8);
int code = data3 & 0xfff; curr_sprite.ysize++;
int color = data2 & 0x0f; curr_sprite.xsize++;
int y = (data0 & 0x1ff) - 6; curr_sprite.oy -= 6;
int x = (data1 & 0x1ff) - 13; curr_sprite.ox -= 13;
int yzoom = (data0 >> 12) & 15;
int xzoom = (data1 >> 12) & 15;
int zoomed = (xzoom | yzoom);
int ytiles = ((data2 >> 12) & 7) + 1;
int xtiles = ((data2 >> 8) & 7) + 1;
int yflip = (data2 >> 15) & 1;
int xflip = (data2 >> 11) & 1;
int xt, yt; int xt, yt;
int zoomed = (curr_sprite.zoomx | curr_sprite.zoomy);
/* compute the zoom factor -- stolen from aerofgt.c */ /* compute the zoom factor -- stolen from aerofgt.c */
xzoom = 16 - zoomtable[xzoom] / 8; curr_sprite.zoomx = 16 - zoomtable[curr_sprite.zoomx] / 8;
yzoom = 16 - zoomtable[yzoom] / 8; curr_sprite.zoomy = 16 - zoomtable[curr_sprite.zoomy] / 8;
/* wrap around */ /* wrap around */
if (x > visarea.max_x) if (curr_sprite.ox > visarea.max_x)
x -= 0x200; curr_sprite.ox -= 0x200;
if (y > visarea.max_y) if (curr_sprite.oy > visarea.max_y)
y -= 0x200; curr_sprite.oy -= 0x200;
/* flip ? */ /* flip ? */
if (flipscreen) if (flipscreen)
{ {
y = visarea.max_y - y - 16 * ytiles - 4; curr_sprite.oy = visarea.max_y - curr_sprite.oy - 16 * curr_sprite.ysize - 4;
x = visarea.max_x - x - 16 * xtiles - 24; curr_sprite.ox = visarea.max_x - curr_sprite.ox - 16 * curr_sprite.xsize - 24;
xflip=!xflip; curr_sprite.flipx=!curr_sprite.flipx;
yflip=!yflip; curr_sprite.flipy=!curr_sprite.flipy;
} }
/* normal case */ /* normal case */
if (!xflip && !yflip) if (!curr_sprite.flipx && !curr_sprite.flipy)
{ {
for (yt = 0; yt < ytiles; yt++) for (yt = 0; yt < curr_sprite.ysize; yt++)
for (xt = 0; xt < xtiles; xt++, code++) for (xt = 0; xt < curr_sprite.xsize; xt++, curr_sprite.map++)
if (!zoomed) if (!zoomed)
drawgfx_transpen(bitmap, cliprect, screen.machine().gfx[2], code, color, 0, 0, drawgfx_transpen(bitmap, cliprect, screen.machine().gfx[2], curr_sprite.map, curr_sprite.color, 0, 0,
x + xt * 16, y + yt * 16, 15); curr_sprite.ox + xt * 16, curr_sprite.oy + yt * 16, 15);
else else
drawgfxzoom_transpen(bitmap, cliprect, screen.machine().gfx[2], code, color, 0, 0, drawgfxzoom_transpen(bitmap, cliprect, screen.machine().gfx[2], curr_sprite.map, curr_sprite.color, 0, 0,
x + xt * xzoom, y + yt * yzoom, curr_sprite.ox + xt * curr_sprite.zoomx, curr_sprite.oy + yt * curr_sprite.zoomy,
0x1000 * xzoom, 0x1000 * yzoom, 15); 0x1000 * curr_sprite.zoomx, 0x1000 * curr_sprite.zoomy, 15);
} }
/* xflipped case */ /* curr_sprite.flipxped case */
else if (xflip && !yflip) else if (curr_sprite.flipx && !curr_sprite.flipy)
{ {
for (yt = 0; yt < ytiles; yt++) for (yt = 0; yt < curr_sprite.ysize; yt++)
for (xt = 0; xt < xtiles; xt++, code++) for (xt = 0; xt < curr_sprite.xsize; xt++, curr_sprite.map++)
if (!zoomed) if (!zoomed)
drawgfx_transpen(bitmap, cliprect, screen.machine().gfx[2], code, color, 1, 0, drawgfx_transpen(bitmap, cliprect, screen.machine().gfx[2], curr_sprite.map, curr_sprite.color, 1, 0,
x + (xtiles - 1 - xt) * 16, y + yt * 16, 15); curr_sprite.ox + (curr_sprite.xsize - 1 - xt) * 16, curr_sprite.oy + yt * 16, 15);
else else
drawgfxzoom_transpen(bitmap, cliprect, screen.machine().gfx[2], code, color, 1, 0, drawgfxzoom_transpen(bitmap, cliprect, screen.machine().gfx[2], curr_sprite.map, curr_sprite.color, 1, 0,
x + (xtiles - 1 - xt) * xzoom, y + yt * yzoom, curr_sprite.ox + (curr_sprite.xsize - 1 - xt) * curr_sprite.zoomx, curr_sprite.oy + yt * curr_sprite.zoomy,
0x1000 * xzoom, 0x1000 * yzoom, 15); 0x1000 * curr_sprite.zoomx, 0x1000 * curr_sprite.zoomy, 15);
} }
/* yflipped case */ /* curr_sprite.flipyped case */
else if (!xflip && yflip) else if (!curr_sprite.flipx && curr_sprite.flipy)
{ {
for (yt = 0; yt < ytiles; yt++) for (yt = 0; yt < curr_sprite.ysize; yt++)
for (xt = 0; xt < xtiles; xt++, code++) for (xt = 0; xt < curr_sprite.xsize; xt++, curr_sprite.map++)
if (!zoomed) if (!zoomed)
drawgfx_transpen(bitmap, cliprect, screen.machine().gfx[2], code, color, 0, 1, drawgfx_transpen(bitmap, cliprect, screen.machine().gfx[2], curr_sprite.map, curr_sprite.color, 0, 1,
x + xt * 16, y + (ytiles - 1 - yt) * 16, 15); curr_sprite.ox + xt * 16, curr_sprite.oy + (curr_sprite.ysize - 1 - yt) * 16, 15);
else else
drawgfxzoom_transpen(bitmap, cliprect, screen.machine().gfx[2], code, color, 0, 1, drawgfxzoom_transpen(bitmap, cliprect, screen.machine().gfx[2], curr_sprite.map, curr_sprite.color, 0, 1,
x + xt * xzoom, y + (ytiles - 1 - yt) * yzoom, curr_sprite.ox + xt * curr_sprite.zoomx, curr_sprite.oy + (curr_sprite.ysize - 1 - yt) * curr_sprite.zoomy,
0x1000 * xzoom, 0x1000 * yzoom, 15); 0x1000 * curr_sprite.zoomx, 0x1000 * curr_sprite.zoomy, 15);
} }
/* x & yflipped case */ /* x & curr_sprite.flipyped case */
else else
{ {
for (yt = 0; yt < ytiles; yt++) for (yt = 0; yt < curr_sprite.ysize; yt++)
for (xt = 0; xt < xtiles; xt++, code++) for (xt = 0; xt < curr_sprite.xsize; xt++, curr_sprite.map++)
if (!zoomed) if (!zoomed)
drawgfx_transpen(bitmap, cliprect, screen.machine().gfx[2], code, color, 1, 1, drawgfx_transpen(bitmap, cliprect, screen.machine().gfx[2], curr_sprite.map, curr_sprite.color, 1, 1,
x + (xtiles - 1 - xt) * 16, y + (ytiles - 1 - yt) * 16, 15); curr_sprite.ox + (curr_sprite.xsize - 1 - xt) * 16, curr_sprite.oy + (curr_sprite.ysize - 1 - yt) * 16, 15);
else else
drawgfxzoom_transpen(bitmap, cliprect, screen.machine().gfx[2], code, color, 1, 1, drawgfxzoom_transpen(bitmap, cliprect, screen.machine().gfx[2], curr_sprite.map, curr_sprite.color, 1, 1,
x + (xtiles - 1 - xt) * xzoom, y + (ytiles - 1 - yt) * yzoom, curr_sprite.ox + (curr_sprite.xsize - 1 - xt) * curr_sprite.zoomx, curr_sprite.oy + (curr_sprite.ysize - 1 - yt) * curr_sprite.zoomy,
0x1000 * xzoom, 0x1000 * yzoom, 15); 0x1000 * curr_sprite.zoomx, 0x1000 * curr_sprite.zoomy, 15);
} }
} }
} }

18
src/mame/video/vsystem_spr2.h
View File

@ -6,6 +6,24 @@ class vsystem_spr2_device : public device_t
public: public:
vsystem_spr2_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock); vsystem_spr2_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock);
struct vsystem_sprite_attributes
{
int ox;
int xsize;
int zoomx;
int oy;
int ysize;
int zoomy;
int flipx;
int flipy;
int color;
int pri;
UINT32 map;
} curr_sprite;
int get_sprite_attributes(UINT16* ram);
template<class _BitmapClass> template<class _BitmapClass>
void turbofrc_draw_sprites_common( UINT16* spriteram3, int spriteram3_bytes, UINT16* spriteram1, int spriteram1_bytes, UINT16* spriteram2, int spriteram2_bytes, int sprite_gfx, int spritepalettebank, running_machine &machine, _BitmapClass &bitmap, const rectangle &cliprect, int chip, int chip_disabled_pri ); void turbofrc_draw_sprites_common( UINT16* spriteram3, int spriteram3_bytes, UINT16* spriteram1, int spriteram1_bytes, UINT16* spriteram2, int spriteram2_bytes, int sprite_gfx, int spritepalettebank, running_machine &machine, _BitmapClass &bitmap, const rectangle &cliprect, int chip, int chip_disabled_pri );