diff --git a/src/mess/video/nubus_48gc.c b/src/mess/video/nubus_48gc.c
index db5eec63a06..c8f76ef058b 100644
--- a/src/mess/video/nubus_48gc.c
+++ b/src/mess/video/nubus_48gc.c
@@ -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++;
 				}
diff --git a/src/mess/video/nubus_48gc.h b/src/mess/video/nubus_48gc.h
index 07cb22adeb0..08738d7148a 100644
--- a/src/mess/video/nubus_48gc.h
+++ b/src/mess/video/nubus_48gc.h
@@ -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();
diff --git a/src/mess/video/nubus_cb264.c b/src/mess/video/nubus_cb264.c
index bcc75ac0785..59178883e47 100644
--- a/src/mess/video/nubus_cb264.c
+++ b/src/mess/video/nubus_cb264.c
@@ -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;
 	}
 
diff --git a/src/mess/video/nubus_cb264.h b/src/mess/video/nubus_cb264.h
index ef9603e51a6..87ed546277e 100644
--- a/src/mess/video/nubus_cb264.h
+++ b/src/mess/video/nubus_cb264.h
@@ -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();
diff --git a/src/mess/video/nubus_m2hires.c b/src/mess/video/nubus_m2hires.c
index 212e4d28e9d..b5b239e0d3b 100644
--- a/src/mess/video/nubus_m2hires.c
+++ b/src/mess/video/nubus_m2hires.c
@@ -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;
diff --git a/src/mess/video/nubus_m2hires.h b/src/mess/video/nubus_m2hires.h
index 1883f8aaa81..99d2d1b5bf1 100644
--- a/src/mess/video/nubus_m2hires.h
+++ b/src/mess/video/nubus_m2hires.h
@@ -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();
diff --git a/src/mess/video/nubus_radiustpd.c b/src/mess/video/nubus_radiustpd.c
index 6bc2b2e3681..f9ffc42fbb5 100644
--- a/src/mess/video/nubus_radiustpd.c
+++ b/src/mess/video/nubus_radiustpd.c
@@ -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)];
 		}
 	}
 
diff --git a/src/mess/video/nubus_radiustpd.h b/src/mess/video/nubus_radiustpd.h
index 2b3d5f79e4e..f98387b3dbd 100644
--- a/src/mess/video/nubus_radiustpd.h
+++ b/src/mess/video/nubus_radiustpd.h
@@ -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();
diff --git a/src/mess/video/nubus_spec8.c b/src/mess/video/nubus_spec8.c
index 1950ce7c2ff..018a799fad4 100644
--- a/src/mess/video/nubus_spec8.c
+++ b/src/mess/video/nubus_spec8.c
@@ -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;
diff --git a/src/mess/video/nubus_spec8.h b/src/mess/video/nubus_spec8.h
index e43246f39a7..cf6a97c07fd 100644
--- a/src/mess/video/nubus_spec8.h
+++ b/src/mess/video/nubus_spec8.h
@@ -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();
diff --git a/src/mess/video/nubus_specpdq.c b/src/mess/video/nubus_specpdq.c
index 7a655de8f6f..24a16d4976e 100644
--- a/src/mess/video/nubus_specpdq.c
+++ b/src/mess/video/nubus_specpdq.c
@@ -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;
diff --git a/src/mess/video/nubus_specpdq.h b/src/mess/video/nubus_specpdq.h
index 83f5f68f11f..246129adad5 100644
--- a/src/mess/video/nubus_specpdq.h
+++ b/src/mess/video/nubus_specpdq.h
@@ -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();
diff --git a/src/mess/video/nubus_vikbw.c b/src/mess/video/nubus_vikbw.c
index a9124f1bb08..52a780d1937 100644
--- a/src/mess/video/nubus_vikbw.c
+++ b/src/mess/video/nubus_vikbw.c
@@ -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)];
 		}
 	}
 
diff --git a/src/mess/video/nubus_vikbw.h b/src/mess/video/nubus_vikbw.h
index f7e77146a70..faf754d3b59 100644
--- a/src/mess/video/nubus_vikbw.h
+++ b/src/mess/video/nubus_vikbw.h
@@ -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();
diff --git a/src/mess/video/nubus_wsportrait.c b/src/mess/video/nubus_wsportrait.c
index 73af0a3ad8e..cd8c52b98dd 100644
--- a/src/mess/video/nubus_wsportrait.c
+++ b/src/mess/video/nubus_wsportrait.c
@@ -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;
diff --git a/src/mess/video/nubus_wsportrait.h b/src/mess/video/nubus_wsportrait.h
index 0b0c62e8c3b..3da54601aa5 100644
--- a/src/mess/video/nubus_wsportrait.h
+++ b/src/mess/video/nubus_wsportrait.h
@@ -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();