static void draw_circle_line(running_machine &machine, bitmap_ind16 &bitmap, int x, int y, int l)
{
starshp1_state *state = machine.driver_data<starshp1_state>();
if (y >= 0 && y <= bitmap.height() - 1)
{
const UINT16* p = state->m_LSFR + (UINT16) (512 * y);
UINT16* pLine = &bitmap.pix16(y);
int h1 = x - 2 * l;
int h2 = x + 2 * l;
if (h1 < 0)
h1 = 0;
if (h2 > bitmap.width() - 1)
h2 = bitmap.width() - 1;
for (x = h1; x <= h2; x++)
if (state->m_circle_mod)
{
if (p[x] & 1)
pLine[x] = 0x11;
}
else
pLine[x] = 0x12;
}
}
static void draw_sprites(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect)
{
bagman_state *state = machine.driver_data<bagman_state>();
UINT8 *spriteram = state->m_spriteram;
int offs;
for (offs = state->m_spriteram_size - 4;offs >= 0;offs -= 4)
{
int sx,sy,flipx,flipy;
sx = spriteram[offs + 3];
sy = 255 - spriteram[offs + 2] - 16;
flipx = spriteram[offs] & 0x40;
flipy = spriteram[offs] & 0x80;
if (flip_screen_x_get(machine))
{
sx = bitmap.width() - sx - 15;
flipx = !flipx;
}
if (flip_screen_y_get(machine))
{
sy = bitmap.height() - sy - 15;
flipy = !flipy;
}
if (spriteram[offs + 2] && spriteram[offs + 3])
drawgfx_transpen(bitmap,
cliprect,machine.gfx[1],
(spriteram[offs] & 0x3f) + 2 * (spriteram[offs + 1] & 0x20),
spriteram[offs + 1] & 0x1f,
flipx,flipy,
sx,sy,0);
}
}
UINT32 psion_custom_lcdc::screen_update(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
{
assert(height*9 <= bitmap.height() && width*6 <= bitmap.width());
bitmap.fill(0, cliprect);
if (m_display_on)
for (int l=0; l<height; l++)
for (int i=0; i<width; i++)
{
static const UINT8 psion_display_layout[] =
{
0x00, 0x01, 0x02, 0x03, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
0x40, 0x41, 0x42, 0x43, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f,
0x04, 0x05, 0x06, 0x07, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27,
0x44, 0x45, 0x46, 0x47, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67
};
INT8 char_pos = psion_display_layout[l*width + i];
for (int y=0; y<8; y++)
for (int x=0; x<5; x++)
if (m_ddram[char_pos] <= 0x10)
{
//draw CGRAM characters
bitmap.pix16(l*9 + y, i*6 + x) = BIT(m_cgram[(m_ddram[char_pos]&0x07)*8+y], 4-x);
}
else
{
//draw CGROM characters
if (region()->bytes() <= 0x800)
{
bitmap.pix16(l*9 + y, i*6 + x) = BIT(region()->u8(m_ddram[char_pos]*8+y), 4-x);
}
else
{
if(m_ddram[char_pos] < 0xe0)
bitmap.pix16(l*9 + y, i*6 + x) = BIT(region()->u8(m_ddram[char_pos]*8+y), 4-x);
else
bitmap.pix16(l*9 + y, i*6 + x) = BIT(region()->u8(0x700+((m_ddram[char_pos]-0xe0)*11)+y), 4-x);
}
}
// if is the correct position draw cursor and blink
if (char_pos == m_cursor_pos)
{
//draw the cursor
if (m_cursor_on)
for (int x=0; x<5; x++)
bitmap.pix16(l*9 + 7, i * 6 + x) = 1;
if (!m_blink && m_blink_on)
for (int y=0; y<7; y++)
for (int x=0; x<5; x++)
bitmap.pix16(l*9 + y, i * 6 + x) = 1;
}
}
return 0;
}
static void draw_sprite_collision( running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect )
{
circus_state *state = machine.driver_data<circus_state>();
const gfx_element *sprite_gfx = machine.gfx[1];
const UINT8 *sprite_data = gfx_element_get_data(sprite_gfx, state->m_clown_z);
int sx, sy, dx, dy;
int pixel, collision = 0;
// draw sprite and check collision on a pixel basis
for (sy = 0; sy < 16; sy++)
{
dy = state->m_clown_x + sy-1;
if (dy>=0 && dy<bitmap.height())
{
for (sx = 0; sx < 16; sx++)
{
dx = state->m_clown_y + sx;
if (dx>=0 && dx<bitmap.width())
{
pixel = sprite_data[sy * sprite_gfx->line_modulo + sx];
if (pixel)
{
collision |= bitmap.pix16(dy, dx);
bitmap.pix16(dy, dx) = machine.pens[pixel];
}
}
}
}
}
if (collision)
device_set_input_line(state->m_maincpu, 0, ASSERT_LINE);
}
INLINE void draw_pixel(bitmap_ind16 &bitmap,const rectangle &cliprect,int x,int y,int color,int flip)
{
if (flip)
{
x = bitmap.width() - x - 1;
y = bitmap.height() - y - 1;
}
if (cliprect.contains(x, y))
bitmap.pix16(y, x) = color;
}
bool video_assert_out_of_range_pixels(running_machine &machine, bitmap_ind16 &bitmap)
{
#ifdef MAME_DEBUG
// iterate over rows
int maxindex = palette_get_max_index(machine.palette);
for (int y = 0; y < bitmap.height(); y++)
{
UINT16 *rowbase = &bitmap.pix16(y);
for (int x = 0; x < bitmap.width(); x++)
if (rowbase[x] > maxindex)
{
osd_break_into_debugger("Out of range pixel");
return true;
}
}
#endif
return false;
}
static void draw_starfield(starshp1_state *state, bitmap_ind16 &bitmap)
{
/*
* The LSFR is reset once per frame at the position of
* sprite 15. This behavior is quite pointless and not
* really needed by the game. Not emulated.
*/
int x;
int y;
for (y = 0; y < bitmap.height(); y++)
{
const UINT16* p = state->m_LSFR + (UINT16) (512 * y);
UINT16* pLine = &bitmap.pix16(y);
for (x = 0; x < bitmap.width(); x++)
if ((p[x] & 0x5b56) == 0x5b44)
pLine[x] = (p[x] & 0x0400) ? 0x0e : 0x0f;
}
}
UINT32 hd44780_device::screen_update(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
{
assert(height*9 <= bitmap.height() && width*6 <= bitmap.width());
bitmap.fill(0, cliprect);
if (m_display_on)
for (int l=0; l<height; l++)
for (int i=0; i<width; i++)
{
UINT8 line_base = l * 0x40;
UINT8 line_size = (m_num_line) ? 40 : 80;
INT8 char_pos = line_base + i;
char_pos += m_disp_shift;
while (char_pos < 0 || (char_pos - line_base) >= line_size)
{
if (char_pos < 0)
char_pos += line_size;
else if (char_pos - line_base >= line_size)
char_pos -= line_size;
}
for (int y=0; y<8; y++)
for (int x=0; x<5; x++)
if (m_ddram[char_pos] <= 0x10)
{
//draw CGRAM characters
pixel_update(bitmap, l, i, y, x, BIT(m_cgram[(m_ddram[char_pos]&0x07)*8+y], 4-x));
}
else
{
//draw CGROM characters
if (region()->bytes() <= 0x800)
{
pixel_update(bitmap, l, i, y, x, BIT(region()->u8(m_ddram[char_pos]*8+y), 4-x));
}
else
{
if(m_ddram[char_pos] < 0xe0)
pixel_update(bitmap, l, i, y, x, BIT(region()->u8(m_ddram[char_pos]*8+y), 4-x));
else
pixel_update(bitmap, l, i, y, x, BIT(region()->u8(0x700+((m_ddram[char_pos]-0xe0)*11)+y), 4-x));
}
}
// if is the correct position draw cursor and blink
if (char_pos == m_cursor_pos)
{
//draw the cursor
if (m_cursor_on)
for (int x=0; x<5; x++)
pixel_update(bitmap, l, i, 7, x, 1);
if (!m_blink && m_blink_on)
for (int y=0; y<7; y++)
for (int x=0; x<5; x++)
pixel_update(bitmap, l, i, y, x, 1);
}
}
return 0;
}
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
}
}
}
