Sprinter/mame
2
0
Fork 0
mirror of https://github.com/holub/mame synced 2025-04-25 09:50:04 +03:00
Code Issues Actions 1 Packages Projects Releases Wiki Activity

this was an Allman file (nw)

Browse Source
This commit is contained in:
Vas Crabb 2018-08-13 15:06:14 +10:00
parent 85fcb47e79
commit 58b1bfebf4
2 changed files with 288 additions and 266 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

513
src/devices/video/hp1ll3.cpp
View File

@ -213,7 +213,7 @@ void hp1ll3_device::device_start()
m_videoram = std::make_unique<uint16_t[]>(HPGPU_VRAM_SIZE);
save_pointer(NAME(m_videoram) , HPGPU_VRAM_SIZE);
save_pointer(NAME(m_videoram), HPGPU_VRAM_SIZE);
m_ram_addr_mask = 0x3fff;
m_horiz_pix_total = visarea.max_x + 1;
m_vert_pix_total = visarea.max_y + 1;
@ -226,9 +226,9 @@ void hp1ll3_device::device_reset()
m_enable_video = m_enable_cursor = m_enable_sprite = m_busy = false;
}
uint16_t hp1ll3_device::get_pix_addr(uint16_t x , uint16_t y) const
uint16_t hp1ll3_device::get_pix_addr(uint16_t x, uint16_t y) const
{
return m_org + y * m_conf[ CONF_WPL ] + x / WS;
return m_org + y * m_conf[CONF_WPL] + x / WS;
}
inline void hp1ll3_device::point(int x, int y, bool pix, const uint16_t masks[])
@ -250,25 +250,25 @@ void hp1ll3_device::line(int x1, int y1, int x2, int y2)
int diago,horiz;
unsigned char c1;
uint16_t rop_masks[ 4 ];
uint16_t rop_masks[4];
get_rop_masks(m_rr, rop_masks);
uint16_t udl_scan = MSB_MASK;
c1=0;
incy=1;
c1 = 0;
incy = 1;
if(x2>x1)
if (x2 > x1)
dx = x2 - x1;
else
dx = x1 - x2;
if(y2>y1)
if (y2 > y1)
dy = y2 - y1;
else
dy = y1 - y2;
if( dy > dx )
if (dy > dx)
{
t = y2;
y2 = x2;
@ -285,7 +285,7 @@ void hp1ll3_device::line(int x1, int y1, int x2, int y2)
c1 = 1;
}
if( x1 > x2 )
if (x1 > x2)
{
t = y2;
y2 = y1;
@ -296,11 +296,11 @@ void hp1ll3_device::line(int x1, int y1, int x2, int y2)
x2 = t;
}
horiz = dy<<1;
diago = ( dy - dx )<<1;
e = ( dy<<1 ) - dx;
horiz = dy << 1;
diago = (dy - dx) << 1;
e = (dy << 1) - dx;
if( y1 <= y2 )
if (y1 <= y2)
incy = 1;
else
incy = -1;
@ -308,17 +308,16 @@ void hp1ll3_device::line(int x1, int y1, int x2, int y2)
x = x1;
y = y1;
if(c1)
if (c1)
{
do
{
point(y,x,m_udl & udl_scan,rop_masks);
point(y, x, m_udl & udl_scan,rop_masks);
udl_scan >>= 1;
if (!udl_scan) {
if (!udl_scan)
udl_scan = MSB_MASK;
}
if( e > 0 )
if (e > 0)
{
y = y + incy;
e = e + diago;
@ -330,19 +329,19 @@ void hp1ll3_device::line(int x1, int y1, int x2, int y2)
x++;
} while( x <= x2 );
} while (x <= x2);
}
else
{
do
{
point(x,y,m_udl & udl_scan,rop_masks);
point(x, y, m_udl & udl_scan,rop_masks);
udl_scan >>= 1;
if (!udl_scan) {
udl_scan = MSB_MASK;
}
if( e > 0 )
if (e > 0)
{
y = y + incy;
e = e + diago;
@ -354,10 +353,8 @@ void hp1ll3_device::line(int x1, int y1, int x2, int y2)
x++;
} while( x <= x2 );
} while (x <= x2);
}
return;
}
void hp1ll3_device::label(uint8_t chr, int width)
@ -365,31 +362,31 @@ void hp1ll3_device::label(uint8_t chr, int width)
draw_cursor_sprite();
Rectangle clip = get_window();
Rectangle dst{{ m_cursor_x , m_cursor_y } , { uint16_t(width) , m_fontheight }};
bitblt(m_fontdata + chr * 16 , 16 , 16 , Point { 0 , 0 } , clip , dst , m_rr);
Rectangle dst{{ m_cursor_x, m_cursor_y }, { uint16_t(width), m_fontheight }};
bitblt(m_fontdata + chr * 16, 16, 16, Point { 0, 0 }, clip, dst, m_rr);
m_cursor_x += width;
draw_cursor_sprite();
}
void hp1ll3_device::wr_video(uint16_t addr , uint16_t v)
void hp1ll3_device::wr_video(uint16_t addr, uint16_t v)
{
m_videoram[ addr & m_ram_addr_mask ] = v;
m_videoram[addr & m_ram_addr_mask] = v;
}
uint16_t hp1ll3_device::rd_video(uint16_t addr) const
{
return m_videoram[ addr & m_ram_addr_mask ];
return m_videoram[addr & m_ram_addr_mask];
}
void hp1ll3_device::get_rop_masks(uint16_t rop , uint16_t masks[])
void hp1ll3_device::get_rop_masks(uint16_t rop, uint16_t masks[])
{
masks[ 0 ] = BIT(rop , 0) ? ~0 : 0;
masks[ 1 ] = BIT(rop , 1) ? ~0 : 0;
masks[ 2 ] = BIT(rop , 2) ? ~0 : 0;
masks[ 3 ] = BIT(rop , 3) ? ~0 : 0;
masks[0] = BIT(rop, 0) ? ~0 : 0;
masks[1] = BIT(rop, 1) ? ~0 : 0;
masks[2] = BIT(rop, 2) ? ~0 : 0;
masks[3] = BIT(rop, 3) ? ~0 : 0;
}
uint16_t hp1ll3_device::apply_rop(uint16_t old_pix , uint16_t new_pix , uint16_t glob_mask , const uint16_t masks[])
uint16_t hp1ll3_device::apply_rop(uint16_t old_pix, uint16_t new_pix, uint16_t glob_mask, const uint16_t masks[])
{
uint16_t diff0 = old_pix & new_pix;
uint16_t diff1 = ~old_pix & new_pix;
@ -399,49 +396,49 @@ uint16_t hp1ll3_device::apply_rop(uint16_t old_pix , uint16_t new_pix , uint16_t
// The idea here is that ROP is forced to be "RR_OLD" for all zero bits in glob_mask
// so that the corresponding bits in new_pix are ignored
return
((masks[ 0 ] | ~glob_mask) & diff0) |
(masks[ 1 ] & glob_mask & diff1) |
((masks[ 2 ] | ~glob_mask) & diff2) |
(masks[ 3 ] & glob_mask & diff3);
((masks[0] | ~glob_mask) & diff0) |
(masks[1] & glob_mask & diff1) |
((masks[2] | ~glob_mask) & diff2) |
(masks[3] & glob_mask & diff3);
}
void hp1ll3_device::rmw_rop(uint16_t addr , uint16_t new_pix , uint16_t glob_mask , const uint16_t masks[])
void hp1ll3_device::rmw_rop(uint16_t addr, uint16_t new_pix, uint16_t glob_mask, const uint16_t masks[])
{
wr_video(addr , apply_rop(rd_video(addr), new_pix, glob_mask, masks));
wr_video(addr, apply_rop(rd_video(addr), new_pix, glob_mask, masks));
}
void hp1ll3_device::clip_coord(int size_1 , int& p1 , int origin_clip , int size_clip , int& origin_2 , int& size_2) const
void hp1ll3_device::clip_coord(int size_1, int &p1, int origin_clip, int size_clip, int &origin_2, int &size_2) const
{
// origin_1 is implicitly 0
int corner_2 = origin_2 + size_2;
// Clip origin_2 & p1 w.r.t. clip rectangle
int t = origin_2 - origin_clip;
if (t < 0) {
if (t < 0)
{
p1 -= t;
origin_2 = origin_clip;
}
// Clip size_2 w.r.t. clip rectangle
int corner_clip = origin_clip + size_clip;
if (corner_2 > corner_clip) {
if (corner_2 > corner_clip)
size_2 = corner_clip - origin_2;
}
// Clip size_2 w.r.t. rectangle 1 (whose origin is 0,0)
t = p1 + size_2 - size_1;
if (t > 0) {
if (t > 0)
size_2 -= t;
}
}
bool hp1ll3_device::bitblt(uint16_t src_base_addr , unsigned src_width , unsigned src_height , Point src_p ,
const Rectangle& clip_rect , const Rectangle& dst_rect , uint16_t rop , bool use_m_org)
bool hp1ll3_device::bitblt(uint16_t src_base_addr, unsigned src_width, unsigned src_height, Point src_p,
const Rectangle &clip_rect, const Rectangle &dst_rect, uint16_t rop, bool use_m_org)
{
DBG_LOG(3,0,("bitblt %04x,%u,%u,(%u,%u),(%u,%u,%u,%u),(%u,%u,%u,%u),%u\n" , src_base_addr ,
src_width ,
src_height ,
src_p.x ,
src_p.y ,
clip_rect.origin.x , clip_rect.origin.y , clip_rect.size.x , clip_rect.size.y ,
dst_rect.origin.x , dst_rect.origin.y , dst_rect.size.x , dst_rect.size.y ,
DBG_LOG(3,0,("bitblt %04x,%u,%u,(%u,%u),(%u,%u,%u,%u),(%u,%u,%u,%u),%u\n", src_base_addr,
src_width,
src_height,
src_p.x,
src_p.y,
clip_rect.origin.x, clip_rect.origin.y, clip_rect.size.x, clip_rect.size.y,
dst_rect.origin.x, dst_rect.origin.y, dst_rect.size.x, dst_rect.size.y,
rop));
int src_x = src_p.x;
int dst_x = dst_rect.origin.x;
@ -454,37 +451,39 @@ bool hp1ll3_device::bitblt(uint16_t src_base_addr , unsigned src_width , unsigne
// Clip y-coordinates
clip_coord(src_height, src_y, clip_rect.origin.y, clip_rect.size.y, dst_y, dst_height);
DBG_LOG(3,0,("bitblt (%u,%u) (%u,%u,%u,%u)\n" , src_x , src_y ,
dst_x , dst_y , dst_width , dst_height));
if (dst_width <= 0 || dst_height <= 0) {
DBG_LOG(3,0,("bitblt (%u,%u) (%u,%u,%u,%u)\n", src_x, src_y, dst_x, dst_y, dst_width, dst_height));
if (dst_width <= 0 || dst_height <= 0)
return false;
}
unsigned dst_rounded_width = m_conf[ CONF_WPL ] * WS;
unsigned dst_rounded_width = m_conf[CONF_WPL] * WS;
// p1_pix & p2_pix point to a uniquely identified pixel in video RAM
unsigned p1_pix = unsigned(src_base_addr) * WS + src_x + src_width * src_y;
unsigned p2_pix = unsigned(use_m_org ? m_org : m_sad) * WS + dst_x + dst_rounded_width * dst_y;
DBG_LOG(3,0,("bitblt p1_pix=%u p2_pix=%u\n" , p1_pix , p2_pix));
uint16_t rop_masks[ 4 ];
DBG_LOG(3,0,("bitblt p1_pix=%u p2_pix=%u\n", p1_pix, p2_pix));
uint16_t rop_masks[4];
get_rop_masks(rop, rop_masks);
if (p1_pix < p2_pix) {
if (p1_pix < p2_pix)
{
// Move block going up (decrease y)
p1_pix += dst_height * src_width + dst_width - 1;
p2_pix += dst_height * dst_rounded_width + dst_width - 1;
DBG_LOG(3,0,("bitblt rev p1_pix=%u p2_pix=%u\n" , p1_pix , p2_pix));
DBG_LOG(3,0,("bitblt rev p1_pix=%u p2_pix=%u\n", p1_pix, p2_pix));
while (dst_height--) {
p1_pix -= src_width;
p2_pix -= dst_rounded_width;
rowbltneg(p1_pix , p2_pix , dst_width , rop_masks);
rowbltneg(p1_pix, p2_pix, dst_width, rop_masks);
}
} else {
}
else
{
// Move block going down (increase y)
DBG_LOG(3,0,("bitblt fwd\n"));
while (dst_height--) {
rowbltpos(p1_pix , p2_pix , dst_width , rop_masks);
while (dst_height--)
{
rowbltpos(p1_pix, p2_pix, dst_width, rop_masks);
p1_pix += src_width;
p2_pix += dst_rounded_width;
}
@ -493,33 +492,36 @@ bool hp1ll3_device::bitblt(uint16_t src_base_addr , unsigned src_width , unsigne
return true;
}
void hp1ll3_device::rowbltpos(unsigned p1_pix , unsigned p2_pix , int width , const uint16_t masks[])
void hp1ll3_device::rowbltpos(unsigned p1_pix, unsigned p2_pix, int width, const uint16_t masks[])
{
// p1_pix and p2_pix point to the leftmost pixel of the row
while (width > 0) {
while (width > 0)
{
unsigned p1_word = p1_pix / WS;
unsigned p1_bit = p1_pix % WS;
// Get src pixels and align to MSB
uint16_t new_pix = rd_video(p1_word) << p1_bit;
if (p1_bit) {
if (p1_bit)
new_pix |= rd_video(p1_word + 1) >> (WS - p1_bit);
}
unsigned p2_word = p2_pix / WS;
unsigned p2_bit = p2_pix % WS;
uint16_t old_pix = rd_video(p2_word);
unsigned w = p2_bit + width;
uint16_t glob_mask = ~0;
if (p2_bit) {
if (p2_bit)
{
// Left end
new_pix >>= p2_bit;
glob_mask >>= p2_bit;
}
if (w < WS) {
if (w < WS)
{
// Right end
glob_mask &= ~0 << (WS - w);
}
rmw_rop(p2_word, new_pix, glob_mask, masks);
DBG_LOG(3,0,("rowbltpos %04x %04x %04x>%04x %u %u %u\n" , old_pix , new_pix , glob_mask , rd_video(p2_word) , p1_pix , p2_pix , width));
DBG_LOG(3,0,("rowbltpos %04x %04x %04x>%04x %u %u %u\n", old_pix, new_pix, glob_mask, rd_video(p2_word), p1_pix, p2_pix, width));
w = WS - p2_bit;
p1_pix += w;
p2_pix += w;
@ -527,10 +529,11 @@ void hp1ll3_device::rowbltpos(unsigned p1_pix , unsigned p2_pix , int width , co
}
}
void hp1ll3_device::rowbltneg(unsigned p1_pix , unsigned p2_pix , int width , const uint16_t masks[])
void hp1ll3_device::rowbltneg(unsigned p1_pix, unsigned p2_pix, int width, const uint16_t masks[])
{
// p1_pix and p2_pix point to the rightmost pixel of the row
while (width > 0) {
while (width > 0)
{
unsigned p1_word = p1_pix / WS;
unsigned p1_bit = p1_pix % WS;
// Get src pixels and align to LSB
@ -543,18 +546,20 @@ void hp1ll3_device::rowbltneg(unsigned p1_pix , unsigned p2_pix , int width , co
uint16_t old_pix = rd_video(p2_word);
int w = p2_bit - width;
uint16_t glob_mask = ~0;
if (p2_bit != (WS - 1)) {
if (p2_bit != (WS - 1))
{
// Right end
new_pix <<= (WS - 1 - p2_bit);
glob_mask <<= (WS - 1 - p2_bit);
}
if (w >= 0) {
if (w >= 0)
{
// Left end
uint16_t tmp = ~0;
glob_mask &= tmp >> (w + 1);
}
rmw_rop(p2_word, new_pix, glob_mask, masks);
DBG_LOG(3,0,("rowbltneg %04x %04x %04x>%04x %u %u %u\n" , old_pix , new_pix , glob_mask , rd_video(p2_word) , p1_pix , p2_pix , width));
DBG_LOG(3,0,("rowbltneg %04x %04x %04x>%04x %u %u %u\n", old_pix, new_pix, glob_mask, rd_video(p2_word), p1_pix, p2_pix, width));
w = p2_bit + 1;
p1_pix -= w;
p2_pix -= w;
@ -562,17 +567,18 @@ void hp1ll3_device::rowbltneg(unsigned p1_pix , unsigned p2_pix , int width , co
}
}
void hp1ll3_device::fill(const Rectangle& fill_rect , uint16_t pattern_no)
void hp1ll3_device::fill(const Rectangle &fill_rect, uint16_t pattern_no)
{
uint16_t pattern_addr = get_pattern_addr(pattern_no);
Point src_p{ 0 , 0 };
Point src_p{ 0, 0 };
// Align to 16x16 tiles in absolute coordinates
uint16_t start_x = fill_rect.origin.x & ~0xf;
Rectangle dst_rect{{ start_x , uint16_t(fill_rect.origin.y & ~0xf) } , { 16 , 16 }};
Rectangle dst_rect{{ start_x, uint16_t(fill_rect.origin.y & ~0xf) }, { 16, 16 }};
// Iterate over vertical span
while (bitblt(pattern_addr, 16, 16, src_p, fill_rect, dst_rect, m_rr)) {
while (bitblt(pattern_addr, 16, 16, src_p, fill_rect, dst_rect, m_rr))
{
// Iterate over horizontal span
do {
dst_rect.origin.x += 16;
@ -589,17 +595,19 @@ uint16_t hp1ll3_device::get_pattern_addr(uint16_t pattern_no) const
void hp1ll3_device::draw_cursor()
{
if (m_enable_cursor) {
Rectangle dst{{ uint16_t(m_cursor_x + m_cursor_offset) , m_cursor_y } , { 16 , 16 }};
bitblt(get_pattern_addr(m_cursor_pattern), 16, 16, Point{ 0 , 0 }, get_screen(), dst, RR_XOR , false);
if (m_enable_cursor)
{
Rectangle dst{{ uint16_t(m_cursor_x + m_cursor_offset), m_cursor_y }, { 16, 16 }};
bitblt(get_pattern_addr(m_cursor_pattern), 16, 16, Point{ 0, 0 }, get_screen(), dst, RR_XOR, false);
}
}
void hp1ll3_device::draw_sprite()
{
if (m_enable_sprite) {
Rectangle dst{{ m_sprite_x , m_sprite_y } , { 16 , 16 }};
bitblt(get_pattern_addr(m_sprite_pattern), 16, 16, Point{ 0 , 0 }, get_screen(), dst, RR_XOR , false);
if (m_enable_sprite)
{
Rectangle dst{{ m_sprite_x, m_sprite_y }, { 16, 16 }};
bitblt(get_pattern_addr(m_sprite_pattern), 16, 16, Point{ 0, 0 }, get_screen(), dst, RR_XOR, false);
}
}
@ -611,7 +619,8 @@ void hp1ll3_device::draw_cursor_sprite()
void hp1ll3_device::set_pen_pos(Point p)
{
if (p.x != m_cursor_x || p.y != m_cursor_y) {
if (p.x != m_cursor_x || p.y != m_cursor_y)
{
draw_cursor();
m_cursor_x = p.x;
m_cursor_y = p.y;
@ -621,7 +630,8 @@ void hp1ll3_device::set_pen_pos(Point p)
void hp1ll3_device::set_sprite_pos(Point p)
{
if (p.x != m_sprite_x || p.y != m_sprite_y) {
if (p.x != m_sprite_x || p.y != m_sprite_y)
{
draw_sprite();
m_sprite_x = p.x;
m_sprite_y = p.y;
@ -631,12 +641,12 @@ void hp1ll3_device::set_sprite_pos(Point p)
hp1ll3_device::Rectangle hp1ll3_device::get_window() const
{
return Rectangle{{ m_window.org_x , m_window.org_y } , { m_window.width , m_window.height }};
return Rectangle{{ m_window.org_x, m_window.org_y }, { m_window.width, m_window.height }};
}
hp1ll3_device::Rectangle hp1ll3_device::get_screen() const
{
return Rectangle{{ 0 , 0 } , { uint16_t(m_horiz_pix_total) , uint16_t(m_vert_pix_total) }};
return Rectangle{{ 0, 0 }, { uint16_t(m_horiz_pix_total), uint16_t(m_vert_pix_total) }};
}
void hp1ll3_device::apply_conf()
@ -646,22 +656,21 @@ void hp1ll3_device::apply_conf()
uint32_t hp1ll3_device::screen_update(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
{
int x, y, offset;
uint16_t gfx, *p;
if (!m_enable_video) {
if (!m_enable_video)
{
bitmap.fill(rgb_t::black());
return 0;
}
// XXX last line is not actually drawn on real hw
for (y = 0; y < m_vert_pix_total; y++) {
offset = m_sad + y*(m_horiz_pix_total/16);
p = &m_bitmap.pix16(y);
for (int y = 0; y < m_vert_pix_total; y++)
{
int const offset = m_sad + y * (m_horiz_pix_total / 16);
uint16_t *p = &m_bitmap.pix16(y);
for (x = offset; x < offset + m_horiz_pix_total/16; x++)
for (int x = offset; x < offset + m_horiz_pix_total / 16; x++)
{
gfx = m_videoram[x];
uint16_t const gfx = m_videoram[x];
*p++ = BIT(gfx, 15);
*p++ = BIT(gfx, 14);
@ -706,70 +715,77 @@ READ8_MEMBER( hp1ll3_device::read )
{
uint8_t data = 0;
if (offset == 0) {
if (offset == 0)
{
data = m_busy ? 1 : 0;
data |= 2;
data |= (screen().vblank() ? 8 : 0);
} else {
if ((m_io_ptr & 1) == 0) {
}
else
{
if (!(m_io_ptr & 1))
{
switch (m_command)
{
case RDMEM:
m_io_word = rd_video(m_memory_ptr++);
break;
{
case RDMEM:
m_io_word = rd_video(m_memory_ptr++);
break;
case RDWIN:
case RDWIN:
{
uint16_t addr = get_pix_addr(m_rw_win_x, m_rw_win_y);
unsigned bit = m_rw_win_x % WS;
int width = m_window.width + m_window.org_x - m_rw_win_x;
if (width <= 0)
{
uint16_t addr = get_pix_addr(m_rw_win_x , m_rw_win_y);
unsigned bit = m_rw_win_x % WS;
int width = m_window.width + m_window.org_x - m_rw_win_x;
if (width <= 0) {
m_command = NOP;
break;
}
unsigned w = std::min(WS , unsigned(width));
m_command = NOP;
}
else
{
unsigned w = std::min(WS, unsigned(width));
m_io_word = rd_video(addr) << bit;
if ((bit + w) > WS) {
if ((bit + w) > WS)
m_io_word |= rd_video(addr + 1) >> (WS - bit);
}
m_io_word &= ~0 << (WS - w);
m_rw_win_x += w;
if (m_rw_win_x >= (m_window.width + m_window.org_x)) {
if (m_rw_win_x >= (m_window.width + m_window.org_x))
{
m_rw_win_x = m_window.org_x;
m_rw_win_y++;
if (m_rw_win_y >= (m_window.height + m_window.org_y)) {
if (m_rw_win_y >= (m_window.height + m_window.org_y))
m_command = NOP;
}
}
}
break;
case RDP:
if (m_io_ptr == 0) {
m_io_word = m_cursor_x;
} else if (m_io_ptr == 2) {
m_io_word = m_cursor_y;
}
break;
case RDSP:
if (m_io_ptr == 0) {
m_io_word = m_sprite_x;
} else if (m_io_ptr == 2) {
m_io_word = m_sprite_y;
}
break;
case ID:
/*
* 'diagb' ROM accepts either of these ID values
* 0x3003, 0x4004, 0x5005, 0x6006
*/
m_io_word = 0x4004;
break;
}
break;
case RDP:
if (m_io_ptr == 0)
m_io_word = m_cursor_x;
else if (m_io_ptr == 2)
m_io_word = m_cursor_y;
break;
case RDSP:
if (m_io_ptr == 0)
m_io_word = m_sprite_x;
else if (m_io_ptr == 2)
m_io_word = m_sprite_y;
break;
case ID:
/*
* 'diagb' ROM accepts either of these ID values
* 0x3003, 0x4004, 0x5005, 0x6006
*/
m_io_word = 0x4004;
break;
}
data = uint8_t(m_io_word >> 8);
} else {
} else
{
data = m_io_word & 0xff;
}
m_io_ptr++;
@ -789,75 +805,86 @@ WRITE8_MEMBER( hp1ll3_device::write )
{
DBG_LOG(1,"HPGPU", ("W @ %d <- %02x\n", offset, data));
if (offset == 0) {
if (offset == 0)
{
command(data);
} else {
if ((m_io_ptr & 1) == 0) {
}
else
{
if (!(m_io_ptr & 1))
{
m_io_word = uint16_t(data) << 8;
} else {
}
else
{
m_io_word |= data;
switch (m_command)
{
case CONF:
m_conf[m_io_ptr >> 1] = m_io_word;
DBG_LOG(1,"HPGPU",("CONF data word %d received: %04X\n", m_io_ptr >> 1, m_io_word));
if ((m_io_ptr >> 1) == 10) {
apply_conf();
m_io_ptr = -1;
m_command = NOP;
}
break;
case WRMEM:
wr_video(m_memory_ptr++, m_io_word);
break;
case WRWIN:
{
case CONF:
m_conf[ m_io_ptr >> 1 ] = m_io_word;
DBG_LOG(1,"HPGPU",("CONF data word %d received: %04X\n", m_io_ptr >> 1, m_io_word));
if ((m_io_ptr >> 1) == 10) {
apply_conf();
m_io_ptr = -1;
m_command = NOP;
}
break;
uint16_t rop_masks[4];
get_rop_masks(m_rr, rop_masks);
case WRMEM:
wr_video(m_memory_ptr++ , m_io_word);
break;
case WRWIN:
uint16_t addr = get_pix_addr(m_rw_win_x, m_rw_win_y);
uint16_t glob_mask = ~0;
unsigned bit = m_rw_win_x % WS;
int width = m_window.width + m_window.org_x - m_rw_win_x;
if (width <= 0)
{
uint16_t rop_masks[ 4 ];
get_rop_masks(m_rr , rop_masks);
m_command = NOP;
draw_cursor_sprite();
}
else
{
unsigned w = std::min(WS, unsigned(width));
uint16_t addr = get_pix_addr(m_rw_win_x , m_rw_win_y);
uint16_t glob_mask = ~0;
unsigned bit = m_rw_win_x % WS;
int width = m_window.width + m_window.org_x - m_rw_win_x;
if (width <= 0) {
m_command = NOP;
draw_cursor_sprite();
} else {
unsigned w = std::min(WS , unsigned(width));
glob_mask >>= bit;
if ((bit + w) < WS)
glob_mask &= ~0 << (WS - (bit + w));
glob_mask >>= bit;
if ((bit + w) < WS) {
glob_mask &= ~0 << (WS - (bit + w));
}
rmw_rop(addr , m_io_word >> bit , glob_mask , rop_masks);
DBG_LOG(3, 0, ("WRWIN (%u,%u) %d %04x %04x\n" , m_rw_win_x , m_rw_win_y , width , m_io_word >> bit , glob_mask));
if ((bit + w) > WS) {
unsigned pad = WS - bit;
glob_mask = ~0 << (2 * WS - bit - w);
rmw_rop(addr + 1 , uint16_t(m_io_word << pad) , glob_mask , rop_masks);
DBG_LOG(3, 0, ("WRWIN %u %04x %04x\n" , pad , m_io_word << pad , glob_mask));
}
m_rw_win_x += w;
if (m_rw_win_x >= (m_window.width + m_window.org_x)) {
m_rw_win_x = m_window.org_x;
m_rw_win_y++;
if (m_rw_win_y >= (m_window.height + m_window.org_y)) {
m_command = NOP;
draw_cursor_sprite();
}
rmw_rop(addr, m_io_word >> bit, glob_mask, rop_masks);
DBG_LOG(3, 0, ("WRWIN (%u,%u) %d %04x %04x\n", m_rw_win_x, m_rw_win_y, width, m_io_word >> bit, glob_mask));
if ((bit + w) > WS)
{
unsigned pad = WS - bit;
glob_mask = ~0 << (2 * WS - bit - w);
rmw_rop(addr + 1, uint16_t(m_io_word << pad), glob_mask, rop_masks);
DBG_LOG(3, 0, ("WRWIN %u %04x %04x\n", pad, m_io_word << pad, glob_mask));
}
m_rw_win_x += w;
if (m_rw_win_x >= (m_window.width + m_window.org_x))
{
m_rw_win_x = m_window.org_x;
m_rw_win_y++;
if (m_rw_win_y >= (m_window.height + m_window.org_y))
{
m_command = NOP;
draw_cursor_sprite();
}
}
}
break;
default:
if (m_io_ptr <= 4) {
m_input[ m_io_ptr / 2 ] = m_io_word;
}
DBG_LOG(2,"HPGPU",("wrote %02x at %d, input buffer is %04X %04X\n", data, m_io_ptr, m_input[0], m_input[1]));
}
break;
default:
if (m_io_ptr <= 4)
m_input[m_io_ptr / 2] = m_io_word;
DBG_LOG(2,"HPGPU",("wrote %02x at %d, input buffer is %04X %04X\n", data, m_io_ptr, m_input[0], m_input[1]));
}
}
m_io_ptr++;
}
@ -866,8 +893,6 @@ WRITE8_MEMBER( hp1ll3_device::write )
void hp1ll3_device::command(int command)
{
int c, w;
switch (command)
{
@ -912,7 +937,7 @@ void hp1ll3_device::command(int command)
case ENSP:
DBG_LOG(2,"HPGPU",("command: ENSP [%d, 0x%x]\n", command, command));
draw_sprite();
m_sprite_pattern = m_input[ 0 ];
m_sprite_pattern = m_input[0];
m_enable_sprite = true;
draw_sprite();
DBG_LOG(1,"HPGPU",("enable sprite; cursor %d,%d sprite %d,%d\n", m_cursor_x, m_cursor_y, m_sprite_x, m_sprite_y));
@ -960,7 +985,7 @@ void hp1ll3_device::command(int command)
// set replacement rule (raster op)
case WRRR:
DBG_LOG(2,"HPGPU",("command: WRRR [%d, 0x%x] (0x%04x)\n", command, command, m_input[0]));
m_rr = m_input[ 0 ];
m_rr = m_input[0];
break;
// set user-defined line pattern
@ -975,18 +1000,20 @@ void hp1ll3_device::command(int command)
command, command, m_input[0],
m_window.org_x, m_window.org_y, m_window.width, m_window.height, m_rr));
draw_cursor_sprite();
fill(get_window() , m_input[0]);
fill(get_window(), m_input[0]);
draw_cursor_sprite();
break;
case LABEL:
DBG_LOG(2,"HPGPU",("command: LABEL [%d, 0x%x] (0x%04x, '%c') at %d,%d\n", command, command, m_input[0],
(m_input[0]<32||m_input[0]>127) ? ' ' : m_input[0], m_cursor_x, m_cursor_y));
c = m_input[0] & 255;
w = (c & 1) ?
(rd_video(m_fad + 2 + (c>>1)) & 255) :
(rd_video(m_fad + 2 + (c>>1)) >> 8);
label(c, w);
{
DBG_LOG(2,"HPGPU",("command: LABEL [%d, 0x%x] (0x%04x, '%c') at %d,%d\n", command, command, m_input[0],
(m_input[0]<32||m_input[0]>127) ? ' ' : m_input[0], m_cursor_x, m_cursor_y));
int const c = m_input[0] & 255;
int const w = (c & 1) ?
(rd_video(m_fad + 2 + (c>>1)) & 255) :
(rd_video(m_fad + 2 + (c>>1)) >> 8);
label(c, w);
}
break;
// Write window
@ -1011,8 +1038,8 @@ void hp1ll3_device::command(int command)
case DRAWPX:
{
DBG_LOG(2,"HPGPU",("command: DRAWPX [%d, 0x%x] (%d, %d)\n", command, command, m_input[0], m_input[1]));
uint16_t rop_masks[ 4 ];
get_rop_masks(m_rr , rop_masks);
uint16_t rop_masks[4];
get_rop_masks(m_rr, rop_masks);
point(m_input[0], m_input[1], true, rop_masks);
}
break;
@ -1036,11 +1063,11 @@ void hp1ll3_device::command(int command)
{
DBG_LOG(2,"HPGPU",("command: COPY [%d, 0x%x] (%d, %d)\n", command, command, m_input[0], m_input[1]));
draw_cursor_sprite();
unsigned rounded_width = m_conf[ CONF_WPL ] * WS;
Rectangle dst_rect{{ m_input[ 0 ] , m_input[ 1 ] } , { m_window.width , m_window.height }};
unsigned rounded_width = m_conf[CONF_WPL] * WS;
Rectangle dst_rect{{ m_input[0], m_input[1] }, { m_window.width, m_window.height }};
// COPY apparently doesn't clip anything
bitblt(m_org , rounded_width , 0xffff , Point{ m_window.org_x , m_window.org_y } ,
Rectangle{{ 0 , 0 } , { uint16_t(rounded_width) , 0xffff }} , dst_rect , m_rr);
bitblt(m_org, rounded_width, 0xffff, Point{ m_window.org_x, m_window.org_y },
Rectangle{{ 0, 0 }, { uint16_t(rounded_width), 0xffff }}, dst_rect, m_rr);
draw_cursor_sprite();
}
break;
@ -1048,7 +1075,7 @@ void hp1ll3_device::command(int command)
// move pointer absolute
case MOVEP:
DBG_LOG(2,"HPGPU",("command: MOVEP [%d, 0x%x] (%d, %d)\n", command, command, m_input[0], m_input[1]));
set_pen_pos(Point{ m_input[ 0 ] , m_input[ 1 ] });
set_pen_pos(Point{ m_input[0], m_input[1] });
m_saved_x = m_cursor_x;
break;
@ -1057,13 +1084,13 @@ void hp1ll3_device::command(int command)
{
DBG_LOG(2,"HPGPU",("command: SCROLUP [%d, 0x%x] (%d, %d)\n", command, command, m_input[0], m_input[1]));
draw_cursor_sprite();
Point src_p{ m_window.org_x , uint16_t(m_window.org_y + m_input[ 1 ]) };
Point src_p{ m_window.org_x, uint16_t(m_window.org_y + m_input[1]) };
Rectangle dst_rect = get_window();
dst_rect.size.y -= m_input[ 1 ];
bitblt(m_org , m_horiz_pix_total , m_vert_pix_total , src_p , get_window() , dst_rect , m_rr);
dst_rect.size.y -= m_input[1];
bitblt(m_org, m_horiz_pix_total, m_vert_pix_total, src_p, get_window(), dst_rect, m_rr);
dst_rect.origin.y += dst_rect.size.y;
dst_rect.size.y = m_input[ 1 ];
fill(dst_rect , m_input[ 0 ]);
dst_rect.size.y = m_input[1];
fill(dst_rect, m_input[0]);
draw_cursor_sprite();
}
break;
@ -1073,14 +1100,14 @@ void hp1ll3_device::command(int command)
{
DBG_LOG(2,"HPGPU",("command: SCROLDN [%d, 0x%x] (%d, %d)\n", command, command, m_input[0], m_input[1]));
draw_cursor_sprite();
Point src_p{ m_window.org_x , m_window.org_y };
Point src_p{ m_window.org_x, m_window.org_y };
Rectangle dst_rect = get_window();
dst_rect.origin.y += m_input[ 1 ];
dst_rect.size.y -= m_input[ 1 ];
bitblt(m_org , m_horiz_pix_total , m_vert_pix_total , src_p , get_window() , dst_rect , m_rr);
dst_rect.origin.y += m_input[1];
dst_rect.size.y -= m_input[1];
bitblt(m_org, m_horiz_pix_total, m_vert_pix_total, src_p, get_window(), dst_rect, m_rr);
dst_rect.origin.y = m_window.org_y;
dst_rect.size.y = m_input[ 1 ];
fill(dst_rect , m_input[ 0 ]);
dst_rect.size.y = m_input[1];
fill(dst_rect, m_input[0]);
draw_cursor_sprite();
}
break;
@ -1088,8 +1115,8 @@ void hp1ll3_device::command(int command)
case ENCURS:
DBG_LOG(2,"HPGPU",("command: ENCURS [%d, 0x%x]\n", command, command));
draw_cursor();
m_cursor_pattern = m_input[ 0 ];
m_cursor_offset = m_input[ 1 ];
m_cursor_pattern = m_input[0];
m_cursor_offset = m_input[1];
m_enable_cursor = true;
draw_cursor();
DBG_LOG(1,"HPGPU",("enable cursor; cursor %d,%d sprite %d,%d\n", m_cursor_x, m_cursor_y, m_sprite_x, m_sprite_y));
@ -1098,13 +1125,13 @@ void hp1ll3_device::command(int command)
// carriage return, line feed
case CRLFx:
DBG_LOG(2,"HPGPU",("command: CRLF [%d, 0x%x] (%d, %d)\n", command, command, m_input[0], m_input[1]));
set_pen_pos(Point{ m_saved_x , uint16_t(m_cursor_y + m_fontheight) });
set_pen_pos(Point{ m_saved_x, uint16_t(m_cursor_y + m_fontheight) });
break;
// move sprite absolute
case MOVESP:
DBG_LOG(2,"HPGPU",("command: MOVESP [%d, 0x%x] (%d, %d)\n", command, command, m_input[0], m_input[1]));
set_sprite_pos(Point{ m_input[ 0 ] , m_input[ 1 ] });
set_sprite_pos(Point{ m_input[0], m_input[1] });
break;
// draw to ...
@ -1112,7 +1139,7 @@ void hp1ll3_device::command(int command)
DBG_LOG(2,"HPGPU",("command: DRAWP [%d, 0x%x] (%d, %d) to (%d, %d)\n",
command, command, m_cursor_x, m_cursor_y, m_input[0], m_input[1]));
line(m_cursor_x, m_cursor_y, m_input[0], m_input[1]);
set_pen_pos(Point{ m_input[ 0 ] , m_input[ 1 ] });
set_pen_pos(Point{ m_input[0], m_input[1] });
break;
// type 3 command -- CONF -- accept configuration parameters (11 words)
@ -1129,7 +1156,7 @@ void hp1ll3_device::command(int command)
m_memory_ptr = m_input[0]; // memory is word-addressable
break;
// type 3 read commands
// type 3 read commands
case RDP:
case RDSP:
break;

41
src/devices/video/hp1ll3.h
View File

@ -12,13 +12,6 @@
#pragma once
///*************************************************************************
// INTERFACE CONFIGURATION MACROS
///*************************************************************************
#define MCFG_HP1LL3_ADD(_tag) \
MCFG_DEVICE_ADD(_tag, HP1LL3, 0)
///*************************************************************************
// TYPE DEFINITIONS
///*************************************************************************
@ -43,31 +36,33 @@ protected:
virtual void device_reset() override;
private:
struct Point {
uint16_t x , y;
struct Point
{
uint16_t x, y;
};
struct Rectangle {
struct Rectangle
{
Point origin;
Point size;
};
void command(int command);
uint16_t get_pix_addr(uint16_t x , uint16_t y) const;
uint16_t get_pix_addr(uint16_t x, uint16_t y) const;
inline void point(int x, int y, bool pix, const uint16_t masks[]);
void label(uint8_t chr, int width);
void line(int x_from, int y_from, int x_to, int y_to);
void wr_video(uint16_t addr , uint16_t v);
void wr_video(uint16_t addr, uint16_t v);
uint16_t rd_video(uint16_t addr) const;
static void get_rop_masks(uint16_t rop , uint16_t masks[]);
static uint16_t apply_rop(uint16_t old_pix , uint16_t new_pix , uint16_t glob_mask , const uint16_t masks[]);
void rmw_rop(uint16_t addr , uint16_t new_pix , uint16_t glob_mask , const uint16_t masks[]);
void clip_coord(int size_1 , int& p1 , int origin_clip , int size_clip , int& origin_2 , int& size_2) const;
bool bitblt(uint16_t src_base_addr , unsigned src_width , unsigned src_height , Point src_p ,
const Rectangle& clip_rect , const Rectangle& dst_rect , uint16_t rop , bool use_m_org = true);
void rowbltpos(unsigned p1_pix , unsigned p2_pix , int width , const uint16_t masks[]);
void rowbltneg(unsigned p1_pix , unsigned p2_pix , int width , const uint16_t masks[]);
void fill(const Rectangle& fill_rect , uint16_t pattern_no);
static void get_rop_masks(uint16_t rop, uint16_t masks[]);
static uint16_t apply_rop(uint16_t old_pix, uint16_t new_pix, uint16_t glob_mask, const uint16_t masks[]);
void rmw_rop(uint16_t addr, uint16_t new_pix, uint16_t glob_mask, const uint16_t masks[]);
void clip_coord(int size_1, int &p1, int origin_clip, int size_clip, int &origin_2, int &size_2) const;
bool bitblt(uint16_t src_base_addr, unsigned src_width, unsigned src_height, Point src_p,
const Rectangle &clip_rect, const Rectangle &dst_rect, uint16_t rop, bool use_m_org = true);
void rowbltpos(unsigned p1_pix, unsigned p2_pix, int width, const uint16_t masks[]);
void rowbltneg(unsigned p1_pix, unsigned p2_pix, int width, const uint16_t masks[]);
void fill(const Rectangle &fill_rect, uint16_t pattern_no);
uint16_t get_pattern_addr(uint16_t pattern_no) const;
void draw_cursor();
void draw_sprite();
@ -78,7 +73,7 @@ private:
Rectangle get_screen() const;
void apply_conf();
uint16_t m_conf[ 11 ] , m_input[2] , m_io_word;
uint16_t m_conf[11], m_input[2], m_io_word;
int m_io_ptr, m_memory_ptr;
int m_command, m_horiz_pix_total, m_vert_pix_total;
@ -100,7 +95,7 @@ private:
} m_window;
std::unique_ptr<uint16_t[]> m_videoram;
uint16_t m_ram_addr_mask;
uint16_t m_rw_win_x , m_rw_win_y;
uint16_t m_rw_win_x, m_rw_win_y;
bool m_busy;