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); } } } }