INPUT_PORTS_END
/****************************************************\
* Video hardware *
\****************************************************/
void uzebox_state::line_update()
{
uint32_t cycles = (uint32_t)(m_maincpu->get_elapsed_cycles() - m_line_start_cycles) / 2;
rgb_t color = rgb_t(pal3bit(m_port_c >> 0), pal3bit(m_port_c >> 3), pal2bit(m_port_c >> 6));
for (uint32_t x = m_line_pos_cycles; x < cycles; x++)
{
if (m_bitmap.cliprect().contains(x, m_vpos))
m_bitmap.pix32(m_vpos, x) = color;
if (!INTERLACED)
if (m_bitmap.cliprect().contains(x, m_vpos + 1))
m_bitmap.pix32(m_vpos + 1, x) = color;
}
m_line_pos_cycles = cycles;
}
inline void deco_zoomspr_device::dragngun_drawgfxzoom(
bitmap_rgb32 &dest_bmp,const rectangle &clip,gfx_element *gfx,
UINT32 code,UINT32 color,int flipx,int flipy,int sx,int sy,
int transparent_color,
int scalex, int scaley,bitmap_ind8 *pri_buffer,UINT32 pri_mask, int sprite_screen_width, int sprite_screen_height, UINT8 alpha,
bitmap_ind8 &pri_bitmap, bitmap_rgb32 &temp_bitmap,
int priority)
{
rectangle myclip;
if (!scalex || !scaley) return;
/*
scalex and scaley are 16.16 fixed point numbers
1<<15 : shrink to 50%
1<<16 : uniform scale
1<<17 : double to 200%
*/
/* KW 991012 -- Added code to force clip to bitmap boundary */
myclip = clip;
myclip &= temp_bitmap.cliprect();
{
if( gfx )
{
const pen_t *pal = &m_palette->pen(gfx->colorbase() + gfx->granularity() * (color % gfx->colors()));
const UINT8 *code_base = gfx->get_data(code % gfx->elements());
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;
/* case 1: no alpha */
if (alpha == 0xff)
{
{
for( y=sy; y<ey; y++ )
{
const UINT8 *source = code_base + (y_index>>16) * gfx->rowbytes();
UINT32 *dest = &temp_bitmap.pix32(y);
UINT8 *pri = &pri_bitmap.pix8(y);
int x, x_index = x_index_base;
for( x=sx; x<ex; x++ )
{
int c = source[x_index>>16];
if (c != transparent_color)
{
if (priority >= pri[x])
{
dest[x] = pal[c];
dest[x] |= 0xff000000;
}
else // sprites can have a 'masking' effect on other sprites
{
dest[x] = 0x00000000;
}
}
x_index += dx;
}
y_index += dy;
}
}
}
/* alpha-blended */
else
{
{
for( y=sy; y<ey; y++ )
{
const UINT8 *source = code_base + (y_index>>16) * gfx->rowbytes();
UINT32 *dest = &temp_bitmap.pix32(y);
UINT8 *pri = &pri_bitmap.pix8(y);
UINT32 *tmapcolor = &dest_bmp.pix32(y);
int x, x_index = x_index_base;
for( x=sx; x<ex; x++ )
{
int c = source[x_index>>16];
if (c != transparent_color)
{
if (priority >= pri[x])
{
// this logic doesn't seem correct. Sprites CAN blend other sprites (needed in many places) but based on videos of the character select screen it appears that sprites can't blend already blended sprites
// I'm not sure which colour gets used but the video shows a single shade of yellow rather than the yellow blending the yellow)
if ((dest[x] & 0xff000000) == 0x00000000)
dest[x] = alpha_blend_r32(tmapcolor[x] & 0x00ffffff, pal[c] & 0x00ffffff, alpha); // if nothing has been drawn pull the pixel from the tilemap to blend with
else
dest[x] = alpha_blend_r32(dest[x] & 0x00ffffff, pal[c] & 0x00ffffff, alpha); // otherwise blend with what was previously drawn
dest[x] |= 0xff000000;
}
else // sprites can have a 'masking' effect on other sprites
{
dest[x] = 0x00000000;
}
}
x_index += dx;
}
y_index += dy;
}
}
}
}
void bt459_device::screen_update(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect, u8 *pixel_data)
{
// initialise the blink timer
if (m_blink_start > screen.frame_number())
m_blink_start = screen.frame_number();
// compute the blink state according to the programmed duty cycle
const bool blink_state = ((screen.frame_number() - m_blink_start) & (
(m_command_0 & CR0302) == CR0302_1616 ? 0x10 :
(m_command_0 & CR0302) == CR0302_3232 ? 0x20 :
(m_command_0 & CR0302) == CR0302_6464 ? 0x40 : 0x30)) == 0;
// compute the pixel mask from the pixel read mask and blink mask/state
const u8 pixel_mask = m_pixel_read_mask & (blink_state ? 0xffU : ~m_pixel_blink_mask);
// draw visible pixel data
switch (m_command_0 & CR0100)
{
case CR0100_1BPP:
for (int y = screen.visible_area().min_y; y <= screen.visible_area().max_y; y++)
for (int x = screen.visible_area().min_x; x <= screen.visible_area().max_x; x += 8)
{
u8 data = *pixel_data++;
bitmap.pix(y, x + 7) = get_rgb(data & 0x1, pixel_mask); data >>= 1;
bitmap.pix(y, x + 6) = get_rgb(data & 0x1, pixel_mask); data >>= 1;
bitmap.pix(y, x + 5) = get_rgb(data & 0x1, pixel_mask); data >>= 1;
bitmap.pix(y, x + 4) = get_rgb(data & 0x1, pixel_mask); data >>= 1;
bitmap.pix(y, x + 3) = get_rgb(data & 0x1, pixel_mask); data >>= 1;
bitmap.pix(y, x + 2) = get_rgb(data & 0x1, pixel_mask); data >>= 1;
bitmap.pix(y, x + 1) = get_rgb(data & 0x1, pixel_mask); data >>= 1;
bitmap.pix(y, x + 0) = get_rgb(data & 0x1, pixel_mask);
}
break;
case CR0100_2BPP:
for (int y = screen.visible_area().min_y; y <= screen.visible_area().max_y; y++)
for (int x = screen.visible_area().min_x; x <= screen.visible_area().max_x; x += 4)
{
u8 data = *pixel_data++;
bitmap.pix(y, x + 3) = get_rgb(data & 0x3, pixel_mask); data >>= 2;
bitmap.pix(y, x + 2) = get_rgb(data & 0x3, pixel_mask); data >>= 2;
bitmap.pix(y, x + 1) = get_rgb(data & 0x3, pixel_mask); data >>= 2;
bitmap.pix(y, x + 0) = get_rgb(data & 0x3, pixel_mask);
}
break;
case CR0100_4BPP:
for (int y = screen.visible_area().min_y; y <= screen.visible_area().max_y; y++)
for (int x = screen.visible_area().min_x; x <= screen.visible_area().max_x; x += 2)
{
u8 data = *pixel_data++;
bitmap.pix(y, x + 1) = get_rgb(data & 0x7, pixel_mask); data >>= 4;
bitmap.pix(y, x + 0) = get_rgb(data & 0x7, pixel_mask);
}
break;
case CR0100_8BPP:
for (int y = screen.visible_area().min_y; y <= screen.visible_area().max_y; y++)
for (int x = screen.visible_area().min_x; x <= screen.visible_area().max_x; x++)
bitmap.pix(y, x) = get_rgb(*pixel_data++, pixel_mask);
break;
}
// draw cursors when visible and not blinked off
if ((m_cursor_command & (CR47 | CR46 | CR45 | CR44)) && ((m_cursor_command & CR40) == 0 || blink_state))
{
// get 64x64 bitmap and cross hair cursor plane enable
const u8 bm_cursor_enable = (m_cursor_command & (CR47 | CR46)) >> 6;
const u8 ch_cursor_enable = (m_cursor_command & (CR45 | CR44)) >> 4;
// get cross hair cursor half thickness
const int ch_thickness = (m_cursor_command & CR4241) >> 1;
/*
* The cursor (x) value to be written is calculated as follows:
*
* Cx = desired display screen (x) position + H - P
*
* where
*
* P = 37 if 1:1 input multiplexing, 52 if 4:1 input multiplexing,
* 57 if 5:1 input multiplexing
* H = number of pixels between the first rising edge of LD*
* following the falling edge of HSYNC* to active video
*
* The cursor (y) value to be written is calculated as follows:
*
* Cy = desired display screen (y) position + V - 32
*
* where
*
* V = number of scan lines from the second sync pulse during
* vertical blanking to active video
*
* Values from $0FC0 (-64) to $0FBF (+4031) may be loaded into the
* cursor (y) register. The negative values ($0FC0 to $0FFF) are used
* in situations where V < 32, and the cursor must be moved off the
* top of the screen.
*/
const int cursor_x = m_cursor_x + (
(m_command_0 & CR0706) == CR0706_11MPX ? 37 :
(m_command_0 & CR0706) == CR0706_41MPX ? 52 :
(m_command_0 & CR0706) == CR0706_51MPX ? 57 : 0);
const int cursor_y = (m_cursor_y < 0xfc0 ? m_cursor_y : m_cursor_y - 0x1000) + 32;
// 64x64 bitmap cursor
if (bm_cursor_enable)
{
// compute target 64x64 rectangle
rectangle cursor(cursor_x - 31, cursor_x + 32, cursor_y - 31, cursor_y + 32);
// intersect with screen bitmap
cursor &= bitmap.cliprect();
// draw if any portion is visible
if (!cursor.empty())
{
for (int y = 0; y < 64; y++)
{
// get screen y pixel coordinate
const int ypos = cursor_y - 31 + y;
for (int x = 0; x < 64; x++)
{
// get screen x pixel coordinate
const int xpos = cursor_x - 31 + x;
// check if pixel is visible
if (cursor.contains(xpos, ypos))
{
// retrieve 2 bits of 64x64 bitmap cursor data
u8 data = (m_cursor_ram[y * 16 + (x >> 2)] >> ((3 - (x & 3)) << 1)) & bm_cursor_enable;
// check for dual-cursor mode and combine with cross-hair data
if (ch_cursor_enable)
if (((x >= 31 - ch_thickness) && (x <= 31 + ch_thickness)) || ((y >= 31 - ch_thickness) && (y <= 31 + ch_thickness)))
data = (m_cursor_command & CR43) ? data | ch_cursor_enable : data ^ ch_cursor_enable;
// write cursor data to screen (normal or X Window mode)
if (data && !((m_command_2 & CR21) && data == 1))
bitmap.pix(ypos, xpos) = m_cursor_color[data - 1];
}
}
}
}
}
// cross hair cursor
if (ch_cursor_enable)
{
// get the cross hair cursor color
const rgb_t ch_color = m_cursor_color[ch_cursor_enable - 1];
/*
* The window (x) value to be written is calculated as follows:
*
* Wx = desired display screen (x) position + H - P
*
* where
*
* P = 5 if 1:1 input multiplexing, 20 if 4:1 input multiplexing,
* 25 if 5:1 input multiplexing
* H = number of pixels between the first rising edge of LD*
* following the falling edge of HSYNC* to active video
*
* The window (y) value to be written is calculated as follows:
*
* Wy = desired display screen (y) position + V
*
* where
*
* V = number of scan lines from the second sync pulse during
* vertical blanking to active video
*
* Values from $0000 to $0FFF may be written to the window (x) and
* (y) registers. A full-screen cross hair is implemented by
* loading the window (x,y) registers with $0000, and the window
* width and height registers with $0FFF.
*/
const bool full_screen = (m_window_x == 0 && m_window_y == 0 && m_window_w == 0x0fff && m_window_h == 0x0fff);
const int window_x = full_screen ? screen.visible_area().min_x : m_window_x + (
(m_command_0 & CR0706) == CR0706_11MPX ? 5 :
(m_command_0 & CR0706) == CR0706_41MPX ? 20 :
(m_command_0 & CR0706) == CR0706_51MPX ? 25 : 0);
const int window_y = full_screen ? screen.visible_area().min_y : m_window_y;
/*
* The actual window width is 2, 8 or 10 pixels more than the
* value specified by the window width register, depending on
* whether 1:1, 4:1 or 5:1 input multiplexing is specified. The
* actual window height is 2 pixels more than the value specified
* by the window height register. Therefore, the minimum window
* width is 2, 8 or 10 pixels for 1:1, 4:1 and 5:1 multiplexing,
* respectively. The minimum window height is 2 pixels.
*
* Values from $0000 to $0FFF may be written to the window width
* and height registers.
*
* Note: testing indicates the cross-hair cursor should be drawn
* strictly inside the window, although this is not 100% clear from
* the documentation.
*/
const int window_w = full_screen ? screen.visible_area().width() : m_window_w + (
(m_command_0 & CR0706) == CR0706_11MPX ? 2 :
(m_command_0 & CR0706) == CR0706_41MPX ? 8 :
(m_command_0 & CR0706) == CR0706_51MPX ? 10 : 0);
const int window_h = full_screen ? screen.visible_area().height() : m_window_h + 2;
// check for dual-cursor mode
if (bm_cursor_enable)
{
// draw the cross hair cursor as vertical and horizontal filled rectangles broken by the 64x64 cursor area
rectangle v1(cursor_x - ch_thickness, cursor_x + ch_thickness, window_y + 1, cursor_y - 32);
rectangle v2(cursor_x - ch_thickness, cursor_x + ch_thickness, cursor_y + 33, window_y + window_h);
rectangle h1(window_x + 1, cursor_x - 32, cursor_y - ch_thickness, cursor_y + ch_thickness);
rectangle h2(cursor_x + 33, window_x + window_w, cursor_y - ch_thickness, cursor_y + ch_thickness);
v1 &= bitmap.cliprect();
v2 &= bitmap.cliprect();
h1 &= bitmap.cliprect();
h2 &= bitmap.cliprect();
if (!v1.empty())
bitmap.fill(ch_color, v1);
if (!v2.empty())
bitmap.fill(ch_color, v2);
if (!h1.empty())
bitmap.fill(ch_color, h1);
if (!h2.empty())
bitmap.fill(ch_color, h2);
}
else
{
// draw the cross hair cursor as unbroken vertical and horizontal filled rectangles
rectangle v(cursor_x - ch_thickness, cursor_x + ch_thickness, window_y + 1, window_y + window_h);
rectangle h(window_x + 1, window_x + window_w, cursor_y - ch_thickness, cursor_y + ch_thickness);
v &= bitmap.cliprect();
h &= bitmap.cliprect();
if (!v.empty())
bitmap.fill(ch_color, v);
if (!h.empty())
bitmap.fill(ch_color, h);
}
}
}
