void hnayayoi_state::draw_layer_interleaved( bitmap_ind16 &bitmap, const rectangle &cliprect, int left_pixmap, int right_pixmap, int palbase, int transp )
{
int county, countx, pen;
uint8_t *src1 = m_pixmap[left_pixmap];
uint8_t *src2 = m_pixmap[right_pixmap];
uint16_t *dstbase = &bitmap.pix16(0);
palbase *= 16;
for (county = 255; county >= 0; county--, dstbase += bitmap.rowpixels())
{
uint16_t *dst = dstbase;
if (transp)
{
for (countx = 255; countx >= 0; countx--, dst += 2)
{
pen = *(src1++);
if (pen) *dst = palbase + pen;
pen = *(src2++);
if (pen) *(dst + 1) = palbase + pen;
}
}
else
{
for (countx = 255; countx >= 0; countx--, dst += 2)
{
*dst = palbase + *(src1++);
*(dst + 1) = palbase + *(src2++);
}
}
}
}
UINT32 hitme_state::screen_update_hitme(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
{
/* the card width resistor comes from an input port, scaled to the range 0-25 kOhms */
double width_resist = ioport("WIDTH")->read() * 25000 / 100;
/* this triggers a oneshot for the following length of time */
double width_duration = 0.45 * 1000e-12 * width_resist;
/* the dot clock runs at the standard horizontal frequency * 320+16 clocks per scanline */
double dot_freq = 15750 * 336;
/* the number of pixels is the duration times the frequency */
int width_pixels = width_duration * dot_freq;
int x, y, xx, inv;
offs_t offs = 0;
/* start by drawing the tilemap */
m_tilemap->draw(screen, bitmap, cliprect, 0, 0);
/* now loop over and invert anything */
for (y = 0; y < 19; y++)
{
int dy = bitmap.rowpixels();
for (inv = x = 0; x < 40; x++, offs++)
{
/* if the high bit is set, reset the oneshot */
if (m_videoram[y * 40 + x] & 0x80)
inv = width_pixels;
/* invert pixels until we run out */
for (xx = 0; xx < 8 && inv; xx++, inv--)
{
UINT16 *dest = &bitmap.pix16(y * 10, x * 8 + xx);
dest[0 * dy] ^= 1;
dest[1 * dy] ^= 1;
dest[2 * dy] ^= 1;
dest[3 * dy] ^= 1;
dest[4 * dy] ^= 1;
dest[5 * dy] ^= 1;
dest[6 * dy] ^= 1;
dest[7 * dy] ^= 1;
dest[8 * dy] ^= 1;
dest[9 * dy] ^= 1;
}
}
}
return 0;
}
// modified from version in mame/video/k054338.cpp
void konmedal68k_state::fill_backcolor(bitmap_ind16 &bitmap, const rectangle &cliprect, int pen_idx, int mode)
{
if ((mode & 0x02) == 0) // solid fill
{
bitmap.fill(pen_idx, cliprect);
}
else
{
uint16_t *dst_ptr = &bitmap.pix16(cliprect.min_y);
int dst_pitch = bitmap.rowpixels();
if ((mode & 0x01) == 0) // vertical gradient fill
{
pen_idx += cliprect.min_y;
for(int y = cliprect.min_y; y <= cliprect.max_y; y++)
{
for(int x = cliprect.min_x; x <= cliprect.max_x; x++)
{
dst_ptr[x] = pen_idx;
}
pen_idx++;
dst_ptr += dst_pitch;
}
}
else // horizontal gradient fill
{
pen_idx += cliprect.min_x;
dst_ptr += cliprect.min_x;
for(int y = cliprect.min_y; y<= cliprect.max_y; y++)
{
for(int x = cliprect.min_x; x <= cliprect.max_x; x++)
{
dst_ptr[x] = pen_idx;
}
dst_ptr += dst_pitch;
}
}
}
}
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);
}
/* mix & blend the paletted 16-bit tile and sprite bitmaps into an RGB 32-bit bitmap */
static void blendbitmaps(running_machine &machine,
bitmap_rgb32 &dest,bitmap_ind16 &src1,bitmap_ind16 &src2,bitmap_ind16 &src3,
int sx,int sy,const rectangle &clip)
{
int ox;
int oy;
int ex;
int ey;
/* check bounds */
ox = sx;
oy = sy;
ex = sx + src1.width() - 1;
if (sx < 0) sx = 0;
if (sx < clip.min_x) sx = clip.min_x;
if (ex >= dest.width()) ex = dest.width() - 1;
if (ex > clip.max_x) ex = clip.max_x;
if (sx > ex) return;
ey = sy + src1.height() - 1;
if (sy < 0) sy = 0;
if (sy < clip.min_y) sy = clip.min_y;
if (ey >= dest.height()) ey = dest.height() - 1;
if (ey > clip.max_y) ey = clip.max_y;
if (sy > ey) return;
{
const pen_t *paldata = machine.pens;
UINT32 *end;
UINT16 *sd1 = &src1.pix16(0);
UINT16 *sd2 = &src2.pix16(0);
UINT16 *sd3 = &src3.pix16(0);
int sw = ex-sx+1; /* source width */
int sh = ey-sy+1; /* source height */
int sm = src1.rowpixels(); /* source modulo */
UINT32 *dd = &dest.pix32(sy, sx); /* dest data */
int dm = dest.rowpixels(); /* dest modulo */
sd1 += (sx-ox);
sd1 += sm * (sy-oy);
sd2 += (sx-ox);
sd2 += sm * (sy-oy);
sd3 += (sx-ox);
sd3 += sm * (sy-oy);
sm -= sw;
dm -= sw;
while (sh)
{
#define BLENDPIXEL(x) if (sd3[x]) { \
if (sd2[x]) { \
dd[x] = paldata[sd2[x] | 0x0400] + paldata[sd3[x]]; \
} else { \
dd[x] = paldata[sd1[x] | 0x0400] + paldata[sd3[x]]; \
} \
} else { \
if (sd2[x]) { \
if (sd2[x] & 0x0800) { \
dd[x] = paldata[sd1[x] | 0x0400] + paldata[sd2[x]]; \
} else { \
dd[x] = paldata[sd2[x]]; \
} \
} else { \
dd[x] = paldata[sd1[x]]; \
} \
}
end = dd + sw;
while (dd <= end - 8)
{
BLENDPIXEL(0);
BLENDPIXEL(1);
BLENDPIXEL(2);
BLENDPIXEL(3);
BLENDPIXEL(4);
BLENDPIXEL(5);
BLENDPIXEL(6);
BLENDPIXEL(7);
dd += 8;
sd1 += 8;
sd2 += 8;
sd3 += 8;
}
while (dd < end)
{
BLENDPIXEL(0);
dd++;
sd1++;
sd2++;
sd3++;
}
dd += dm;
sd1 += sm;
sd2 += sm;
sd3 += sm;
sh--;
#undef BLENDPIXEL
}
}
}
