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

Modernized nubus graphics cards screen updates (no whatsnew)

Browse Source
This commit is contained in:
Miodrag Milanovic 2012-09-18 11:00:03 +00:00
parent 41d4cd4f6a
commit b0127c2abd
16 changed files with 189 additions and 205 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

75
src/mess/video/nubus_48gc.c
View File

@ -14,11 +14,9 @@
#define VRAM_SIZE (0x200000) // 2 megs, maxed out
static SCREEN_UPDATE_RGB32( mac_48gc );
MACHINE_CONFIG_FRAGMENT( macvideo_48gc )
MCFG_SCREEN_ADD( GC48_SCREEN_NAME, RASTER)
MCFG_SCREEN_UPDATE_STATIC( mac_48gc )
MCFG_SCREEN_UPDATE_DEVICE(DEVICE_SELF, jmfb_device, screen_update)
MCFG_SCREEN_RAW_PARAMS(25175000, 800, 0, 640, 525, 0, 480)
// MCFG_SCREEN_SIZE(1152, 870)
// MCFG_SCREEN_VISIBLE_AREA(0, 1152-1, 0, 870-1)
@ -141,93 +139,92 @@ void jmfb_device::device_reset()
***************************************************************************/
static SCREEN_UPDATE_RGB32( mac_48gc )
UINT32 jmfb_device::screen_update(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect)
{
jmfb_device *card = downcast<jmfb_device *>(screen.owner());
UINT32 *scanline, *base;
int x, y;
UINT8 *vram8 = (UINT8 *)card->m_vram;
UINT8 *vram8 = (UINT8 *)m_vram;
UINT8 pixels;
if (!card->m_vbl_disable)
if (!m_vbl_disable)
{
card->raise_slot_irq();
raise_slot_irq();
}
vram8 += 0xa00;
switch (card->m_mode)
switch (m_mode)
{
case 0: // 1bpp
for (y = 0; y < card->m_yres; y++)
for (y = 0; y < m_yres; y++)
{
scanline = &bitmap.pix32(y);
for (x = 0; x < card->m_xres/8; x++)
for (x = 0; x < m_xres/8; x++)
{
pixels = vram8[(y * card->m_stride) + (BYTE4_XOR_BE(x))];
pixels = vram8[(y * m_stride) + (BYTE4_XOR_BE(x))];
*scanline++ = card->m_palette[(pixels>>7)&1];
*scanline++ = card->m_palette[(pixels>>6)&1];
*scanline++ = card->m_palette[(pixels>>5)&1];
*scanline++ = card->m_palette[(pixels>>4)&1];
*scanline++ = card->m_palette[(pixels>>3)&1];
*scanline++ = card->m_palette[(pixels>>2)&1];
*scanline++ = card->m_palette[(pixels>>1)&1];
*scanline++ = card->m_palette[pixels&1];
*scanline++ = m_palette[(pixels>>7)&1];
*scanline++ = m_palette[(pixels>>6)&1];
*scanline++ = m_palette[(pixels>>5)&1];
*scanline++ = m_palette[(pixels>>4)&1];
*scanline++ = m_palette[(pixels>>3)&1];
*scanline++ = m_palette[(pixels>>2)&1];
*scanline++ = m_palette[(pixels>>1)&1];
*scanline++ = m_palette[pixels&1];
}
}
break;
case 1: // 2bpp
for (y = 0; y < card->m_yres; y++)
for (y = 0; y < m_yres; y++)
{
scanline = &bitmap.pix32(y);
for (x = 0; x < card->m_xres/4; x++)
for (x = 0; x < m_xres/4; x++)
{
pixels = vram8[(y * card->m_stride) + (BYTE4_XOR_BE(x))];
pixels = vram8[(y * m_stride) + (BYTE4_XOR_BE(x))];
*scanline++ = card->m_palette[(pixels>>6)&0x3];
*scanline++ = card->m_palette[(pixels>>4)&0x3];
*scanline++ = card->m_palette[(pixels>>2)&0x3];
*scanline++ = card->m_palette[pixels&3];
*scanline++ = m_palette[(pixels>>6)&0x3];
*scanline++ = m_palette[(pixels>>4)&0x3];
*scanline++ = m_palette[(pixels>>2)&0x3];
*scanline++ = m_palette[pixels&3];
}
}
break;
case 2: // 4 bpp
for (y = 0; y < card->m_yres; y++)
for (y = 0; y < m_yres; y++)
{
scanline = &bitmap.pix32(y);
for (x = 0; x < card->m_xres/2; x++)
for (x = 0; x < m_xres/2; x++)
{
pixels = vram8[(y * card->m_stride) + (BYTE4_XOR_BE(x))];
pixels = vram8[(y * m_stride) + (BYTE4_XOR_BE(x))];
*scanline++ = card->m_palette[(pixels>>4)&0xf];
*scanline++ = card->m_palette[pixels&0xf];
*scanline++ = m_palette[(pixels>>4)&0xf];
*scanline++ = m_palette[pixels&0xf];
}
}
break;
case 3: // 8 bpp
for (y = 0; y < card->m_yres; y++)
for (y = 0; y < m_yres; y++)
{
scanline = &bitmap.pix32(y);
for (x = 0; x < card->m_xres; x++)
for (x = 0; x < m_xres; x++)
{
pixels = vram8[(y * card->m_stride) + (BYTE4_XOR_BE(x))];
*scanline++ = card->m_palette[pixels];
pixels = vram8[(y * m_stride) + (BYTE4_XOR_BE(x))];
*scanline++ = m_palette[pixels];
}
}
break;
case 4: // 24 bpp
for (y = 0; y < card->m_yres; y++)
for (y = 0; y < m_yres; y++)
{
scanline = &bitmap.pix32(y);
base = (UINT32 *)&card->m_vram[y * card->m_stride];
for (x = 0; x < card->m_xres; x++)
base = (UINT32 *)&m_vram[y * m_stride];
for (x = 0; x < m_xres; x++)
{
*scanline++ = *base++;
}

1
src/mess/video/nubus_48gc.h
View File

@ -24,6 +24,7 @@ public:
virtual machine_config_constructor device_mconfig_additions() const;
virtual const rom_entry *device_rom_region() const;
UINT32 screen_update(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect);
protected:
// device-level overrides
virtual void device_start();

55
src/mess/video/nubus_cb264.c
View File

@ -19,11 +19,9 @@
#define VRAM_SIZE (0x200000) // 2 megs, maxed out
static SCREEN_UPDATE_RGB32( cb264 );
MACHINE_CONFIG_FRAGMENT( cb264 )
MCFG_SCREEN_ADD( CB264_SCREEN_NAME, RASTER)
MCFG_SCREEN_UPDATE_STATIC(cb264)
MCFG_SCREEN_UPDATE_DEVICE(DEVICE_SELF, nubus_cb264_device, screen_update)
MCFG_SCREEN_RAW_PARAMS(25175000, 800, 0, 640, 525, 0, 480)
MCFG_SCREEN_SIZE(1024,768)
MCFG_SCREEN_VISIBLE_AREA(0, 640-1, 0, 480-1)
@ -127,19 +125,18 @@ void nubus_cb264_device::device_reset()
***************************************************************************/
static SCREEN_UPDATE_RGB32( cb264 )
UINT32 nubus_cb264_device::screen_update(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect)
{
UINT32 *scanline, *base;
int x, y;
nubus_cb264_device *card = downcast<nubus_cb264_device *>(screen.owner());
UINT8 pixels;
if (!card->m_cb264_vbl_disable)
if (!m_cb264_vbl_disable)
{
card->raise_slot_irq();
raise_slot_irq();
}
switch (card->m_cb264_mode)
switch (m_cb264_mode)
{
case 0: // 1 bpp
for (y = 0; y < 480; y++)
@ -147,16 +144,16 @@ static SCREEN_UPDATE_RGB32( cb264 )
scanline = &bitmap.pix32(y);
for (x = 0; x < 640/8; x++)
{
pixels = card->m_vram[(y * 1024) + (BYTE4_XOR_BE(x))];
pixels = m_vram[(y * 1024) + (BYTE4_XOR_BE(x))];
*scanline++ = card->m_palette[pixels&0x80];
*scanline++ = card->m_palette[(pixels<<1)&0x80];
*scanline++ = card->m_palette[(pixels<<2)&0x80];
*scanline++ = card->m_palette[(pixels<<3)&0x80];
*scanline++ = card->m_palette[(pixels<<4)&0x80];
*scanline++ = card->m_palette[(pixels<<5)&0x80];
*scanline++ = card->m_palette[(pixels<<6)&0x80];
*scanline++ = card->m_palette[(pixels<<7)&0x80];
*scanline++ = m_palette[pixels&0x80];
*scanline++ = m_palette[(pixels<<1)&0x80];
*scanline++ = m_palette[(pixels<<2)&0x80];
*scanline++ = m_palette[(pixels<<3)&0x80];
*scanline++ = m_palette[(pixels<<4)&0x80];
*scanline++ = m_palette[(pixels<<5)&0x80];
*scanline++ = m_palette[(pixels<<6)&0x80];
*scanline++ = m_palette[(pixels<<7)&0x80];
}
}
break;
@ -167,12 +164,12 @@ static SCREEN_UPDATE_RGB32( cb264 )
scanline = &bitmap.pix32(y);
for (x = 0; x < 640/4; x++)
{
pixels = card->m_vram[(y * 1024) + (BYTE4_XOR_BE(x))];
pixels = m_vram[(y * 1024) + (BYTE4_XOR_BE(x))];
*scanline++ = card->m_palette[pixels&0xc0];
*scanline++ = card->m_palette[(pixels<<2)&0xc0];
*scanline++ = card->m_palette[(pixels<<4)&0xc0];
*scanline++ = card->m_palette[(pixels<<6)&0xc0];
*scanline++ = m_palette[pixels&0xc0];
*scanline++ = m_palette[(pixels<<2)&0xc0];
*scanline++ = m_palette[(pixels<<4)&0xc0];
*scanline++ = m_palette[(pixels<<6)&0xc0];
}
}
break;
@ -184,10 +181,10 @@ static SCREEN_UPDATE_RGB32( cb264 )
for (x = 0; x < 640/2; x++)
{
pixels = card->m_vram[(y * 1024) + (BYTE4_XOR_BE(x))];
pixels = m_vram[(y * 1024) + (BYTE4_XOR_BE(x))];
*scanline++ = card->m_palette[pixels&0xf0];
*scanline++ = card->m_palette[(pixels<<4)&0xf0];
*scanline++ = m_palette[pixels&0xf0];
*scanline++ = m_palette[(pixels<<4)&0xf0];
}
}
break;
@ -199,8 +196,8 @@ static SCREEN_UPDATE_RGB32( cb264 )
for (x = 0; x < 640; x++)
{
pixels = card->m_vram[(y * 1024) + (BYTE4_XOR_BE(x))];
*scanline++ = card->m_palette[pixels];
pixels = m_vram[(y * 1024) + (BYTE4_XOR_BE(x))];
*scanline++ = m_palette[pixels];
}
}
break;
@ -208,7 +205,7 @@ static SCREEN_UPDATE_RGB32( cb264 )
case 4: // 24 bpp
case 7: // ???
{
UINT32 *vram32 = (UINT32 *)card->m_vram;
UINT32 *vram32 = (UINT32 *)m_vram;
for (y = 0; y < 480; y++)
{
@ -223,7 +220,7 @@ static SCREEN_UPDATE_RGB32( cb264 )
break;
default:
fatalerror("cb264: unknown video mode %d\n", card->m_cb264_mode);
fatalerror("cb264: unknown video mode %d\n", m_cb264_mode);
break;
}

1
src/mess/video/nubus_cb264.h
View File

@ -25,6 +25,7 @@ public:
virtual machine_config_constructor device_mconfig_additions() const;
virtual const rom_entry *device_rom_region() const;
UINT32 screen_update(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect);
protected:
// device-level overrides
virtual void device_start();

49
src/mess/video/nubus_m2hires.c
View File

@ -16,11 +16,9 @@
#define VRAM_SIZE (0x80000) // 512k max
static SCREEN_UPDATE_RGB32( m2hires );
MACHINE_CONFIG_FRAGMENT( m2hires )
MCFG_SCREEN_ADD( M2HIRES_SCREEN_NAME, RASTER)
MCFG_SCREEN_UPDATE_STATIC(m2hires)
MCFG_SCREEN_UPDATE_DEVICE(DEVICE_SELF, nubus_m2hires_device, screen_update)
MCFG_SCREEN_RAW_PARAMS(25175000, 800, 0, 640, 525, 0, 480)
MCFG_SCREEN_SIZE(1024,768)
MCFG_SCREEN_VISIBLE_AREA(0, 640-1, 0, 480-1)
@ -140,23 +138,22 @@ void nubus_m2hires_device::device_timer(emu_timer &timer, device_timer_id tid, i
***************************************************************************/
static SCREEN_UPDATE_RGB32( m2hires )
UINT32 nubus_m2hires_device::screen_update(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect)
{
UINT32 *scanline;
int x, y;
nubus_m2hires_device *card = downcast<nubus_m2hires_device *>(screen.owner());
UINT8 pixels, *vram;
// first time? kick off the VBL timer
if (!card->m_screen)
if (!m_screen)
{
card->m_screen = &screen;
card->m_timer->adjust(card->m_screen->time_until_pos(479, 0), 0);
m_screen = &screen;
m_timer->adjust(m_screen->time_until_pos(479, 0), 0);
}
vram = card->m_vram + 0x20;
vram = m_vram + 0x20;
switch (card->m_mode)
switch (m_mode)
{
case 0: // 1 bpp?
for (y = 0; y < 480; y++)
@ -166,14 +163,14 @@ static SCREEN_UPDATE_RGB32( m2hires )
{
pixels = vram[(y * 128) + (BYTE4_XOR_BE(x))];
*scanline++ = card->m_palette[((pixels>>7)&0x1)];
*scanline++ = card->m_palette[((pixels>>6)&0x1)];
*scanline++ = card->m_palette[((pixels>>5)&0x1)];
*scanline++ = card->m_palette[((pixels>>4)&0x1)];
*scanline++ = card->m_palette[((pixels>>3)&0x1)];
*scanline++ = card->m_palette[((pixels>>2)&0x1)];
*scanline++ = card->m_palette[((pixels>>1)&0x1)];
*scanline++ = card->m_palette[(pixels&1)];
*scanline++ = m_palette[((pixels>>7)&0x1)];
*scanline++ = m_palette[((pixels>>6)&0x1)];
*scanline++ = m_palette[((pixels>>5)&0x1)];
*scanline++ = m_palette[((pixels>>4)&0x1)];
*scanline++ = m_palette[((pixels>>3)&0x1)];
*scanline++ = m_palette[((pixels>>2)&0x1)];
*scanline++ = m_palette[((pixels>>1)&0x1)];
*scanline++ = m_palette[(pixels&1)];
}
}
break;
@ -186,10 +183,10 @@ static SCREEN_UPDATE_RGB32( m2hires )
{
pixels = vram[(y * 256) + (BYTE4_XOR_BE(x))];
*scanline++ = card->m_palette[((pixels>>6)&3)];
*scanline++ = card->m_palette[((pixels>>4)&3)];
*scanline++ = card->m_palette[((pixels>>2)&3)];
*scanline++ = card->m_palette[(pixels&3)];
*scanline++ = m_palette[((pixels>>6)&3)];
*scanline++ = m_palette[((pixels>>4)&3)];
*scanline++ = m_palette[((pixels>>2)&3)];
*scanline++ = m_palette[(pixels&3)];
}
}
break;
@ -203,8 +200,8 @@ static SCREEN_UPDATE_RGB32( m2hires )
{
pixels = vram[(y * 512) + (BYTE4_XOR_BE(x))];
*scanline++ = card->m_palette[((pixels&0xf0)>>4)];
*scanline++ = card->m_palette[(pixels&0xf)];
*scanline++ = m_palette[((pixels&0xf0)>>4)];
*scanline++ = m_palette[(pixels&0xf)];
}
}
break;
@ -217,13 +214,13 @@ static SCREEN_UPDATE_RGB32( m2hires )
for (x = 0; x < 640; x++)
{
pixels = vram[(y * 1024) + (BYTE4_XOR_BE(x))];
*scanline++ = card->m_palette[pixels];
*scanline++ = m_palette[pixels];
}
}
break;
default:
fatalerror("m2hires: unknown video mode %d\n", card->m_mode);
fatalerror("m2hires: unknown video mode %d\n", m_mode);
break;
}
return 0;

1
src/mess/video/nubus_m2hires.h
View File

@ -25,6 +25,7 @@ public:
virtual machine_config_constructor device_mconfig_additions() const;
virtual const rom_entry *device_rom_region() const;
UINT32 screen_update(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect);
protected:
// device-level overrides
virtual void device_start();

31
src/mess/video/nubus_radiustpd.c
View File

@ -16,11 +16,9 @@
#define VRAM_SIZE (0x40000) // 256k. 1152x880 1 bit per pixel fits nicely.
static SCREEN_UPDATE_RGB32( radiustpd );
MACHINE_CONFIG_FRAGMENT( radiustpd )
MCFG_SCREEN_ADD( RADIUSTPD_SCREEN_NAME, RASTER)
MCFG_SCREEN_UPDATE_STATIC(radiustpd)
MCFG_SCREEN_UPDATE_DEVICE(DEVICE_SELF, nubus_radiustpd_device, screen_update)
MCFG_SCREEN_SIZE(1280, 960)
MCFG_SCREEN_REFRESH_RATE(70)
MCFG_SCREEN_VISIBLE_AREA(0, 1152-1, 0, 880-1)
@ -141,21 +139,20 @@ void nubus_radiustpd_device::device_timer(emu_timer &timer, device_timer_id tid,
***************************************************************************/
static SCREEN_UPDATE_RGB32( radiustpd )
UINT32 nubus_radiustpd_device::screen_update(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect)
{
UINT32 *scanline;
int x, y;
nubus_radiustpd_device *card = downcast<nubus_radiustpd_device *>(screen.owner());
UINT8 pixels, *vram;
// first time? kick off the VBL timer
if (!card->m_screen)
if (!m_screen)
{
card->m_screen = &screen;
card->m_timer->adjust(card->m_screen->time_until_pos(479, 0), 0);
m_screen = &screen;
m_timer->adjust(m_screen->time_until_pos(479, 0), 0);
}
vram = card->m_vram + 0x200;
vram = m_vram + 0x200;
for (y = 0; y < 880; y++)
{
@ -164,14 +161,14 @@ static SCREEN_UPDATE_RGB32( radiustpd )
{
pixels = vram[(y * (1152/8)) + (BYTE4_XOR_BE(x))];
*scanline++ = card->m_palette[((pixels>>7)&0x1)];
*scanline++ = card->m_palette[((pixels>>6)&0x1)];
*scanline++ = card->m_palette[((pixels>>5)&0x1)];
*scanline++ = card->m_palette[((pixels>>4)&0x1)];
*scanline++ = card->m_palette[((pixels>>3)&0x1)];
*scanline++ = card->m_palette[((pixels>>2)&0x1)];
*scanline++ = card->m_palette[((pixels>>1)&0x1)];
*scanline++ = card->m_palette[(pixels&1)];
*scanline++ = m_palette[((pixels>>7)&0x1)];
*scanline++ = m_palette[((pixels>>6)&0x1)];
*scanline++ = m_palette[((pixels>>5)&0x1)];
*scanline++ = m_palette[((pixels>>4)&0x1)];
*scanline++ = m_palette[((pixels>>3)&0x1)];
*scanline++ = m_palette[((pixels>>2)&0x1)];
*scanline++ = m_palette[((pixels>>1)&0x1)];
*scanline++ = m_palette[(pixels&1)];
}
}

1
src/mess/video/nubus_radiustpd.h
View File

@ -25,6 +25,7 @@ public:
virtual machine_config_constructor device_mconfig_additions() const;
virtual const rom_entry *device_rom_region() const;
UINT32 screen_update(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect);
protected:
// device-level overrides
virtual void device_start();

49
src/mess/video/nubus_spec8.c
View File

@ -18,11 +18,9 @@
#define VRAM_SIZE (0xc0000) // 768k of VRAM for 1024x768 @ 8 bit
static SCREEN_UPDATE_RGB32( spec8s3 );
MACHINE_CONFIG_FRAGMENT( spec8s3 )
MCFG_SCREEN_ADD( SPEC8S3_SCREEN_NAME, RASTER)
MCFG_SCREEN_UPDATE_STATIC(spec8s3)
MCFG_SCREEN_UPDATE_DEVICE(DEVICE_SELF, nubus_spec8s3_device, screen_update)
MCFG_SCREEN_RAW_PARAMS(25175000, 800, 0, 640, 525, 0, 480)
MCFG_SCREEN_SIZE(1024,768)
MCFG_SCREEN_VISIBLE_AREA(0, 1024-1, 0, 768-1)
@ -144,22 +142,21 @@ void nubus_spec8s3_device::device_timer(emu_timer &timer, device_timer_id tid, i
***************************************************************************/
static SCREEN_UPDATE_RGB32( spec8s3 )
UINT32 nubus_spec8s3_device::screen_update(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect)
{
UINT32 *scanline;
int x, y;
nubus_spec8s3_device *card = downcast<nubus_spec8s3_device *>(screen.owner());
UINT8 pixels, *vram;
// first time? kick off the VBL timer
if (!card->m_screen)
if (!m_screen)
{
card->m_screen = &screen;
card->m_timer->adjust(card->m_screen->time_until_pos(767, 0), 0);
m_screen = &screen;
m_timer->adjust(m_screen->time_until_pos(767, 0), 0);
}
vram = card->m_vram + 0x400;
vram = m_vram + 0x400;
switch (card->m_mode)
switch (m_mode)
{
case 0: // 1 bpp
for (y = 0; y < 768; y++)
@ -169,14 +166,14 @@ static SCREEN_UPDATE_RGB32( spec8s3 )
{
pixels = vram[(y * 512) + (BYTE4_XOR_BE(x))];
*scanline++ = card->m_palette[pixels&0x80];
*scanline++ = card->m_palette[(pixels<<1)&0x80];
*scanline++ = card->m_palette[(pixels<<2)&0x80];
*scanline++ = card->m_palette[(pixels<<3)&0x80];
*scanline++ = card->m_palette[(pixels<<4)&0x80];
*scanline++ = card->m_palette[(pixels<<5)&0x80];
*scanline++ = card->m_palette[(pixels<<6)&0x80];
*scanline++ = card->m_palette[(pixels<<7)&0x80];
*scanline++ = m_palette[pixels&0x80];
*scanline++ = m_palette[(pixels<<1)&0x80];
*scanline++ = m_palette[(pixels<<2)&0x80];
*scanline++ = m_palette[(pixels<<3)&0x80];
*scanline++ = m_palette[(pixels<<4)&0x80];
*scanline++ = m_palette[(pixels<<5)&0x80];
*scanline++ = m_palette[(pixels<<6)&0x80];
*scanline++ = m_palette[(pixels<<7)&0x80];
}
}
break;
@ -189,10 +186,10 @@ static SCREEN_UPDATE_RGB32( spec8s3 )
{
pixels = vram[(y * 512) + (BYTE4_XOR_BE(x))];
*scanline++ = card->m_palette[pixels&0xc0];
*scanline++ = card->m_palette[(pixels<<2)&0xc0];
*scanline++ = card->m_palette[(pixels<<4)&0xc0];
*scanline++ = card->m_palette[(pixels<<6)&0xc0];
*scanline++ = m_palette[pixels&0xc0];
*scanline++ = m_palette[(pixels<<2)&0xc0];
*scanline++ = m_palette[(pixels<<4)&0xc0];
*scanline++ = m_palette[(pixels<<6)&0xc0];
}
}
break;
@ -206,8 +203,8 @@ static SCREEN_UPDATE_RGB32( spec8s3 )
{
pixels = vram[(y * 512) + (BYTE4_XOR_BE(x))];
*scanline++ = card->m_palette[pixels&0xf0];
*scanline++ = card->m_palette[(pixels<<4)&0xf0];
*scanline++ = m_palette[pixels&0xf0];
*scanline++ = m_palette[(pixels<<4)&0xf0];
}
}
break;
@ -220,13 +217,13 @@ static SCREEN_UPDATE_RGB32( spec8s3 )
for (x = 0; x < 1024; x++)
{
pixels = vram[(y * 1024) + (BYTE4_XOR_BE(x))];
*scanline++ = card->m_palette[pixels];
*scanline++ = m_palette[pixels];
}
}
break;
default:
fatalerror("spec8s3: unknown video mode %d\n", card->m_mode);
fatalerror("spec8s3: unknown video mode %d\n", m_mode);
break;
}
return 0;

1
src/mess/video/nubus_spec8.h
View File

@ -26,6 +26,7 @@ public:
virtual const rom_entry *device_rom_region() const;
virtual void device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr);
UINT32 screen_update(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect);
protected:
// device-level overrides
virtual void device_start();

49
src/mess/video/nubus_specpdq.c
View File

@ -31,11 +31,9 @@
#define VRAM_SIZE (0x400000)
static SCREEN_UPDATE_RGB32( specpdq );
MACHINE_CONFIG_FRAGMENT( specpdq )
MCFG_SCREEN_ADD( SPECPDQ_SCREEN_NAME, RASTER)
MCFG_SCREEN_UPDATE_STATIC(specpdq)
MCFG_SCREEN_UPDATE_DEVICE(DEVICE_SELF, nubus_specpdq_device, screen_update)
MCFG_SCREEN_RAW_PARAMS(25175000, 800, 0, 640, 525, 0, 480)
MCFG_SCREEN_SIZE(1280,1024)
MCFG_SCREEN_VISIBLE_AREA(0, 1152-1, 0, 844-1)
@ -153,22 +151,21 @@ void nubus_specpdq_device::device_timer(emu_timer &timer, device_timer_id tid, i
***************************************************************************/
static SCREEN_UPDATE_RGB32( specpdq )
UINT32 nubus_specpdq_device::screen_update(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect)
{
UINT32 *scanline;
int x, y;
nubus_specpdq_device *card = downcast<nubus_specpdq_device *>(screen.owner());
UINT8 pixels, *vram;
// first time? kick off the VBL timer
if (!card->m_screen)
if (!m_screen)
{
card->m_screen = &screen;
card->m_timer->adjust(card->m_screen->time_until_pos(843, 0), 0);
m_screen = &screen;
m_timer->adjust(m_screen->time_until_pos(843, 0), 0);
}
vram = card->m_vram + 0x9000;
vram = m_vram + 0x9000;
switch (card->m_mode)
switch (m_mode)
{
case 0: // 1 bpp
for (y = 0; y < 844; y++)
@ -178,14 +175,14 @@ static SCREEN_UPDATE_RGB32( specpdq )
{
pixels = vram[(y * 512) + (BYTE4_XOR_BE(x))];
*scanline++ = card->m_palette[(pixels&0x80)];
*scanline++ = card->m_palette[((pixels<<1)&0x80)];
*scanline++ = card->m_palette[((pixels<<2)&0x80)];
*scanline++ = card->m_palette[((pixels<<3)&0x80)];
*scanline++ = card->m_palette[((pixels<<4)&0x80)];
*scanline++ = card->m_palette[((pixels<<5)&0x80)];
*scanline++ = card->m_palette[((pixels<<6)&0x80)];
*scanline++ = card->m_palette[((pixels<<7)&0x80)];
*scanline++ = m_palette[(pixels&0x80)];
*scanline++ = m_palette[((pixels<<1)&0x80)];
*scanline++ = m_palette[((pixels<<2)&0x80)];
*scanline++ = m_palette[((pixels<<3)&0x80)];
*scanline++ = m_palette[((pixels<<4)&0x80)];
*scanline++ = m_palette[((pixels<<5)&0x80)];
*scanline++ = m_palette[((pixels<<6)&0x80)];
*scanline++ = m_palette[((pixels<<7)&0x80)];
}
}
break;
@ -198,10 +195,10 @@ static SCREEN_UPDATE_RGB32( specpdq )
{
pixels = vram[(y * 512) + (BYTE4_XOR_BE(x))];
*scanline++ = card->m_palette[(pixels&0xc0)];
*scanline++ = card->m_palette[((pixels<<2)&0xc0)];
*scanline++ = card->m_palette[((pixels<<4)&0xc0)];
*scanline++ = card->m_palette[((pixels<<6)&0xc0)];
*scanline++ = m_palette[(pixels&0xc0)];
*scanline++ = m_palette[((pixels<<2)&0xc0)];
*scanline++ = m_palette[((pixels<<4)&0xc0)];
*scanline++ = m_palette[((pixels<<6)&0xc0)];
}
}
break;
@ -215,8 +212,8 @@ static SCREEN_UPDATE_RGB32( specpdq )
{
pixels = vram[(y * 1024) + (BYTE4_XOR_BE(x))];
*scanline++ = card->m_palette[(pixels&0xf0)];
*scanline++ = card->m_palette[((pixels<<4)&0xf0)];
*scanline++ = m_palette[(pixels&0xf0)];
*scanline++ = m_palette[((pixels<<4)&0xf0)];
}
}
break;
@ -229,13 +226,13 @@ static SCREEN_UPDATE_RGB32( specpdq )
for (x = 0; x < 1152; x++)
{
pixels = vram[(y * 1152) + (BYTE4_XOR_BE(x))];
*scanline++ = card->m_palette[pixels];
*scanline++ = m_palette[pixels];
}
}
break;
default:
fatalerror("specpdq: unknown video mode %d\n", card->m_mode);
fatalerror("specpdq: unknown video mode %d\n", m_mode);
break;
}
return 0;

1
src/mess/video/nubus_specpdq.h
View File

@ -26,6 +26,7 @@ public:
virtual const rom_entry *device_rom_region() const;
virtual void device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr);
UINT32 screen_update(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect);
protected:
// device-level overrides
virtual void device_start();

29
src/mess/video/nubus_vikbw.c
View File

@ -16,11 +16,9 @@
#define VRAM_SIZE (0x18000) // 1024x768 @ 1bpp is 98,304 bytes (0x18000)
static SCREEN_UPDATE_RGB32( vikbw );
MACHINE_CONFIG_FRAGMENT( vikbw )
MCFG_SCREEN_ADD( VIKBW_SCREEN_NAME, RASTER)
MCFG_SCREEN_UPDATE_STATIC(vikbw)
MCFG_SCREEN_UPDATE_DEVICE(DEVICE_SELF, nubus_vikbw_device, screen_update)
MCFG_SCREEN_SIZE(1024,768)
MCFG_SCREEN_VISIBLE_AREA(0, 1024-1, 0, 768-1)
MCFG_SCREEN_REFRESH_RATE(70)
@ -122,16 +120,15 @@ void nubus_vikbw_device::device_reset()
***************************************************************************/
static SCREEN_UPDATE_RGB32( vikbw )
UINT32 nubus_vikbw_device::screen_update(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect)
{
UINT32 *scanline;
int x, y;
nubus_vikbw_device *card = downcast<nubus_vikbw_device *>(screen.owner());
UINT8 pixels;
if (!card->m_vbl_disable)
if (!m_vbl_disable)
{
card->raise_slot_irq();
raise_slot_irq();
}
for (y = 0; y < 768; y++)
@ -139,16 +136,16 @@ static SCREEN_UPDATE_RGB32( vikbw )
scanline = &bitmap.pix32(y);
for (x = 0; x < 1024/8; x++)
{
pixels = card->m_vram[(y * 128) + (BYTE4_XOR_BE(x))];
pixels = m_vram[(y * 128) + (BYTE4_XOR_BE(x))];
*scanline++ = card->m_palette[(pixels>>7)&1];
*scanline++ = card->m_palette[(pixels>>6)&1];
*scanline++ = card->m_palette[(pixels>>5)&1];
*scanline++ = card->m_palette[(pixels>>4)&1];
*scanline++ = card->m_palette[(pixels>>3)&1];
*scanline++ = card->m_palette[(pixels>>2)&1];
*scanline++ = card->m_palette[(pixels>>1)&1];
*scanline++ = card->m_palette[(pixels&1)];
*scanline++ = m_palette[(pixels>>7)&1];
*scanline++ = m_palette[(pixels>>6)&1];
*scanline++ = m_palette[(pixels>>5)&1];
*scanline++ = m_palette[(pixels>>4)&1];
*scanline++ = m_palette[(pixels>>3)&1];
*scanline++ = m_palette[(pixels>>2)&1];
*scanline++ = m_palette[(pixels>>1)&1];
*scanline++ = m_palette[(pixels&1)];
}
}

3
src/mess/video/nubus_vikbw.h
View File

@ -24,7 +24,8 @@ public:
// optional information overrides
virtual machine_config_constructor device_mconfig_additions() const;
virtual const rom_entry *device_rom_region() const;
UINT32 screen_update(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect);
protected:
// device-level overrides
virtual void device_start();

47
src/mess/video/nubus_wsportrait.c
View File

@ -19,11 +19,9 @@
#define VRAM_SIZE (0x80000) // 512k max
static SCREEN_UPDATE_RGB32( wsportrait );
MACHINE_CONFIG_FRAGMENT( wsportrait )
MCFG_SCREEN_ADD( WSPORTRAIT_SCREEN_NAME, RASTER)
MCFG_SCREEN_UPDATE_STATIC(wsportrait)
MCFG_SCREEN_UPDATE_DEVICE(DEVICE_SELF, nubus_wsportrait_device, screen_update)
MCFG_SCREEN_SIZE(1024,960)
MCFG_SCREEN_REFRESH_RATE(75.0)
MCFG_SCREEN_VISIBLE_AREA(0, 640-1, 0, 870-1)
@ -140,23 +138,22 @@ void nubus_wsportrait_device::device_timer(emu_timer &timer, device_timer_id tid
***************************************************************************/
static SCREEN_UPDATE_RGB32( wsportrait )
UINT32 nubus_wsportrait_device::screen_update(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect)
{
UINT32 *scanline;
int x, y;
nubus_wsportrait_device *card = downcast<nubus_wsportrait_device *>(screen.owner());
UINT8 pixels, *vram;
// first time? kick off the VBL timer
if (!card->m_screen)
if (!m_screen)
{
card->m_screen = &screen;
card->m_timer->adjust(card->m_screen->time_until_pos(869, 0), 0);
m_screen = &screen;
m_timer->adjust(m_screen->time_until_pos(869, 0), 0);
}
vram = card->m_vram + 0x80;
vram = m_vram + 0x80;
switch (card->m_mode)
switch (m_mode)
{
case 0: // 1 bpp?
for (y = 0; y < 870; y++)
@ -166,14 +163,14 @@ static SCREEN_UPDATE_RGB32( wsportrait )
{
pixels = vram[(y * 128) + (BYTE4_XOR_BE(x))];
*scanline++ = card->m_palette[((pixels>>7)&0x1)];
*scanline++ = card->m_palette[((pixels>>6)&0x1)];
*scanline++ = card->m_palette[((pixels>>5)&0x1)];
*scanline++ = card->m_palette[((pixels>>4)&0x1)];
*scanline++ = card->m_palette[((pixels>>3)&0x1)];
*scanline++ = card->m_palette[((pixels>>2)&0x1)];
*scanline++ = card->m_palette[((pixels>>1)&0x1)];
*scanline++ = card->m_palette[(pixels&1)];
*scanline++ = m_palette[((pixels>>7)&0x1)];
*scanline++ = m_palette[((pixels>>6)&0x1)];
*scanline++ = m_palette[((pixels>>5)&0x1)];
*scanline++ = m_palette[((pixels>>4)&0x1)];
*scanline++ = m_palette[((pixels>>3)&0x1)];
*scanline++ = m_palette[((pixels>>2)&0x1)];
*scanline++ = m_palette[((pixels>>1)&0x1)];
*scanline++ = m_palette[(pixels&1)];
}
}
break;
@ -186,10 +183,10 @@ static SCREEN_UPDATE_RGB32( wsportrait )
{
pixels = vram[(y * 256) + (BYTE4_XOR_BE(x))];
*scanline++ = card->m_palette[((pixels>>6)&3)];
*scanline++ = card->m_palette[((pixels>>4)&3)];
*scanline++ = card->m_palette[((pixels>>2)&3)];
*scanline++ = card->m_palette[(pixels&3)];
*scanline++ = m_palette[((pixels>>6)&3)];
*scanline++ = m_palette[((pixels>>4)&3)];
*scanline++ = m_palette[((pixels>>2)&3)];
*scanline++ = m_palette[(pixels&3)];
}
}
break;
@ -203,14 +200,14 @@ static SCREEN_UPDATE_RGB32( wsportrait )
{
pixels = vram[(y * 512) + (BYTE4_XOR_BE(x))];
*scanline++ = card->m_palette[((pixels&0xf0)>>4)];
*scanline++ = card->m_palette[(pixels&0xf)];
*scanline++ = m_palette[((pixels&0xf0)>>4)];
*scanline++ = m_palette[(pixels&0xf)];
}
}
break;
default:
fatalerror("wsportrait: unknown video mode %d\n", card->m_mode);
fatalerror("wsportrait: unknown video mode %d\n", m_mode);
break;
}
return 0;

1
src/mess/video/nubus_wsportrait.h
View File

@ -25,6 +25,7 @@ public:
virtual machine_config_constructor device_mconfig_additions() const;
virtual const rom_entry *device_rom_region() const;
UINT32 screen_update(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect);
protected:
// device-level overrides
virtual void device_start();