inline void z88_state::plot_pixel(bitmap_ind16 &bitmap, int x, int y, UINT16 color)
{
if (x<Z88_SCREEN_WIDTH)
bitmap.pix16(y, x) = color;
}
UINT32 ttchamp_state::screen_update_ttchamp(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
{
logerror("update\n");
int y,x,count;
static const int xxx=320,yyy=204;
bitmap.fill(m_palette->black_pen());
UINT8 *videoramfg;
UINT8* videorambg;
count=0;
videorambg = (UINT8*)m_videoram0;
videoramfg = (UINT8*)m_videoram2;
for (y=0;y<yyy;y++)
{
for(x=0;x<xxx;x++)
{
bitmap.pix16(y, x) = videorambg[BYTE_XOR_LE(count)]+0x300;
count++;
}
}
/*
count=0;
videoram = (UINT8*)m_videoram1;
for (y=0;y<yyy;y++)
{
for(x=0;x<xxx;x++)
{
UINT8 pix = videoram[BYTE_XOR_LE(count)];
if (pix) bitmap.pix16(y, x) = pix+0x200;
count++;
}
}
*/
count=0;
for (y=0;y<yyy;y++)
{
for(x=0;x<xxx;x++)
{
UINT8 pix = videoramfg[BYTE_XOR_LE(count)];
if (pix)
{
// first pen values seem to be special
// see char select and shadows ingame
// pen 0 = transparent
// pen 1 = blend 1
// pen 2 = blend 2
// pen 3 = ??
if (pix == 0x01) // blend mode 1
{
UINT8 pix = videorambg[BYTE_XOR_LE(count)];
bitmap.pix16(y, x) = pix + 0x200;
}
else if (pix == 0x02) // blend mode 2
{
UINT8 pix = videorambg[BYTE_XOR_LE(count)];
bitmap.pix16(y, x) = pix + 0x100;
}
else
{
bitmap.pix16(y, x) = pix + 0x000;
}
}
count++;
}
}
#if 0
for (int i = 0; i < 0x8000; i++)
{
// how are layers cleared?
// I think it actually does more blit operations with
// different bits of m_port10 set to redraw the backgrounds using the video ram data as a source rather than ROM - notice the garbage you see behind 'sprites' right now
// this method also removes the text layer, which we don't want
// m_videoram1[i] = 0x0000;
// m_videoram2[i] = 0x0000;
}
#endif
return 0;
}
// renders to 2 bitmaps, and mixes output
uint32_t toaplan2_state::screen_update_batsugun(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
{
// bitmap.fill(0, cliprect);
// gp9001_custom_priority_bitmap->fill(0, cliprect);
if (m_vdp[0])
{
bitmap.fill(0, cliprect);
m_custom_priority_bitmap.fill(0, cliprect);
m_vdp[0]->render_vdp(bitmap, cliprect);
}
if (m_vdp[1])
{
m_secondary_render_bitmap.fill(0, cliprect);
m_custom_priority_bitmap.fill(0, cliprect);
m_vdp[1]->render_vdp(m_secondary_render_bitmap, cliprect);
}
// key test places in batsugun
// level 2 - the two layers of clouds (will appear under background, or over ships if wrong)
// level 3 - the special effect 'layer' which should be under everything (will appear over background if wrong)
// level 4(?) - the large clouds (will obscure player if wrong)
// high score entry - letters will be missing if wrong
// end credits - various issues if wrong, clouds like level 2
//
// when implemented based directly on the PAL equation it doesn't work, however, my own equations roughly based
// on that do.
//
if (m_vdp[0] && m_vdp[1])
{
uint16_t* src_vdp0; // output buffer of vdp0
uint16_t* src_vdp1; // output buffer of vdp1
for (int y=cliprect.min_y;y<=cliprect.max_y;y++)
{
src_vdp0 = &bitmap.pix16(y);
src_vdp1 = &m_secondary_render_bitmap.pix16(y);
for (int x=cliprect.min_x;x<=cliprect.max_x;x++)
{
uint16_t GPU0_LUTaddr = src_vdp0[x];
uint16_t GPU1_LUTaddr = src_vdp1[x];
// these equations is derived from the PAL, but doesn't seem to work?
int COMPARISON = ((GPU0_LUTaddr & 0x0780) > (GPU1_LUTaddr & 0x0780));
// note: GPU1_LUTaddr & 0x000f - transparency check for vdp1? (gfx are 4bpp, the low 4 bits of the lookup would be the pixel data value)
#if 0
int result =
((GPU0_LUTaddr & 0x0008) & !COMPARISON)
| ((GPU0_LUTaddr & 0x0008) & !(GPU1_LUTaddr & 0x000f))
| ((GPU0_LUTaddr & 0x0004) & !COMPARISON)
| ((GPU0_LUTaddr & 0x0004) & !(GPU1_LUTaddr & 0x000f))
| ((GPU0_LUTaddr & 0x0002) & !COMPARISON)
| ((GPU0_LUTaddr & 0x0002) & !(GPU1_LUTaddr & 0x000f))
| ((GPU0_LUTaddr & 0x0001) & !COMPARISON)
| ((GPU0_LUTaddr & 0x0001) & !(GPU1_LUTaddr & 0x000f));
if (result) src_vdp0[x] = GPU0_LUTaddr;
else src_vdp0[x] = GPU1_LUTaddr;
#endif
// this seems to work tho?
if (!(GPU1_LUTaddr & 0x000f))
{
src_vdp0[x] = GPU0_LUTaddr;
}
else
{
if (!(GPU0_LUTaddr & 0x000f))
{
src_vdp0[x] = GPU1_LUTaddr; // bg pen
}
else
{
if (COMPARISON)
{
src_vdp0[x] = GPU1_LUTaddr;
}
else
{
src_vdp0[x] = GPU0_LUTaddr;
}
}
}
}
}
}
return 0;
}
INLINE void x68k_plot_pixel(bitmap_ind16 &bitmap, int x, int y, UINT32 color)
{
bitmap.pix16(y, x) = (UINT16)color;
}
UINT32 destroyr_state::screen_update_destroyr(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
{
int i, j;
bitmap.fill(0, cliprect);
/* draw major objects */
for (i = 0; i < 16; i++)
{
int attr = m_major_obj_ram[2 * i + 0] ^ 0xff;
int horz = m_major_obj_ram[2 * i + 1];
int num = attr & 3;
int scan = attr & 4;
int flipx = attr & 8;
if (scan == 0)
{
if (horz >= 192)
horz -= 256;
}
else
{
if (horz < 192)
continue;
}
m_gfxdecode->gfx(2)->transpen(bitmap,cliprect, num, 0, flipx, 0, horz, 16 * i, 0);
}
/* draw alpha numerics */
for (i = 0; i < 8; i++)
{
for (j = 0; j < 32; j++)
{
int num = m_alpha_num_ram[32 * i + j];
m_gfxdecode->gfx(0)->transpen(bitmap,cliprect, num, 0, 0, 0, 8 * j, 8 * i, 0);
}
}
/* draw minor objects */
for (i = 0; i < 2; i++)
{
int num = i << 4 | (m_minor_obj_ram[i + 0] & 0xf);
int horz = 256 - m_minor_obj_ram[i + 2];
int vert = 256 - m_minor_obj_ram[i + 4];
m_gfxdecode->gfx(1)->transpen(bitmap,cliprect, num, 0, 0, 0, horz, vert, 0);
}
/* draw waves */
for (i = 0; i < 4; i++)
{
m_gfxdecode->gfx(3)->transpen(bitmap,cliprect, m_wavemod ? 1 : 0, 0, 0, 0, 64 * i, 0x4e, 0);
}
/* draw cursor */
for (i = 0; i < 256; i++)
{
if (i & 4)
bitmap.pix16(m_cursor ^ 0xff, i) = 7;
}
return 0;
}
inline void tx0_state::tx0_plot_pixel(bitmap_ind16 &bitmap, int x, int y, UINT32 color)
{
bitmap.pix16(y, x) = color;
}
uint32_t gridlee_state::screen_update_gridlee(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
{
const pen_t *pens = &m_palette->pen(m_palettebank_vis * 32);
uint8_t *gfx;
int x, y, i;
/* draw scanlines from the VRAM directly */
for (y = cliprect.min_y; y <= cliprect.max_y; y++)
{
/* non-flipped: draw directly from the bitmap */
if (!m_cocktail_flip)
draw_scanline8(bitmap, 0, y, 256, &m_local_videoram[(y - GRIDLEE_VBEND) * 256], pens + 16);
/* flipped: x-flip the scanline into a temp buffer and draw that */
else
{
int srcy = GRIDLEE_VBSTART - 1 - y;
uint8_t temp[256];
int xx;
for (xx = 0; xx < 256; xx++)
temp[xx] = m_local_videoram[srcy * 256 + 255 - xx];
draw_scanline8(bitmap, 0, y, 256, temp, pens + 16);
}
}
/* draw the sprite images */
gfx = memregion("gfx1")->base();
for (i = 0; i < 32; i++)
{
uint8_t *sprite = m_spriteram + i * 4;
uint8_t *src;
int image = sprite[0];
int ypos = sprite[2] + 17 + GRIDLEE_VBEND;
int xpos = sprite[3];
/* get a pointer to the source image */
src = &gfx[64 * image];
/* loop over y */
for (y = 0; y < 16; y++, ypos = (ypos + 1) & 255)
{
int currxor = 0;
/* adjust for flip */
if (m_cocktail_flip)
{
ypos = 271 - ypos;
currxor = 0xff;
}
if (ypos >= (16 + GRIDLEE_VBEND) && ypos >= cliprect.min_y && ypos <= cliprect.max_y)
{
int currx = xpos;
/* loop over x */
for (x = 0; x < 4; x++)
{
int ipixel = *src++;
int left = ipixel >> 4;
int right = ipixel & 0x0f;
/* left pixel */
if (left && currx >= 0 && currx < 256)
bitmap.pix16(ypos, currx ^ currxor) = pens[left];
currx++;
/* right pixel */
if (right && currx >= 0 && currx < 256)
bitmap.pix16(ypos, currx ^ currxor) = pens[right];
currx++;
}
}
else
src += 4;
/* de-adjust for flip */
if (m_cocktail_flip)
ypos = 271 - ypos;
}
void balsente_state::draw_one_sprite(bitmap_ind16 &bitmap, const rectangle &cliprect, uint8_t *sprite)
{
int flags = sprite[0];
int image = sprite[1] | ((flags & 7) << 8);
int ypos = sprite[2] + 17 + BALSENTE_VBEND;
int xpos = sprite[3];
uint8_t *src;
int x, y;
/* get a pointer to the source image */
src = &m_sprite_data[(64 * image) & m_sprite_mask];
if (flags & 0x80) src += 4 * 15;
/* loop over y */
for (y = 0; y < 16; y++, ypos = (ypos + 1) & 255)
{
if (ypos >= (16 + BALSENTE_VBEND) && ypos >= cliprect.min_y && ypos <= cliprect.max_y)
{
const pen_t *pens = &m_palette->pen(m_palettebank_vis * 256);
uint8_t *old = &m_expanded_videoram[(ypos - BALSENTE_VBEND) * 256 + xpos];
int currx = xpos;
/* standard case */
if (!(flags & 0x40))
{
/* loop over x */
for (x = 0; x < 4; x++, old += 2)
{
int ipixel = *src++;
int left = ipixel & 0xf0;
int right = (ipixel << 4) & 0xf0;
/* left pixel, combine with the background */
if (left && currx >= 0 && currx < 256)
bitmap.pix16(ypos, currx) = pens[left | old[0]];
currx++;
/* right pixel, combine with the background */
if (right && currx >= 0 && currx < 256)
bitmap.pix16(ypos, currx) = pens[right | old[1]];
currx++;
}
}
/* hflip case */
else
{
src += 4;
/* loop over x */
for (x = 0; x < 4; x++, old += 2)
{
int ipixel = *--src;
int left = (ipixel << 4) & 0xf0;
int right = ipixel & 0xf0;
/* left pixel, combine with the background */
if (left && currx >= 0 && currx < 256)
bitmap.pix16(ypos, currx) = pens[left | old[0]];
currx++;
/* right pixel, combine with the background */
if (right && currx >= 0 && currx < 256)
bitmap.pix16(ypos, currx) = pens[right | old[1]];
currx++;
}
src += 4;
}
}
else
src += 4;
if (flags & 0x80) src -= 2 * 4;
}
}
void triplhnt_state::draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect)
{
int i;
int hit_line = 999;
int hit_code = 999;
for (i = 0; i < 16; i++)
{
rectangle rect;
int j = (m_orga_ram[i] & 15) ^ 15;
/* software sorts sprites by x and stores order in orga RAM */
int hpos = m_hpos_ram[j] ^ 255;
int vpos = m_vpos_ram[j] ^ 255;
int code = m_code_ram[j] ^ 255;
if (hpos == 255)
continue;
/* sprite placement might be wrong */
if (m_sprite_zoom)
{
rect.set(hpos - 16, hpos - 16 + 63, 196 - vpos, 196 - vpos + 63);
}
else
{
rect.set(hpos - 16, hpos - 16 + 31, 224 - vpos, 224 - vpos + 31);
}
/* render sprite to auxiliary bitmap */
m_gfxdecode->gfx(m_sprite_zoom)->opaque(m_helper,cliprect,
2 * code + m_sprite_bank, 0, code & 8, 0,
rect.min_x, rect.min_y);
rect &= cliprect;
/* check for collisions and copy sprite */
{
int x;
int y;
for (x = rect.min_x; x <= rect.max_x; x++)
{
for (y = rect.min_y; y <= rect.max_y; y++)
{
pen_t a = m_helper.pix16(y, x);
pen_t b = bitmap.pix16(y, x);
if (a == 2 && b == 7)
{
hit_code = j;
hit_line = y;
}
if (a != 1)
bitmap.pix16(y, x) = a;
}
}
}
}
if (hit_line != 999 && hit_code != 999)
timer_set(m_screen->time_until_pos(hit_line), TIMER_HIT, hit_code);
}
UINT32 vindictr_state::screen_update_vindictr(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
{
atarimo_rect_list rectlist;
bitmap_ind16 *mobitmap;
int x, y, r;
/* draw the playfield */
m_playfield_tilemap->draw(bitmap, cliprect, 0, 0);
/* draw and merge the MO */
mobitmap = atarimo_render(0, cliprect, &rectlist);
for (r = 0; r < rectlist.numrects; r++, rectlist.rect++)
for (y = rectlist.rect->min_y; y <= rectlist.rect->max_y; y++)
{
UINT16 *mo = &mobitmap->pix16(y);
UINT16 *pf = &bitmap.pix16(y);
for (x = rectlist.rect->min_x; x <= rectlist.rect->max_x; x++)
if (mo[x])
{
/* partially verified via schematics (there are a lot of PALs involved!):
SHADE = PAL(MPR1-0, LB7-0, PFX6-5, PFX3-2, PF/M)
if (SHADE)
CRA |= 0x100
MOG3-1 = ~MAT3-1 if MAT6==1 and MSD3==1
*/
int mopriority = mo[x] >> ATARIMO_PRIORITY_SHIFT;
/* upper bit of MO priority signals special rendering and doesn't draw anything */
if (mopriority & 4)
continue;
/* MO pen 1 doesn't draw, but it sets the SHADE flag and bumps the palette offset */
if ((mo[x] & 0x0f) == 1)
{
if ((mo[x] & 0xf0) != 0)
pf[x] |= 0x100;
}
else
pf[x] = mo[x] & ATARIMO_DATA_MASK;
/* don't erase yet -- we need to make another pass later */
}
}
/* add the alpha on top */
m_alpha_tilemap->draw(bitmap, cliprect, 0, 0);
/* now go back and process the upper bit of MO priority */
rectlist.rect -= rectlist.numrects;
for (r = 0; r < rectlist.numrects; r++, rectlist.rect++)
for (y = rectlist.rect->min_y; y <= rectlist.rect->max_y; y++)
{
UINT16 *mo = &mobitmap->pix16(y);
UINT16 *pf = &bitmap.pix16(y);
for (x = rectlist.rect->min_x; x <= rectlist.rect->max_x; x++)
if (mo[x])
{
int mopriority = mo[x] >> ATARIMO_PRIORITY_SHIFT;
/* upper bit of MO priority might mean palette kludges */
if (mopriority & 4)
{
/* if bit 2 is set, start setting high palette bits */
if (mo[x] & 2)
atarimo_mark_high_palette(bitmap, pf, mo, x, y);
/* if the upper bit of pen data is set, we adjust the final intensity */
if (mo[x] & 8)
pf[x] |= (~mo[x] & 0xe0) << 6;
}
/* erase behind ourselves */
mo[x] = 0;
}
}
return 0;
}
void deco_bac06_device::custom_tilemap_draw(bitmap_ind16 &bitmap,
const rectangle &cliprect,
tilemap_t *tilemap_ptr,
const uint16_t *rowscroll_ptr,
const uint16_t *colscroll_ptr,
const uint16_t *control0,
const uint16_t *control1,
int flags,
uint16_t penmask,
uint16_t pencondition,
uint16_t colprimask,
uint16_t colpricondition
)
{
const bitmap_ind16 &src_bitmap = tilemap_ptr->pixmap();
const bitmap_ind8 &flags_bitmap = tilemap_ptr->flagsmap();
int x, y, p, colpri;
int column_offset=0, src_x=0, src_y=0;
uint32_t scrollx = 0;
uint32_t scrolly = 0;
if (control1)
{
scrollx = control1[0];
scrolly = control1[1];
}
int width_mask;
int height_mask;
int row_scroll_enabled = 0;
int col_scroll_enabled = 0;
if (m_supports_rc_scroll)
{
if (control0)
{
row_scroll_enabled = (rowscroll_ptr && (control0[0] & 0x4));
col_scroll_enabled = (colscroll_ptr && (control0[0] & 0x8));
}
}
width_mask = src_bitmap.width() - 1;
height_mask = src_bitmap.height() - 1;
/* Column scroll & row scroll may per applied per pixel, there are
shift registers for each which control the granularity of the row/col
offset (down to per line level for row, and per 8 lines for column).
Nb: The row & col selectors are _not_ affected by the shape of the
playfield (ie, 256*1024, 512*512 or 1024*256). So even if the tilemap
width is only 256, 'src_x' should not wrap at 256 in the code below (to
do so would mean the top half of row RAM would never be accessed which
is incorrect).
Nb2: Real hardware exhibits a strange bug with column scroll on 'mode 2'
(256*1024) - the first column has a strange additional offset, but
curiously the first 'wrap' (at scroll offset 256) does not have this offset,
it is displayed as expected. The bug is confimed to only affect this mode,
the other two modes work as expected. This bug is not emulated, as it
doesn't affect any games.
*/
if (machine().driver_data()->flip_screen())
src_y = (src_bitmap.height() - 256) - scrolly;
else
src_y = scrolly;
for (y=0; y<=cliprect.max_y; y++) {
if (row_scroll_enabled)
src_x=scrollx + rowscroll_ptr[(src_y >> (control1[3]&0xf))&(0x1ff>>(control1[3]&0xf))];
else
src_x=scrollx;
if (machine().driver_data()->flip_screen())
src_x=(src_bitmap.width() - 256) - src_x;
for (x=0; x<=cliprect.max_x; x++) {
if (col_scroll_enabled)
column_offset=colscroll_ptr[((src_x >> 3) >> (control1[2]&0xf))&(0x3f>>(control1[2]&0xf))];
p = src_bitmap.pix16((src_y + column_offset)&height_mask, src_x&width_mask);
colpri = flags_bitmap.pix8((src_y + column_offset)&height_mask, src_x&width_mask)&0xf;
src_x++;
if ((flags&TILEMAP_DRAW_OPAQUE) || (p&m_bppmask))
{
if ((p&penmask)==pencondition)
if((colpri&colprimask)==colpricondition)
bitmap.pix16(y, x) = p+(colpri&m_gfxcolmask)*m_bppmult;
}
}
src_y++;
}
static inline void K053936GP_copyroz32clip( running_machine &machine,
bitmap_rgb32 &dst_bitmap, bitmap_ind16 &src_bitmap,
const rectangle &dst_cliprect, const rectangle &src_cliprect,
UINT32 _startx,UINT32 _starty,int _incxx,int _incxy,int _incyx,int _incyy,
int tilebpp, int blend, int alpha, int clip, int pixeldouble_output, palette_device *palette )
{
static const int colormask[8]={1,3,7,0xf,0x1f,0x3f,0x7f,0xff};
int cy, cx;
int ecx;
int src_pitch, incxy, incxx;
int src_minx, src_maxx, src_miny, src_maxy, cmask;
UINT16 *src_base;
size_t src_size;
const pen_t *pal_base;
int dst_ptr;
int dst_size;
int dst_base2;
int tx, dst_pitch;
UINT32 *dst_base;
int starty, incyy, startx, incyx, ty, sx, sy;
incxy = _incxy; incxx = _incxx; incyy = _incyy; incyx = _incyx;
starty = _starty; startx = _startx;
if (clip) // set source clip range to some extreme values when disabled
{
src_minx = src_cliprect.min_x;
src_maxx = src_cliprect.max_x;
src_miny = src_cliprect.min_y;
src_maxy = src_cliprect.max_y;
}
// this simply isn't safe to do!
else { src_minx = src_miny = -0x10000; src_maxx = src_maxy = 0x10000; }
// set target clip range
sx = dst_cliprect.min_x;
tx = dst_cliprect.max_x - sx + 1;
sy = dst_cliprect.min_y;
ty = dst_cliprect.max_y - sy + 1;
startx += sx * incxx + sy * incyx;
starty += sx * incxy + sy * incyy;
// adjust entry points and other loop constants
dst_pitch = dst_bitmap.rowpixels();
dst_base = &dst_bitmap.pix32(0);
dst_base2 = sy * dst_pitch + sx + tx;
ecx = tx = -tx;
tilebpp = (tilebpp-1) & 7;
pal_base = palette->pens();
cmask = colormask[tilebpp];
src_pitch = src_bitmap.rowpixels();
src_base = &src_bitmap.pix16(0);
src_size = src_bitmap.width() * src_bitmap.height();
dst_size = dst_bitmap.width() * dst_bitmap.height();
dst_ptr = 0;//dst_base;
cy = starty;
cx = startx;
if (blend > 0)
{
dst_ptr += dst_pitch; // draw blended
starty += incyy;
startx += incyx;
do {
do {
int srcx = (cx >> 16) & 0x1fff;
int srcy = (cy >> 16) & 0x1fff;
int pixel;
UINT32 offs;
offs = srcy * src_pitch + srcx;
cx += incxx;
cy += incxy;
if (offs>=src_size)
continue;
if (srcx < src_minx || srcx > src_maxx || srcy < src_miny || srcy > src_maxy)
continue;
pixel = src_base[offs];
if (!(pixel & cmask))
continue;
if ((dst_ptr+ecx+dst_base2)<dst_size) dst_base[dst_ptr+ecx+dst_base2] = alpha_blend_r32(pal_base[pixel], dst_base[dst_ptr+ecx+dst_base2], alpha);
if (pixeldouble_output)
{
ecx++;
if ((dst_ptr+ecx+dst_base2)<dst_size) dst_base[dst_ptr+ecx+dst_base2] = alpha_blend_r32(pal_base[pixel], dst_base[dst_ptr+ecx+dst_base2], alpha);
}
}
while (++ecx < 0);
ecx = tx;
dst_ptr += dst_pitch;
cy = starty; starty += incyy;
cx = startx; startx += incyx;
} while (--ty);
}
static void draw_sprites( running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect )
{
mcatadv_state *state = machine.driver_data<mcatadv_state>();
UINT16 *source = state->m_spriteram_old;
UINT16 *finish = source + (state->m_spriteram.bytes() / 2) /2;
int global_x = state->m_vidregs[0] - 0x184;
int global_y = state->m_vidregs[1] - 0x1f1;
UINT16 *destline;
UINT8 *priline;
UINT8 *sprdata = state->memregion("gfx1")->base();
int sprmask = state->memregion("gfx1")->bytes()-1;
int xstart, xend, xinc;
int ystart, yend, yinc;
if (state->m_vidregs_old[2] == 0x0001) /* Double Buffered */
{
source += (state->m_spriteram.bytes() / 2) / 2;
finish += (state->m_spriteram.bytes() / 2) / 2;
}
else if (state->m_vidregs_old[2]) /* I suppose it's possible that there is 4 banks, haven't seen it used though */
{
logerror("Spritebank != 0/1\n");
}
while (source < finish)
{
int pen = (source[0] & 0x3f00) >> 8;
int tileno = source[1] & 0xffff;
int pri = (source[0] & 0xc000) >> 14;
int x = source[2] & 0x3ff;
int y = source[3] & 0x3ff;
int flipy = source[0] & 0x0040;
int flipx = source[0] & 0x0080;
int height = ((source[3] & 0xf000) >> 12) * 16;
int width = ((source[2] & 0xf000) >> 12) * 16;
int offset = tileno * 256;
int drawxpos, drawypos;
int xcnt, ycnt;
int pix;
if (x & 0x200) x-=0x400;
if (y & 0x200) y-=0x400;
#if 0 // For Flipscreen/Cocktail
if(state->m_vidregs[0] & 0x8000)
{
flipx = !flipx;
}
if(state->m_vidregs[1] & 0x8000)
{
flipy = !flipy;
}
#endif
if (source[3] != source[0]) // 'hack' don't draw sprites while its testing the ram!
{
if(!flipx) { xstart = 0; xend = width; xinc = 1; }
else { xstart = width-1; xend = -1; xinc = -1; }
if(!flipy) { ystart = 0; yend = height; yinc = 1; }
else { ystart = height-1; yend = -1; yinc = -1; }
for (ycnt = ystart; ycnt != yend; ycnt += yinc)
{
drawypos = y + ycnt - global_y;
if ((drawypos >= cliprect.min_y) && (drawypos <= cliprect.max_y))
{
destline = &bitmap.pix16(drawypos);
priline = &machine.priority_bitmap.pix8(drawypos);
for (xcnt = xstart; xcnt != xend; xcnt += xinc)
{
drawxpos = x + xcnt - global_x;
if ((drawxpos >= cliprect.min_x) && (drawxpos <= cliprect.max_x))
{
if((priline[drawxpos] < pri))
{
pix = sprdata[(offset / 2)&sprmask];
if (offset & 1)
pix = pix >> 4;
pix &= 0x0f;
if (pix)
destline[drawxpos] = (pix + (pen << 4));
}
}
offset++;
}
}
else
{
offset += width;
}
}
void splash_state::draw_bitmap(bitmap_ind16 &bitmap, const rectangle &cliprect)
{
int sx,sy,color,count,colxor,bitswap;
colxor = 0; /* splash and some bitmap modes in roldfrog */
bitswap = 0;
if (m_bitmap_type == 1) /* roldfrog */
{
if (m_bitmap_mode[0] == 0x0000)
{
colxor = 0x7f;
}
else if (m_bitmap_mode[0] == 0x0100)
{
bitswap = 1;
}
else if (m_bitmap_mode[0] == 0x0200)
{
colxor = 0x55;
}
else if (m_bitmap_mode[0] == 0x0300)
{
bitswap = 2;
colxor = 0x7f;
}
else if (m_bitmap_mode[0] == 0x0400)
{
bitswap = 3;
}
else if (m_bitmap_mode[0] == 0x0500)
{
bitswap = 4;
}
else if (m_bitmap_mode[0] == 0x0600)
{
bitswap = 5;
colxor = 0x7f;
}
else if (m_bitmap_mode[0] == 0x0700)
{
bitswap = 6;
colxor = 0x55;
}
}
count = 0;
for (sy=0;sy<256;sy++)
{
for (sx=0;sx<512;sx++)
{
color = m_pixelram[count]&0xff;
count++;
switch( bitswap )
{
case 1:
color = BITSWAP8(color,7,0,1,2,3,4,5,6);
break;
case 2:
color = BITSWAP8(color,7,4,6,5,1,0,3,2);
break;
case 3:
color = BITSWAP8(color,7,3,2,1,0,6,5,4);
break;
case 4:
color = BITSWAP8(color,7,6,4,2,0,5,3,1);
break;
case 5:
color = BITSWAP8(color,7,0,6,5,4,3,2,1);
break;
case 6:
color = BITSWAP8(color,7,4,3,2,1,0,6,5);
break;
}
if (sy >= cliprect.min_y && sy <= cliprect.max_y && sx-9 >= cliprect.min_x && sx-9 <= cliprect.max_x)
bitmap.pix16(sy, sx-9) = 0x300+(color^colxor);
}
}
}
static void draw_sprites(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect)
{
triplhnt_state *state = machine.driver_data<triplhnt_state>();
int i;
int hit_line = 999;
int hit_code = 999;
for (i = 0; i < 16; i++)
{
rectangle rect;
int j = (state->m_orga_ram[i] & 15) ^ 15;
/* software sorts sprites by x and stores order in orga RAM */
int hpos = state->m_hpos_ram[j] ^ 255;
int vpos = state->m_vpos_ram[j] ^ 255;
int code = state->m_code_ram[j] ^ 255;
if (hpos == 255)
continue;
/* sprite placement might be wrong */
if (state->m_sprite_zoom)
{
rect.set(hpos - 16, hpos - 16 + 63, 196 - vpos, 196 - vpos + 63);
}
else
{
rect.set(hpos - 16, hpos - 16 + 31, 224 - vpos, 224 - vpos + 31);
}
/* render sprite to auxiliary bitmap */
drawgfx_opaque(state->m_helper, cliprect, machine.gfx[state->m_sprite_zoom],
2 * code + state->m_sprite_bank, 0, code & 8, 0,
rect.min_x, rect.min_y);
rect &= cliprect;
/* check for collisions and copy sprite */
{
int x;
int y;
for (x = rect.min_x; x <= rect.max_x; x++)
{
for (y = rect.min_y; y <= rect.max_y; y++)
{
pen_t a = state->m_helper.pix16(y, x);
pen_t b = bitmap.pix16(y, x);
if (a == 2 && b == 7)
{
hit_code = j;
hit_line = y;
}
if (a != 1)
bitmap.pix16(y, x) = a;
}
}
}
}
if (hit_line != 999 && hit_code != 999)
machine.scheduler().timer_set(machine.primary_screen->time_until_pos(hit_line), FUNC(triplhnt_hit_callback), hit_code);
}
static void taito_f2_tc360_spritemixdraw( running_machine &machine, bitmap_ind16 &dest_bmp, const rectangle &clip, gfx_element *gfx,
UINT32 code, UINT32 color, int flipx, int flipy, int sx, int sy, int scalex, int scaley )
{
taitof2_state *state = machine.driver_data<taitof2_state>();
int pal_base = gfx->colorbase() + gfx->granularity() * (color % gfx->colors());
const UINT8 *source_base = gfx->get_data(code % gfx->elements());
bitmap_ind8 &priority_bitmap = gfx->machine().priority_bitmap;
int sprite_screen_height = (scaley * gfx->height() + 0x8000) >> 16;
int sprite_screen_width = (scalex * gfx->width() + 0x8000) >> 16;
if (!scalex || !scaley)
return;
if (sprite_screen_width && sprite_screen_height)
{
/* compute sprite increment per screen pixel */
int dx = (gfx->width() << 16) / sprite_screen_width;
int dy = (gfx->height() << 16) / sprite_screen_height;
int ex = sx + sprite_screen_width;
int ey = sy + sprite_screen_height;
int x_index_base;
int y_index;
if (flipx)
{
x_index_base = (sprite_screen_width - 1) * dx;
dx = -dx;
}
else
{
x_index_base = 0;
}
if (flipy)
{
y_index = (sprite_screen_height - 1) * dy;
dy = -dy;
}
else
{
y_index = 0;
}
if (sx < clip.min_x)
{ /* clip left */
int pixels = clip.min_x - sx;
sx += pixels;
x_index_base += pixels * dx;
}
if (sy < clip.min_y)
{ /* clip top */
int pixels = clip.min_y - sy;
sy += pixels;
y_index += pixels * dy;
}
/* NS 980211 - fixed incorrect clipping */
if (ex > clip.max_x + 1)
{ /* clip right */
int pixels = ex-clip.max_x - 1;
ex -= pixels;
}
if (ey > clip.max_y + 1)
{ /* clip bottom */
int pixels = ey-clip.max_y - 1;
ey -= pixels;
}
if (ex > sx)
{
/* skip if inner loop doesn't draw anything */
int y;
for (y = sy; y < ey; y++)
{
const UINT8 *source = source_base + (y_index >> 16) * gfx->rowbytes();
UINT16 *dest = &dest_bmp.pix16(y);
UINT8 *pri = &priority_bitmap.pix8(y);
int x, x_index = x_index_base;
for (x = sx; x < ex; x++)
{
int c = source[x_index >> 16];
if (c && (pri[x] & 0x80) == 0)
{
UINT8 tilemap_priority = 0, sprite_priority = 0;
// Get tilemap priority (0 - 0xf) for this destination pixel
if (pri[x] & 0x10) tilemap_priority = state->m_tilepri[4];
else if (pri[x] & 0x8) tilemap_priority = state->m_tilepri[3];
else if (pri[x] & 0x4) tilemap_priority = state->m_tilepri[2];
else if (pri[x] & 0x2) tilemap_priority = state->m_tilepri[1];
else if (pri[x] & 0x1) tilemap_priority = state->m_tilepri[0];
// Get sprite priority (0 - 0xf) for this source pixel
if ((color & 0xc0) == 0xc0)
sprite_priority = state->m_spritepri[3];
else if ((color & 0xc0) == 0x80)
sprite_priority = state->m_spritepri[2];
else if ((color & 0xc0) == 0x40)
sprite_priority = state->m_spritepri[1];
else if ((color & 0xc0) == 0x00)
sprite_priority = state->m_spritepri[0];
// Blend mode 1 - Sprite under tilemap, use sprite palette with tilemap data
if ((state->m_spriteblendmode & 0xc0) == 0xc0 && sprite_priority == (tilemap_priority - 1))
{
dest[x] = ((pal_base + c) & 0xfff0) | (dest[x] & 0xf);
}
// Blend mode 1 - Sprite over tilemap, use sprite data with tilemap palette
else if ((state->m_spriteblendmode & 0xc0) == 0xc0 && sprite_priority == (tilemap_priority + 1))
{
if (dest[x] & 0xf)
dest[x] = (dest[x] & 0xfff0) | ((pal_base + c) & 0xf);
else
dest[x] = pal_base + c;
}
// Blend mode 2 - Sprite under tilemap, use sprite data with tilemap palette
else if ((state->m_spriteblendmode & 0xc0) == 0x80 && sprite_priority == (tilemap_priority - 1))
{
dest[x] = (dest[x] & 0xffef);
}
// Blend mode 2 - Sprite over tilemap, alternate sprite palette, confirmed in Pulirula level 2
else if ((state->m_spriteblendmode & 0xc0) == 0x80 && sprite_priority == (tilemap_priority + 1))
{
dest[x] = ((pal_base + c) & 0xffef); // Pulirula level 2, Liquid Kids attract mode
}
// No blending
else
{
if (sprite_priority > tilemap_priority) // Ninja Kids confirms tilemap takes priority in equal value case
dest[x] = pal_base + c;
}
pri[x] |= 0x80;
}
x_index += dx;
}
y_index += dy;
}
}
UINT32 tc0091lvc_device::screen_update(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
{
UINT32 count;
int x,y;
UINT8 global_flip;
bitmap.fill(m_gfxdecode->palette().black_pen(), cliprect);
if((m_vregs[4] & 0x20) == 0)
return 0;
global_flip = m_vregs[4] & 0x10;
if((m_vregs[4] & 0x7) == 7) // 8bpp bitmap enabled
{
count = 0;
for (y=0;y<256;y++)
{
for (x=0;x<512;x++)
{
int res_x, res_y;
res_x = (global_flip) ? 320-x : x;
res_y = (global_flip) ? 256-y : y;
if(screen.visible_area().contains(res_x, res_y))
bitmap.pix16(res_y, res_x) = m_gfxdecode->palette().pen(m_bitmap_ram[count]);
count++;
}
}
}
else
{
int dx, dy;
machine().tilemap().set_flip_all(global_flip ? (TILEMAP_FLIPY | TILEMAP_FLIPX) : 0);
dx = m_bg0_scroll[0] | (m_bg0_scroll[1] << 8);
if (global_flip) { dx = ((dx & 0xfffc) | ((dx - 3) & 0x0003)) ^ 0xf; dx += 192; }
dy = m_bg0_scroll[2];
bg0_tilemap->set_scrollx(0, -dx);
bg0_tilemap->set_scrolly(0, -dy);
dx = m_bg1_scroll[0] | (m_bg1_scroll[1] << 8);
if (global_flip) { dx = ((dx & 0xfffc) | ((dx - 3) & 0x0003)) ^ 0xf; dx += 192; }
dy = m_bg1_scroll[2];
bg1_tilemap->set_scrollx(0, -dx);
bg1_tilemap->set_scrolly(0, -dy);
tx_tilemap->set_scrollx(0, (global_flip) ? -192 : 0);
screen.priority().fill(0, cliprect);
bg1_tilemap->draw(screen, bitmap, cliprect, 0,0);
bg0_tilemap->draw(screen, bitmap, cliprect, 0,(m_vregs[4] & 0x8) ? 0 : 1);
draw_sprites(screen, bitmap, cliprect, global_flip);
tx_tilemap->draw(screen, bitmap, cliprect, 0,0);
}
return 0;
}
void zac2650_state::draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect)
{
int offs;
const rectangle &visarea = m_screen->visible_area();
/* -------------------------------------------------------------- */
/* There seems to be a strange setup with this board, in that it */
/* appears that the S2636 runs from a different clock than the */
/* background generator, When the program maps sprite position to */
/* character position it only has 6 pixels of sprite for 8 pixels */
/* of character. */
/* -------------------------------------------------------------- */
/* n.b. The original has several graphic glitches as well, so it */
/* does not seem to be a fault of the emulation! */
/* -------------------------------------------------------------- */
m_CollisionBackground = 0; /* Read from 0x1e80 bit 7 */
// for collision detection checking
copybitmap(m_bitmap,bitmap,0,0,0,0,visarea);
for(offs=0;offs<0x50;offs+=0x10)
{
if((m_s2636_0_ram[offs+10]<0xF0) && (offs!=0x30))
{
int spriteno = (offs / 8);
int expand = ((m_s2636_0_ram[0xc0] & (spriteno*2))!=0) ? 2 : 1;
int bx = (m_s2636_0_ram[offs+10] * 4) - 22;
int by = (m_s2636_0_ram[offs+12] * 3) + 3;
int x,y;
/* Sprite->Background collision detection */
m_gfxdecode->gfx(expand)->transpen(bitmap,cliprect,
spriteno,
1,
0,0,
bx,by, 0);
for (x = bx; x < bx + m_gfxdecode->gfx(expand)->width(); x++)
{
for (y = by; y < by +m_gfxdecode->gfx(expand)->height(); y++)
{
if (visarea.contains(x, y))
if (bitmap.pix16(y, x) != m_bitmap.pix16(y, x))
{
m_CollisionBackground = 0x80;
break;
}
}
}
m_gfxdecode->gfx(expand)->transpen(bitmap,cliprect,
spriteno,
0,
0,0,
bx,by, 0);
}
}
/* Sprite->Sprite collision detection */
m_CollisionSprite = 0;
// if(SpriteCollision(0,1)) m_CollisionSprite |= 0x20; /* Not Used */
if(SpriteCollision(0,2)) m_CollisionSprite |= 0x10;
if(SpriteCollision(0,4)) m_CollisionSprite |= 0x08;
if(SpriteCollision(1,2)) m_CollisionSprite |= 0x04;
if(SpriteCollision(1,4)) m_CollisionSprite |= 0x02;
// if(SpriteCollision(2,4)) m_CollisionSprite |= 0x01; /* Not Used */
}
void buggychl_state::draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect )
{
UINT8 *spriteram = m_spriteram;
int offs;
const UINT8 *gfx;
g_profiler.start(PROFILER_USER1);
gfx = memregion("gfx2")->base();
for (offs = 0; offs < m_spriteram.bytes(); offs += 4)
{
int sx, sy, flipy, zoom, ch, x, px, y;
const UINT8 *lookup;
const UINT8 *zoomx_rom, *zoomy_rom;
sx = spriteram[offs + 3] - ((spriteram[offs + 2] & 0x80) << 1);
sy = 256 - 64 - spriteram[offs] + ((spriteram[offs + 1] & 0x80) << 1);
flipy = spriteram[offs + 1] & 0x40;
zoom = spriteram[offs + 1] & 0x3f;
zoomy_rom = gfx + (zoom << 6);
zoomx_rom = gfx + 0x2000 + (zoom << 3);
lookup = m_sprite_lookup + ((spriteram[offs + 2] & 0x7f) << 6);
for (y = 0; y < 64; y++)
{
int dy = flip_screen_y() ? (255 - sy - y) : (sy + y);
if ((dy & ~0xff) == 0)
{
int charline, base_pos;
charline = zoomy_rom[y] & 0x07;
base_pos = zoomy_rom[y] & 0x38;
if (flipy)
base_pos ^= 0x38;
px = 0;
for (ch = 0; ch < 4; ch++)
{
int pos, code, realflipy;
const UINT8 *pendata;
pos = base_pos + 2 * ch;
code = 8 * (lookup[pos] | ((lookup[pos + 1] & 0x07) << 8));
realflipy = (lookup[pos + 1] & 0x80) ? !flipy : flipy;
code += (realflipy ? (charline ^ 7) : charline);
pendata = machine().gfx[1]->get_data(code);
for (x = 0; x < 16; x++)
{
int col = pendata[x];
if (col)
{
int dx = flip_screen_x() ? (255 - sx - px) : (sx + px);
if ((dx & ~0xff) == 0)
bitmap.pix16(dy, dx) = m_sprite_color_base + col;
}
/* the following line is almost certainly wrong */
if (zoomx_rom[7 - (2 * ch + x / 8)] & (1 << (x & 7)))
px++;
}
}
}
}
}
g_profiler.stop();
}
void apple2_state::apple2_hires_draw(bitmap_ind16 &bitmap, const rectangle &cliprect, int page, int beginrow, int endrow)
{
const uint8_t *vram, *vaux;
int row, col, b;
int offset;
int columns;
uint8_t vram_row[82];
uint16_t v;
uint16_t *p;
uint32_t w;
uint16_t *artifact_map_ptr;
int mon_type = m_sysconfig.read_safe(0) & 0x03;
/* sanity checks */
if (beginrow < cliprect.min_y)
beginrow = cliprect.min_y;
if (endrow > cliprect.max_y)
endrow = cliprect.max_y;
if (endrow < beginrow)
return;
if (m_machinetype == TK2000)
{
vram = m_a2_videoram + (page ? 0xa000 : 0x2000);
vaux = m_a2_videoaux + (page ? 0xa000 : 0x2000);
}
else
{
vram = m_a2_videoram + (page ? 0x4000 : 0x2000);
vaux = m_a2_videoaux + (page ? 0x4000 : 0x2000);
}
columns = ((effective_a2() & (VAR_DHIRES|VAR_80COL)) == (VAR_DHIRES|VAR_80COL)) ? 80 : 40;
vram_row[0] = 0;
vram_row[columns + 1] = 0;
for (row = beginrow; row <= endrow; row++)
{
for (col = 0; col < 40; col++)
{
offset = compute_video_address(col, row / 8) | ((row & 7) << 10);
switch(columns)
{
case 40:
vram_row[1+col] = vram[offset];
break;
case 80:
vram_row[1+(col*2)+0] = vaux[offset];
vram_row[1+(col*2)+1] = vram[offset];
break;
default:
fatalerror("Invalid column count\n");
}
}
p = &bitmap.pix16(row);
for (col = 0; col < columns; col++)
{
w = (((uint32_t) vram_row[col+0] & 0x7f) << 0)
| (((uint32_t) vram_row[col+1] & 0x7f) << 7)
| (((uint32_t) vram_row[col+2] & 0x7f) << 14);
switch(columns)
{
case 40:
switch (mon_type)
{
case 0:
artifact_map_ptr = &m_hires_artifact_map[((vram_row[col+1] & 0x80) >> 7) * 16];
for (b = 0; b < 7; b++)
{
v = artifact_map_ptr[((w >> (b + 7-1)) & 0x07) | (((b ^ col) & 0x01) << 3)];
*(p++) = v;
*(p++) = v;
}
break;
case 1:
w >>= 7;
for (b = 0; b < 7; b++)
{
v = (w & 1);
w >>= 1;
*(p++) = v ? WHITE : BLACK;
*(p++) = v ? WHITE : BLACK;
}
break;
case 2:
w >>= 7;
for (b = 0; b < 7; b++)
{
v = (w & 1);
w >>= 1;
*(p++) = v ? GREEN : BLACK;
*(p++) = v ? GREEN : BLACK;
}
break;
case 3:
w >>= 7;
for (b = 0; b < 7; b++)
{
v = (w & 1);
w >>= 1;
*(p++) = v ? ORANGE : BLACK;
*(p++) = v ? ORANGE : BLACK;
}
break;
}
break;
case 80:
if (m_monochrome_dhr)
{
w >>= 7;
for (b = 0; b < 7; b++)
{
v = (w & 1);
w >>= 1;
*(p++) = v ? WHITE : BLACK;
}
}
else
{
switch (mon_type)
{
case 0:
for (b = 0; b < 7; b++)
{
v = m_dhires_artifact_map[((((w >> (b + 7-1)) & 0x0F) * 0x11) >> (((2-(col*7+b))) & 0x03)) & 0x0F];
*(p++) = v;
}
break;
case 1:
w >>= 7;
for (b = 0; b < 7; b++)
{
v = (w & 1);
w >>= 1;
*(p++) = v ? WHITE : BLACK;
}
break;
case 2:
w >>= 7;
for (b = 0; b < 7; b++)
{
v = (w & 1);
w >>= 1;
*(p++) = v ? GREEN : BLACK;
}
break;
case 3:
w >>= 7;
for (b = 0; b < 7; b++)
{
v = (w & 1);
w >>= 1;
*(p++) = v ? ORANGE : BLACK;
}
break;
}
}
break;
default:
fatalerror("Invalid column count\n");
}
}
}
uint32_t thunderj_state::screen_update_thunderj(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
{
// start drawing
m_vad->mob().draw_async(cliprect);
/* draw the playfield */
bitmap_ind8 &priority_bitmap = screen.priority();
priority_bitmap.fill(0, cliprect);
m_vad->playfield().draw(screen, bitmap, cliprect, 0, 0x00);
m_vad->playfield().draw(screen, bitmap, cliprect, 1, 0x01);
m_vad->playfield().draw(screen, bitmap, cliprect, 2, 0x02);
m_vad->playfield().draw(screen, bitmap, cliprect, 3, 0x03);
m_vad->playfield2().draw(screen, bitmap, cliprect, 0, 0x80);
m_vad->playfield2().draw(screen, bitmap, cliprect, 1, 0x84);
m_vad->playfield2().draw(screen, bitmap, cliprect, 2, 0x88);
m_vad->playfield2().draw(screen, bitmap, cliprect, 3, 0x8c);
// draw and merge the MO
bitmap_ind16 &mobitmap = m_vad->mob().bitmap();
for (const sparse_dirty_rect *rect = m_vad->mob().first_dirty_rect(cliprect); rect != nullptr; rect = rect->next())
for (int y = rect->min_y; y <= rect->max_y; y++)
{
uint16_t *mo = &mobitmap.pix16(y);
uint16_t *pf = &bitmap.pix16(y);
uint8_t *pri = &priority_bitmap.pix8(y);
for (int x = rect->min_x; x <= rect->max_x; x++)
if (mo[x] != 0xffff)
{
/* verified from the GALs on the real PCB; equations follow
*
* --- PF/M is 1 if playfield has priority, or 0 if MOs have priority
* PF/M=MPX0*!MPX1*!MPX2*!MPX3*!MPX4*!MPX5*!MPX6*!MPX7
* +PFX3*PFX8*PFX9*!MPR0
* +PFX3*PFX8*!MPR0*!MPR1
* +PFX3*PFX9*!MPR1
*
* --- CS1 is 1 if the playfield should be displayed
* CS1=PF/M*!ALBG*!APIX0*!APIX1
* +!MPX0*!MPX1*!MPX2*!MPX3*!ALBG*!APIX0*!APIX1
*
* --- CS0 is 1 if the MOs should be displayed
* CS0=!PF/M*MPX0*!ALBG*!APIX0*!APIX1
* +!PF/M*MPX1*!ALBG*!APIX0*!APIX1
* +!PF/M*MPX2*!ALBG*!APIX0*!APIX1
* +!PF/M*MPX3*!ALBG*!APIX0*!APIX1
*
* --- CRA10 is the 0x200 bit of the color RAM index; set if pf is displayed
* CRA10:=CS1
*
* --- CRA9 is the 0x100 bit of the color RAM index; set if mo is displayed
* or if the playfield selected is playfield #2
* CRA9:=PFXS*CS1
* +!CS1*CS0
*
* --- CRA8-1 are the low 8 bits of the color RAM index; set as expected
* CRA8:=CS1*PFX7
* +!CS1*MPX7*CS0
* +!CS1*!CS0*ALC4
*
* CRA7:=CS1*PFX6
* +!CS1*MPX6*CS0
*
* CRA6:=CS1*PFX5
* +MPX5*!CS1*CS0
* +!CS1*!CS0*ALC3
*
* CRA5:=CS1*PFX4
* +MPX4*!CS1*CS0
* +!CS1*ALC2*!CS0
*
* CRA4:=CS1*PFX3
* +!CS1*MPX3*CS0
* +!CS1*!CS0*ALC1
*
* CRA3:=CS1*PFX2
* +MPX2*!CS1*CS0
* +!CS1*!CS0*ALC0
*
* CRA2:=CS1*PFX1
* +MPX1*!CS1*CS0
* +!CS1*!CS0*APIX1
*
* CRA1:=CS1*PFX0
* +MPX0*!CS1*CS0
* +!CS1*!CS0*APIX0
*/
int mopriority = mo[x] >> atari_motion_objects_device::PRIORITY_SHIFT;
int pfm = 0;
/* upper bit of MO priority signals special rendering and doesn't draw anything */
if (mopriority & 4)
continue;
/* determine pf/m signal */
if ((mo[x] & 0xff) == 1)
pfm = 1;
else if (pf[x] & 8)
{
int pfpriority = (pri[x] & 0x80) ? ((pri[x] >> 2) & 3) : (pri[x] & 3);
if (((pfpriority == 3) && !(mopriority & 1)) ||
((pfpriority & 1) && (mopriority == 0)) ||
((pfpriority & 2) && !(mopriority & 2)))
pfm = 1;
}
/* if pfm is low, we display the mo */
if (!pfm)
pf[x] = mo[x] & atari_motion_objects_device::DATA_MASK;
/* don't erase yet -- we need to make another pass later */
}
inline void apple2_state::apple2_plot_text_character(bitmap_ind16 &bitmap, int xpos, int ypos, int xscale, uint32_t code,
const uint8_t *textgfx_data, uint32_t textgfx_datalen, uint32_t my_a2)
{
int x, y, i;
int fg = m_fgcolor;
int bg = m_bgcolor;
const uint8_t *chardata;
uint16_t color;
if (m_sysconfig.found())
{
switch (m_sysconfig->read() & 0x03)
{
case 0:
break; // leave alone
case 1:
if ((m_machinetype == APPLE_II) || (m_machinetype == LABA2P) || (m_machinetype == SPACE84))
{
bg = WHITE;
}
else
{
fg = WHITE;
}
break;
case 2:
if ((m_machinetype == APPLE_II) || (m_machinetype == LABA2P) || (m_machinetype == SPACE84))
{
bg = GREEN;
}
else
{
fg = GREEN;
}
break;
case 3:
if ((m_machinetype == APPLE_II) || (m_machinetype == LABA2P) || (m_machinetype == SPACE84))
{
bg = ORANGE;
}
else
{
fg = ORANGE;
}
break;
}
}
if (my_a2 & VAR_ALTCHARSET)
{
/* we're using an alternate charset */
code |= m_alt_charset_value;
}
else if (m_flash && (code >= 0x40) && (code <= 0x7f))
{
/* we're flashing; swap */
i = fg;
fg = bg;
bg = i;
}
/* look up the character data */
chardata = &textgfx_data[(code * 8) % textgfx_datalen];
/* and finally, plot the character itself */
if ((m_machinetype == SPACE84) || (m_machinetype == LABA2P))
{
for (y = 0; y < 8; y++)
{
for (x = 0; x < 7; x++)
{
color = (chardata[y] & (1 << (6-x))) ? bg : fg;
for (i = 0; i < xscale; i++)
{
bitmap.pix16(ypos + y, xpos + (x * xscale) + i) = color;
}
}
}
}
else
{
for (y = 0; y < 8; y++)
{
for (x = 0; x < 7; x++)
{
color = (chardata[y] & (1 << x)) ? bg : fg;
for (i = 0; i < xscale; i++)
{
bitmap.pix16(ypos + y, xpos + (x * xscale) + i) = color;
}
}
}
}
}
void rm380z_state::putChar(int charnum,int attribs,int x,int y,bitmap_ind16 &bitmap,unsigned char* chsb,int vmode)
{
//bool attrDim=false;
bool attrRev=false;
bool attrUnder=false;
if (attribs&0x02) attrUnder=true;
//if (attribs&0x04) attrDim=true;
if (attribs&0x08) attrRev=true;
if ((charnum>0)&&(charnum<=0x7f))
{
// normal chars (base set)
if (vmode==RM380Z_VIDEOMODE_80COL)
{
int basex=RM380Z_CHDIMX*(charnum/RM380Z_NCY);
int basey=RM380Z_CHDIMY*(charnum%RM380Z_NCY);
for (int r=0;r<RM380Z_CHDIMY;r++)
{
for (int c=0;c<RM380Z_CHDIMX;c++)
{
UINT8 chval=(chsb[((basey+r)*(RM380Z_CHDIMX*RM380Z_NCX))+(basex+c)])==0xff?0:1;
if (attrRev)
{
if (chval==0) chval=1;
else chval=0;
}
if (attrUnder)
{
if (r==(RM380Z_CHDIMY-1))
{
if (attrRev) chval=0;
else chval=1;
}
}
UINT16 *dest=&bitmap.pix16((y*(RM380Z_CHDIMY+1))+r,(x*(RM380Z_CHDIMX+1))+c);
*dest=chval;
}
}
// last pixel of underline
if (attrUnder&&(!attrRev))
{
UINT16 *dest=&bitmap.pix16((y*(RM380Z_CHDIMY+1))+(RM380Z_CHDIMY-1),(x*(RM380Z_CHDIMX+1))+RM380Z_CHDIMX);
*dest=attrRev?0:1;
}
// if reversed, print another column of pixels on the right
if (attrRev)
{
for (int r=0;r<RM380Z_CHDIMY;r++)
{
UINT16 *dest=&bitmap.pix16((y*(RM380Z_CHDIMY+1))+r,(x*(RM380Z_CHDIMX+1))+RM380Z_CHDIMX);
*dest=1;
}
}
}
else if (vmode==RM380Z_VIDEOMODE_40COL)
{
int basex=RM380Z_CHDIMX*(charnum/RM380Z_NCY);
int basey=RM380Z_CHDIMY*(charnum%RM380Z_NCY);
for (int r=0;r<RM380Z_CHDIMY;r++)
{
for (int c=0;c<(RM380Z_CHDIMX*2);c+=2)
{
UINT8 chval=(chsb[((basey+r)*(RM380Z_CHDIMX*RM380Z_NCX))+(basex+(c/2))])==0xff?0:1;
if (attrRev)
{
if (chval==0) chval=1;
else chval=0;
}
if (attrUnder)
{
if (r==(RM380Z_CHDIMY-1))
{
if (attrRev) chval=0;
else chval=1;
}
}
UINT16 *dest=&bitmap.pix16( (y*(RM380Z_CHDIMY+1))+r,((x*(RM380Z_CHDIMX+1))*2)+c);
UINT16 *dest2=&bitmap.pix16( (y*(RM380Z_CHDIMY+1))+r,((x*(RM380Z_CHDIMX+1))*2)+c+1);
*dest=chval;
*dest2=chval;
}
}
// last 2 pixels of underline
if (attrUnder)
{
UINT16 *dest=&bitmap.pix16( (y*(RM380Z_CHDIMY+1))+RM380Z_CHDIMY-1 , ((x*(RM380Z_CHDIMX+1))*2)+(RM380Z_CHDIMX*2));
UINT16 *dest2=&bitmap.pix16( (y*(RM380Z_CHDIMY+1))+RM380Z_CHDIMY-1 , ((x*(RM380Z_CHDIMX+1))*2)+(RM380Z_CHDIMX*2)+1);
*dest=attrRev?0:1;
*dest2=attrRev?0:1;
}
// if reversed, print another 2 columns of pixels on the right
if (attrRev)
{
for (int r=0;r<RM380Z_CHDIMY;r++)
{
UINT16 *dest=&bitmap.pix16( (y*(RM380Z_CHDIMY+1))+r,((x*(RM380Z_CHDIMX+1))*2)+((RM380Z_CHDIMX)*2));
UINT16 *dest2=&bitmap.pix16( (y*(RM380Z_CHDIMY+1))+r,((x*(RM380Z_CHDIMX+1))*2)+((RM380Z_CHDIMX)*2)+1);
*dest=1;
*dest2=1;
}
}
}
}
else
{
// graphic chars: 0x80-0xbf is "dimmed", 0xc0-0xff is full bright
if (vmode==RM380Z_VIDEOMODE_80COL)
{
for (int r=0;r<(RM380Z_CHDIMY+1);r++)
{
for (int c=0;c<RM380Z_CHDIMX;c++)
{
UINT16 *dest=&bitmap.pix16((y*(RM380Z_CHDIMY+1))+r,(x*(RM380Z_CHDIMX+1))+c);
*dest=m_graphic_chars[charnum&0x3f][c+(r*(RM380Z_CHDIMX+1))];
}
}
}
else
{
for (int r=0;r<RM380Z_CHDIMY;r++)
{
for (int c=0;c<(RM380Z_CHDIMX*2);c+=2)
{
UINT16 *dest=&bitmap.pix16( (y*(RM380Z_CHDIMY+1))+r,((x*(RM380Z_CHDIMX+1))*2)+c);
UINT16 *dest2=&bitmap.pix16( (y*(RM380Z_CHDIMY+1))+r,((x*(RM380Z_CHDIMX+1))*2)+c+1);
*dest=m_graphic_chars[charnum&0x3f][(c/2)+(r*(RM380Z_CHDIMX+1))];
*dest2=m_graphic_chars[charnum&0x3f][(c/2)+(r*(RM380Z_CHDIMX+1))];
}
}
}
}
}
static void draw_sprites(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect, int priority)
{
wrally_state *state = machine.driver_data<wrally_state>();
int i, px, py;
const gfx_element *gfx = machine.gfx[0];
for (i = 6/2; i < (0x1000 - 6)/2; i += 4) {
int sx = state->m_spriteram[i+2] & 0x03ff;
int sy = (240 - (state->m_spriteram[i] & 0x00ff)) & 0x00ff;
int number = state->m_spriteram[i+3] & 0x3fff;
int color = (state->m_spriteram[i+2] & 0x7c00) >> 10;
int attr = (state->m_spriteram[i] & 0xfe00) >> 9;
int xflip = attr & 0x20;
int yflip = attr & 0x40;
int color_effect = (color & 0x10) >> 4;
int high_priority = number >= 0x3700;
color = color & 0x0f;
if (high_priority != priority) continue;
if (flip_screen_get(machine)) {
sy = sy + 248;
}
if (!color_effect) {
drawgfx_transpen(bitmap,cliprect,gfx,number,
0x20 + color,xflip,yflip,
sx - 0x0f,sy,0);
} else {
/* get a pointer to the current sprite's gfx data */
const UINT8 *gfx_src = gfx_element_get_data(gfx, number % gfx->total_elements);
for (py = 0; py < gfx->height; py++){
/* get a pointer to the current line in the screen bitmap */
int ypos = ((sy + py) & 0x1ff);
UINT16 *srcy = &bitmap.pix16(ypos);
int gfx_py = yflip ? (gfx->height - 1 - py) : py;
if ((ypos < cliprect.min_y) || (ypos > cliprect.max_y)) continue;
for (px = 0; px < gfx->width; px++){
/* get current pixel */
int xpos = (((sx + px) & 0x3ff) - 0x0f) & 0x3ff;
UINT16 *pixel = srcy + xpos;
int src_color = *pixel;
int gfx_px = xflip ? (gfx->width - 1 - px) : px;
/* get asociated pen for the current sprite pixel */
int gfx_pen = gfx_src[gfx->line_modulo*gfx_py + gfx_px];
/* pens 8..15 are used to select a palette */
if ((gfx_pen < 8) || (gfx_pen >= 16)) continue;
if ((xpos < cliprect.min_x) || (xpos > cliprect.max_x)) continue;
/* modify the color of the tile */
*pixel = src_color + (gfx_pen-8)*1024;
}
}
}
}
}
UINT32 namcos21_state::screen_update_namcos21(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
{
UINT8 *videoram = m_videoram;
int pivot = 3;
int pri;
update_palette(machine());
bitmap.fill(0xff, cliprect );
if( m_gametype != NAMCOS21_WINRUN91 )
{ /* draw low priority 2d sprites */
c355_obj_draw(screen, bitmap, cliprect, 2 );
c355_obj_draw(screen, bitmap, cliprect, 14 ); //driver's eyes
}
CopyVisiblePolyFrameBuffer( machine(), bitmap, cliprect, 0x7fc0, 0x7ffe );
if( m_gametype != NAMCOS21_WINRUN91 )
{ /* draw low priority 2d sprites */
c355_obj_draw(screen, bitmap, cliprect, 0 );
c355_obj_draw(screen, bitmap, cliprect, 1 );
}
CopyVisiblePolyFrameBuffer( machine(), bitmap, cliprect, 0, 0x7fbf );
if( m_gametype != NAMCOS21_WINRUN91 )
{ /* draw high priority 2d sprites */
for( pri=pivot; pri<8; pri++ )
{
c355_obj_draw(screen, bitmap, cliprect, pri );
}
c355_obj_draw(screen, bitmap, cliprect, 15 ); //driver's eyes
}
else
{ /* winrun bitmap layer */
int yscroll = -cliprect.min_y+(INT16)m_winrun_gpu_register[0x2/2];
int base = 0x1000+0x100*(m_winrun_color&0xf);
int sx,sy;
for( sy=cliprect.min_y; sy<=cliprect.max_y; sy++ )
{
const UINT8 *pSource = &videoram[((yscroll+sy)&0x3ff)*0x200];
UINT16 *pDest = &bitmap.pix16(sy);
for( sx=cliprect.min_x; sx<=cliprect.max_x; sx++ )
{
int pen = pSource[sx];
switch( pen )
{
case 0xff:
break;
case 0x00:
pDest[sx] = (pDest[sx]&0x1fff)+0x4000;
break;
case 0x01:
pDest[sx] = (pDest[sx]&0x1fff)+0x6000;
break;
default:
pDest[sx] = base|pen;
break;
}
}
}
} /* winrun bitmap layer */
return 0;
}
UINT32 gamepock_state::screen_update_gamepock(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
{
UINT8 ad;
int i,j;
/* Handle HD44102CH #0 */
ad = m_hd44102ch[0].start_page;
for ( i = 0; i < 4; i++ )
{
for ( j = 0; j < 50; j++ )
{
bitmap.pix16(i * 8 + 0, 49 - j ) = ( m_hd44102ch[0].ram[ad+j] & 0x01 ) ? 0 : 1;
bitmap.pix16(i * 8 + 1, 49 - j ) = ( m_hd44102ch[0].ram[ad+j] & 0x02 ) ? 0 : 1;
bitmap.pix16(i * 8 + 2, 49 - j ) = ( m_hd44102ch[0].ram[ad+j] & 0x04 ) ? 0 : 1;
bitmap.pix16(i * 8 + 3, 49 - j ) = ( m_hd44102ch[0].ram[ad+j] & 0x08 ) ? 0 : 1;
bitmap.pix16(i * 8 + 4, 49 - j ) = ( m_hd44102ch[0].ram[ad+j] & 0x10 ) ? 0 : 1;
bitmap.pix16(i * 8 + 5, 49 - j ) = ( m_hd44102ch[0].ram[ad+j] & 0x20 ) ? 0 : 1;
bitmap.pix16(i * 8 + 6, 49 - j ) = ( m_hd44102ch[0].ram[ad+j] & 0x40 ) ? 0 : 1;
bitmap.pix16(i * 8 + 7, 49 - j ) = ( m_hd44102ch[0].ram[ad+j] & 0x80 ) ? 0 : 1;
}
ad += 0x40;
}
/* Handle HD44102CH #1 */
ad = m_hd44102ch[1].start_page;
for ( i = 4; i < 8; i++ )
{
for ( j = 0; j < 50; j++ )
{
bitmap.pix16(i * 8 + 0, j ) = ( m_hd44102ch[1].ram[ad+j] & 0x01 ) ? 0 : 1;
bitmap.pix16(i * 8 + 1, j ) = ( m_hd44102ch[1].ram[ad+j] & 0x02 ) ? 0 : 1;
bitmap.pix16(i * 8 + 2, j ) = ( m_hd44102ch[1].ram[ad+j] & 0x04 ) ? 0 : 1;
bitmap.pix16(i * 8 + 3, j ) = ( m_hd44102ch[1].ram[ad+j] & 0x08 ) ? 0 : 1;
bitmap.pix16(i * 8 + 4, j ) = ( m_hd44102ch[1].ram[ad+j] & 0x10 ) ? 0 : 1;
bitmap.pix16(i * 8 + 5, j ) = ( m_hd44102ch[1].ram[ad+j] & 0x20 ) ? 0 : 1;
bitmap.pix16(i * 8 + 6, j ) = ( m_hd44102ch[1].ram[ad+j] & 0x40 ) ? 0 : 1;
bitmap.pix16(i * 8 + 7, j ) = ( m_hd44102ch[1].ram[ad+j] & 0x80 ) ? 0 : 1;
}
ad += 0x40;
}
/* Handle HD44102CH #2 */
ad = m_hd44102ch[2].start_page;
for ( i = 0; i < 4; i++ )
{
for ( j = 0; j < 25; j++ )
{
bitmap.pix16(i * 8 + 0, 50 + j ) = ( m_hd44102ch[2].ram[ad+j] & 0x01 ) ? 0 : 1;
bitmap.pix16(i * 8 + 1, 50 + j ) = ( m_hd44102ch[2].ram[ad+j] & 0x02 ) ? 0 : 1;
bitmap.pix16(i * 8 + 2, 50 + j ) = ( m_hd44102ch[2].ram[ad+j] & 0x04 ) ? 0 : 1;
bitmap.pix16(i * 8 + 3, 50 + j ) = ( m_hd44102ch[2].ram[ad+j] & 0x08 ) ? 0 : 1;
bitmap.pix16(i * 8 + 4, 50 + j ) = ( m_hd44102ch[2].ram[ad+j] & 0x10 ) ? 0 : 1;
bitmap.pix16(i * 8 + 5, 50 + j ) = ( m_hd44102ch[2].ram[ad+j] & 0x20 ) ? 0 : 1;
bitmap.pix16(i * 8 + 6, 50 + j ) = ( m_hd44102ch[2].ram[ad+j] & 0x40 ) ? 0 : 1;
bitmap.pix16(i * 8 + 7, 50 + j ) = ( m_hd44102ch[2].ram[ad+j] & 0x80 ) ? 0 : 1;
}
for ( j = 25; j < 50; j++ )
{
bitmap.pix16(32 + i * 8 + 0, 25 + j ) = ( m_hd44102ch[2].ram[ad+j] & 0x01 ) ? 0 : 1;
bitmap.pix16(32 + i * 8 + 1, 25 + j ) = ( m_hd44102ch[2].ram[ad+j] & 0x02 ) ? 0 : 1;
bitmap.pix16(32 + i * 8 + 2, 25 + j ) = ( m_hd44102ch[2].ram[ad+j] & 0x04 ) ? 0 : 1;
bitmap.pix16(32 + i * 8 + 3, 25 + j ) = ( m_hd44102ch[2].ram[ad+j] & 0x08 ) ? 0 : 1;
bitmap.pix16(32 + i * 8 + 4, 25 + j ) = ( m_hd44102ch[2].ram[ad+j] & 0x10 ) ? 0 : 1;
bitmap.pix16(32 + i * 8 + 5, 25 + j ) = ( m_hd44102ch[2].ram[ad+j] & 0x20 ) ? 0 : 1;
bitmap.pix16(32 + i * 8 + 6, 25 + j ) = ( m_hd44102ch[2].ram[ad+j] & 0x40 ) ? 0 : 1;
bitmap.pix16(32 + i * 8 + 7, 25 + j ) = ( m_hd44102ch[2].ram[ad+j] & 0x80 ) ? 0 : 1;
}
ad += 0x40;
}
return 0;
}
/*
* Sprite Format
* ------------------
*
* Word | Bit(s) | Use
* -----+-fedcba9876543210-+----------------
* 0 | --------xxxxxxxx | display y start
* 0 | xxxxxxxx-------- | display y end
* 2 | -------xxxxxxxxx | x position
* 2 | ------x--------- | unknown (used in logicpr2, maybe just a bug?)
* 2 | xxxxxx---------- | unused?
* 4 | ---------xxxxxxx | width
* 4 | --------x------- | is this flip y like in System 16?
* 4 | -------x-------- | flip x
* 4 | xxxxxxx--------- | unused?
* 6 | xxxxxxxxxxxxxxxx | ROM address low bits
* 8 | ----------xxxxxx | color
* 8 | --------xx------ | priority
* 8 | ---xxxxx-------- | ROM address high bits
* 8 | xxx------------- | unused? (extra address bits for larger ROMs?)
* a | ---------------- | zoomx like in System 16?
* c | ---------------- | zoomy like in System 16?
* e | ---------------- |
*/
void deniam_state::draw_sprites( screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect )
{
int offs;
uint8_t *gfx = memregion("gfx2")->base();
for (offs = m_spriteram.bytes() / 2 - 8; offs >= 0; offs -= 8)
{
int sx, starty, endy, x, y, start, color, width, flipx, primask;
uint8_t *rom = gfx;
sx = (m_spriteram[offs + 1] & 0x01ff) + 16 * 8 - 1;
if (sx >= 512) sx -= 512;
starty = m_spriteram[offs + 0] & 0xff;
endy = m_spriteram[offs + 0] >> 8;
width = m_spriteram[offs + 2] & 0x007f;
flipx = m_spriteram[offs + 2] & 0x0100;
if (flipx) sx++;
color = 0x40 + (m_spriteram[offs + 4] & 0x3f);
primask = 8;
switch (m_spriteram[offs + 4] & 0xc0)
{
case 0x00: primask |= 4 | 2 | 1; break; /* below everything */
case 0x40: primask |= 4 | 2; break; /* below fg and tx */
case 0x80: primask |= 4; break; /* below tx */
case 0xc0: break; /* above everything */
}
start = m_spriteram[offs + 3] + ((m_spriteram[offs + 4] & 0x1f00) << 8);
rom += 2 * start;
for (y = starty + 1; y <= endy; y++)
{
int drawing = 0;
int i = 0;
rom += 2 * width; /* note that the first line is skipped */
x = 0;
while (i < 512) /* safety check */
{
if (flipx)
{
if ((rom[i] & 0x0f) == 0x0f)
{
if (!drawing) drawing = 1;
else break;
}
else
{
if (rom[i] & 0x0f)
{
if (cliprect.contains(sx + x, y))
{
if ((screen.priority().pix8(y, sx + x) & primask) == 0)
bitmap.pix16(y, sx + x) = color * 16 + (rom[i] & 0x0f);
screen.priority().pix8(y, sx + x) = 8;
}
}
x++;
}
if ((rom[i] & 0xf0) == 0xf0)
{
if (!drawing) drawing = 1;
else break;
}
else
{
if (rom[i] & 0xf0)
{
if (cliprect.contains(sx + x, y))
{
if ((screen.priority().pix8(y, sx + x) & primask) == 0)
bitmap.pix16(y, sx + x) = color * 16+(rom[i] >> 4);
screen.priority().pix8(y, sx + x) = 8;
}
}
x++;
}
i--;
}
else
{
if ((rom[i] & 0xf0) == 0xf0)
{
if (!drawing) drawing = 1;
else break;
}
else
{
if (rom[i] & 0xf0)
{
if (cliprect.contains(sx + x, y))
{
if ((screen.priority().pix8(y, sx + x) & primask) == 0)
bitmap.pix16(y, sx + x) = color * 16 + (rom[i] >> 4);
screen.priority().pix8(y, sx + x) = 8;
}
}
x++;
}
if ((rom[i] & 0x0f) == 0x0f)
{
if (!drawing) drawing = 1;
else break;
}
else
{
if (rom[i] & 0x0f)
{
if (cliprect.contains(sx + x, y))
{
if ((screen.priority().pix8(y, sx + x) & primask) == 0)
bitmap.pix16(y, sx + x) = color * 16 + (rom[i] & 0x0f);
screen.priority().pix8(y, sx + x) = 8;
}
}
x++;
}
i++;
}
}
}
}
inline void x68k_state::x68k_plot_pixel(bitmap_ind16 &bitmap, int x, int y, UINT32 color)
{
bitmap.pix16(y, x) = (UINT16)color;
}
UINT32 binbug_state::screen_update(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
{
// attributes bit 0 = flash, bit 1 = lores. Also bit 7 of the character = reverse-video (text only).
UINT8 y,ra,chr,gfx,attr,inv,gfxbit;
UINT16 sy=0,ma=0,x;
bool flash;
m_framecnt++;
for (y = 0; y < 16; y++)
{
for (ra = 0; ra < 16; ra++)
{
UINT16 *p = &bitmap.pix16(sy++);
for (x = ma; x < ma + 64; x++)
{
attr = m_p_attribram[x];
chr = m_p_videoram[x];
flash = BIT(m_framecnt, 4) & BIT(attr, 0);
if (BIT(attr, 1)) // lores gfx - can flash
{
if (flash) chr = 0; // blank part of flashing
gfxbit = (ra & 0x0c)>>1;
/* Display one line of a lores character (8 pixels) */
*p++ = BIT(chr, gfxbit);
*p++ = BIT(chr, gfxbit);
*p++ = BIT(chr, gfxbit);
*p++ = BIT(chr, gfxbit);
gfxbit++;
*p++ = BIT(chr, gfxbit);
*p++ = BIT(chr, gfxbit);
*p++ = BIT(chr, gfxbit);
*p++ = BIT(chr, gfxbit);
}
else
{
gfx = 0;
if (!flash)
{
inv = BIT(chr, 7) ? 0xff : 0; // text with bit 7 high is reversed
chr &= 0x7f;
gfx = inv;
// if g,j,p,q,y; lower the descender
if ((chr==0x2c)||(chr==0x3b)||(chr==0x67)||(chr==0x6a)||(chr==0x70)||(chr==0x71)||(chr==0x79))
{
if (ra > 6)
gfx = m_p_chargen[(chr<<4) | (ra-7) ] ^ inv;
}
else
{
if ((ra > 3) & (ra < 13))
gfx = m_p_chargen[(chr<<4) | (ra-4) ] ^ inv;
}
}
/* Display a scanline of a character */
*p++ = BIT(gfx, 7);
*p++ = BIT(gfx, 6);
*p++ = BIT(gfx, 5);
*p++ = BIT(gfx, 4);
*p++ = BIT(gfx, 3);
*p++ = BIT(gfx, 2);
*p++ = BIT(gfx, 1);
*p++ = BIT(gfx, 0);
}
}
}
ma+=64;
}
inline void pcw_state::pcw_plot_pixel(bitmap_ind16 &bitmap, int x, int y, uint32_t color)
{
bitmap.pix16(y, x) = (uint16_t)color;
}
