removed space before m_gfxdecode in main trunk(nw)

src/mame/drivers/ace.c

@@ -98,19 +98,19 @@ UINT32 aceal_state::screen_update_ace(screen_device &screen, bitmap_ind16 &bitma
 	/* first of all, fill the screen with the background color */
 	bitmap.fill(0, cliprect);
 
-	 m_gfxdecode->gfx(1)->opaque(bitmap,cliprect,
+	m_gfxdecode->gfx(1)->opaque(bitmap,cliprect,
 			0,
 			0,
 			0, 0,
 			m_objpos[0], m_objpos[1]);
 
-	 m_gfxdecode->gfx(2)->opaque(bitmap,cliprect,
+	m_gfxdecode->gfx(2)->opaque(bitmap,cliprect,
 			0,
 			0,
 			0, 0,
 			m_objpos[2], m_objpos[3]);
 
-	 m_gfxdecode->gfx(3)->opaque(bitmap,cliprect,
+	m_gfxdecode->gfx(3)->opaque(bitmap,cliprect,
 			0,
 			0,
 			0, 0,
@@ -118,7 +118,7 @@ UINT32 aceal_state::screen_update_ace(screen_device &screen, bitmap_ind16 &bitma
 
 	for (offs = 0; offs < 8; offs++)
 	{
-		 m_gfxdecode->gfx(4)->opaque(bitmap,/* ?? */
+		m_gfxdecode->gfx(4)->opaque(bitmap,/* ?? */
 				cliprect,
 				offs,
 				0,

src/mame/drivers/acefruit.c

@@ -130,7 +130,7 @@ UINT32 acefruit_state::screen_update_acefruit(screen_device &screen, bitmap_ind1
 
 			if( color < 0x4 )
 			{
-				 m_gfxdecode->gfx(1)->opaque(bitmap,cliprect, code, color, 0, 0, col * 16, row * 8 );
+				m_gfxdecode->gfx(1)->opaque(bitmap,cliprect, code, color, 0, 0, col * 16, row * 8 );
 			}
 			else if( color >= 0x5 && color <= 0x7 )
 			{

src/mame/drivers/albazc.c

@@ -87,7 +87,7 @@ void albazc_state::draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect)
 			flipy = !flipy;
 		}
 
-		 m_gfxdecode->gfx(0)->transpen(bitmap,cliprect, code, color, flipx, flipy,
+		m_gfxdecode->gfx(0)->transpen(bitmap,cliprect, code, color, flipx, flipy,
 			sx, sy, 0);
 	}
 }

src/mame/drivers/astrcorp.c

@@ -149,7 +149,7 @@ void astrocorp_state::draw_sprites(bitmap_ind16 &bitmap, const rectangle &clipre
 				{
 					for (xwrap = 0 ; xwrap <= 0x200 ; xwrap += 0x200)
 					{
-						 m_gfxdecode->gfx(0)->transpen(bitmap,cliprect,
+						m_gfxdecode->gfx(0)->transpen(bitmap,cliprect,
 								code, 0,
 								0, 0,
 								sx + x * 16 - xwrap, sy + y * 16 - ywrap, 0xff);

src/mame/drivers/calorie.c

@@ -195,12 +195,12 @@ UINT32 calorie_state::screen_update_calorie(screen_device &screen, bitmap_ind16
 		if (m_sprites[x + 1] & 0x10)
 		{
 				/* 32x32 sprites */
-			 m_gfxdecode->gfx(3)->transpen(bitmap,cliprect, tileno | 0x40, color, flipx, flipy, xpos, ypos - 31, 0);
+			m_gfxdecode->gfx(3)->transpen(bitmap,cliprect, tileno | 0x40, color, flipx, flipy, xpos, ypos - 31, 0);
 		}
 		else
 		{
 			/* 16x16 sprites */
-			 m_gfxdecode->gfx(2)->transpen(bitmap,cliprect, tileno, color, flipx, flipy, xpos, ypos - 15, 0);
+			m_gfxdecode->gfx(2)->transpen(bitmap,cliprect, tileno, color, flipx, flipy, xpos, ypos - 15, 0);
 		}
 	}
 	return 0;

src/mame/drivers/cball.c

@@ -76,7 +76,7 @@ UINT32 cball_state::screen_update_cball(screen_device &screen, bitmap_ind16 &bit
 	m_bg_tilemap->draw(screen, bitmap, cliprect, 0, 0);
 
 	/* draw sprite */
-	 m_gfxdecode->gfx(1)->transpen(bitmap,cliprect,
+	m_gfxdecode->gfx(1)->transpen(bitmap,cliprect,
 		m_video_ram[0x399] >> 4,
 		0,
 		0, 0,

src/mame/drivers/chanbara.c

@@ -191,18 +191,18 @@ void chanbara_state::draw_sprites( bitmap_ind16 &bitmap, const rectangle &clipre
 			{
 				if (!flipy)
 				{
-					 m_gfxdecode->gfx(1)->transpen(bitmap,cliprect, code, color, flipx, flipy, sx, sy-16, 0);
-					 m_gfxdecode->gfx(1)->transpen(bitmap,cliprect, code+1, color, flipx, flipy, sx, sy, 0);
+					m_gfxdecode->gfx(1)->transpen(bitmap,cliprect, code, color, flipx, flipy, sx, sy-16, 0);
+					m_gfxdecode->gfx(1)->transpen(bitmap,cliprect, code+1, color, flipx, flipy, sx, sy, 0);
 				}
 				else
 				{
-					 m_gfxdecode->gfx(1)->transpen(bitmap,cliprect, code, color, flipx, flipy, sx, sy, 0);
-					 m_gfxdecode->gfx(1)->transpen(bitmap,cliprect, code+1, color, flipx, flipy, sx, sy-16, 0);
+					m_gfxdecode->gfx(1)->transpen(bitmap,cliprect, code, color, flipx, flipy, sx, sy, 0);
+					m_gfxdecode->gfx(1)->transpen(bitmap,cliprect, code+1, color, flipx, flipy, sx, sy-16, 0);
 				}
 			}
 			else
 			{
-				 m_gfxdecode->gfx(1)->transpen(bitmap,cliprect, code, color, flipx, flipy, sx, sy, 0);
+				m_gfxdecode->gfx(1)->transpen(bitmap,cliprect, code, color, flipx, flipy, sx, sy, 0);
 			}
 		}
 	}

src/mame/drivers/cntsteer.c

@@ -217,17 +217,17 @@ void cntsteer_state::zerotrgt_draw_sprites( bitmap_ind16 &bitmap, const rectangl
 		{
 			if (fy)
 			{
-				 m_gfxdecode->gfx(1)->transpen(bitmap,cliprect, code, color, fx, fy, sx, sy, 0);
-				 m_gfxdecode->gfx(1)->transpen(bitmap,cliprect, code + 1, color, fx, fy, sx, sy - 16, 0);
+				m_gfxdecode->gfx(1)->transpen(bitmap,cliprect, code, color, fx, fy, sx, sy, 0);
+				m_gfxdecode->gfx(1)->transpen(bitmap,cliprect, code + 1, color, fx, fy, sx, sy - 16, 0);
 			}
 			else
 			{
-				 m_gfxdecode->gfx(1)->transpen(bitmap,cliprect, code, color, fx, fy, sx, sy - 16, 0);
-				 m_gfxdecode->gfx(1)->transpen(bitmap,cliprect, code + 1, color, fx, fy, sx, sy, 0);
+				m_gfxdecode->gfx(1)->transpen(bitmap,cliprect, code, color, fx, fy, sx, sy - 16, 0);
+				m_gfxdecode->gfx(1)->transpen(bitmap,cliprect, code + 1, color, fx, fy, sx, sy, 0);
 			}
 		}
 		else
-			 m_gfxdecode->gfx(1)->transpen(bitmap,cliprect, code, color, fx, fy, sx, sy, 0);
+			m_gfxdecode->gfx(1)->transpen(bitmap,cliprect, code, color, fx, fy, sx, sy, 0);
 	}
 }
 
@@ -274,17 +274,17 @@ void cntsteer_state::cntsteer_draw_sprites( bitmap_ind16 &bitmap, const rectangl
 		{
 			if (fy)
 			{
-				 m_gfxdecode->gfx(1)->transpen(bitmap,cliprect, code, color, fx, fy, sx, sy, 0);
-				 m_gfxdecode->gfx(1)->transpen(bitmap,cliprect, code + 1, color, fx, fy, sx, sy - 16, 0);
+				m_gfxdecode->gfx(1)->transpen(bitmap,cliprect, code, color, fx, fy, sx, sy, 0);
+				m_gfxdecode->gfx(1)->transpen(bitmap,cliprect, code + 1, color, fx, fy, sx, sy - 16, 0);
 			}
 			else
 			{
-				 m_gfxdecode->gfx(1)->transpen(bitmap,cliprect, code, color, fx, fy, sx, sy - 16, 0);
-				 m_gfxdecode->gfx(1)->transpen(bitmap,cliprect, code + 1, color, fx, fy, sx, sy, 0);
+				m_gfxdecode->gfx(1)->transpen(bitmap,cliprect, code, color, fx, fy, sx, sy - 16, 0);
+				m_gfxdecode->gfx(1)->transpen(bitmap,cliprect, code + 1, color, fx, fy, sx, sy, 0);
 			}
 		}
 		else
-			 m_gfxdecode->gfx(1)->transpen(bitmap,cliprect, code, color, fx, fy, sx, sy, 0);
+			m_gfxdecode->gfx(1)->transpen(bitmap,cliprect, code, color, fx, fy, sx, sy, 0);
 	}
 }
 

src/mame/drivers/dacholer.c

@@ -151,7 +151,7 @@ void dacholer_state::draw_sprites( bitmap_ind16 &bitmap, const rectangle &clipre
 			flipy = !flipy;
 		}
 
-		 m_gfxdecode->gfx(2)->transpen(bitmap,cliprect,
+		m_gfxdecode->gfx(2)->transpen(bitmap,cliprect,
 				code,
 				0,
 				flipx,flipy,

src/mame/drivers/ddayjlc.c

@@ -408,7 +408,7 @@ UINT32 ddayjlc_state::screen_update_ddayjlc(screen_device &screen, bitmap_ind16
 
 		code = (code & 0x7f) | ((flags & 0x30) << 3);
 
-		 m_gfxdecode->gfx(0)->transpen(bitmap,cliprect, code, color, xflip, yflip, x, y, 0);
+		m_gfxdecode->gfx(0)->transpen(bitmap,cliprect, code, color, xflip, yflip, x, y, 0);
 	}
 
 	{
@@ -419,9 +419,9 @@ UINT32 ddayjlc_state::screen_update_ddayjlc(screen_device &screen, bitmap_ind16
 			{
 				c = m_videoram[y * 32 + x];
 				if (x > 1 && x < 30)
-					 m_gfxdecode->gfx(1)->transpen(bitmap,cliprect, c + m_char_bank * 0x100, 2, 0, 0, x*8, y*8, 0);
+					m_gfxdecode->gfx(1)->transpen(bitmap,cliprect, c + m_char_bank * 0x100, 2, 0, 0, x*8, y*8, 0);
 				else
-					 m_gfxdecode->gfx(1)->opaque(bitmap,cliprect, c + m_char_bank * 0x100, 2, 0, 0, x*8, y*8);
+					m_gfxdecode->gfx(1)->opaque(bitmap,cliprect, c + m_char_bank * 0x100, 2, 0, 0, x*8, y*8);
 			}
 	}
 	return 0;

src/mame/drivers/destroyr.c

@@ -98,7 +98,7 @@ UINT32 destroyr_state::screen_update_destroyr(screen_device &screen, bitmap_ind1
 				continue;
 		}
 
-		 m_gfxdecode->gfx(2)->transpen(bitmap,cliprect, num, 0, flipx, 0, horz, 16 * i, 0);
+		m_gfxdecode->gfx(2)->transpen(bitmap,cliprect, num, 0, flipx, 0, horz, 16 * i, 0);
 	}
 
 	/* draw alpha numerics */
@@ -108,7 +108,7 @@ UINT32 destroyr_state::screen_update_destroyr(screen_device &screen, bitmap_ind1
 		{
 			int num = m_alpha_num_ram[32 * i + j];
 
-			 m_gfxdecode->gfx(0)->transpen(bitmap,cliprect, num, 0, 0, 0, 8 * j, 8 * i, 0);
+			m_gfxdecode->gfx(0)->transpen(bitmap,cliprect, num, 0, 0, 0, 8 * j, 8 * i, 0);
 		}
 	}
 
@@ -119,13 +119,13 @@ UINT32 destroyr_state::screen_update_destroyr(screen_device &screen, bitmap_ind1
 		int horz = 256 - m_minor_obj_ram[i + 2];
 		int vert = 256 - m_minor_obj_ram[i + 4];
 
-		 m_gfxdecode->gfx(1)->transpen(bitmap,cliprect, num, 0, 0, 0, horz, vert, 0);
+		m_gfxdecode->gfx(1)->transpen(bitmap,cliprect, num, 0, 0, 0, horz, vert, 0);
 	}
 
 	/* draw waves */
 	for (i = 0; i < 4; i++)
 	{
-		 m_gfxdecode->gfx(3)->transpen(bitmap,cliprect, m_wavemod ? 1 : 0, 0, 0, 0, 64 * i, 0x4e, 0);
+		m_gfxdecode->gfx(3)->transpen(bitmap,cliprect, m_wavemod ? 1 : 0, 0, 0, 0, 64 * i, 0x4e, 0);
 	}
 
 	/* draw cursor */

src/mame/drivers/discoboy.c

@@ -200,7 +200,7 @@ UINT32 discoboy_state::screen_update_discoboy(screen_device &screen, bitmap_ind1
 					tileno = 0x2000 + (tileno & 0x1fff) + 0x0000;
 			}
 
-			 m_gfxdecode->gfx(1)->opaque(bitmap,cliprect, tileno, m_ram_att[count / 2], 0, 0, x*8, y*8);
+			m_gfxdecode->gfx(1)->opaque(bitmap,cliprect, tileno, m_ram_att[count / 2], 0, 0, x*8, y*8);
 			count += 2;
 		}
 	}

src/mame/drivers/dlair.c

@@ -256,7 +256,7 @@ UINT32 dlair_state::screen_update_dleuro(screen_device &screen, bitmap_ind16 &bi
 		for (x = 0; x < 32; x++)
 		{
 			UINT8 *base = &videoram[y * 64 + x * 2 + 1];
-			 m_gfxdecode->gfx(0)->opaque(bitmap,cliprect, base[0], base[1], 0, 0, 10 * x, 16 * y);
+			m_gfxdecode->gfx(0)->opaque(bitmap,cliprect, base[0], base[1], 0, 0, 10 * x, 16 * y);
 		}
 
 	return 0;

src/mame/drivers/dwarfd.c

@@ -837,7 +837,7 @@ void dwarfd_state::drawCrt( bitmap_rgb32 &bitmap,const rectangle &cliprect )
 				else
 					b = 1;
 			}
-			 m_gfxdecode->gfx(0)->transpen(bitmap,cliprect,
+			m_gfxdecode->gfx(0)->transpen(bitmap,cliprect,
 				tile + (m_bank + bank2) * 128,
 				0,
 				0, 0,

src/mame/drivers/esh.c

@@ -90,7 +90,7 @@ UINT32 esh_state::screen_update_esh(screen_device &screen, bitmap_rgb32 &bitmap,
 			//int blinkLine = (m_tile_control_ram[current_screen_character] & 0x40) >> 6;
 			//int blinkChar = (m_tile_control_ram[current_screen_character] & 0x80) >> 7;
 
-			 m_gfxdecode->gfx(0)->transpen(bitmap,cliprect,
+			m_gfxdecode->gfx(0)->transpen(bitmap,cliprect,
 					m_tile_ram[current_screen_character] + (0x100 * tileOffs),
 					palIndex,
 					0, 0, charx*8, chary*8, 0);

src/mame/drivers/firefox.c

@@ -249,7 +249,7 @@ UINT32 firefox_state::screen_update_firefox(screen_device &screen, bitmap_rgb32
 				int flipx = flags & 0x20;
 				int code = sprite_data[ 15 - row ] + ( 256 * ( ( flags >> 6 ) & 3 ) );
 
-				 m_gfxdecode->gfx( 1 )->transpen(bitmap,cliprect, code, color, flipx, flipy, x + 8, gfxtop + 500 - y - ( row * 16 ), 0 );
+				m_gfxdecode->gfx( 1 )->transpen(bitmap,cliprect, code, color, flipx, flipy, x + 8, gfxtop + 500 - y - ( row * 16 ), 0 );
 			}
 		}
 	}

src/mame/drivers/flyball.c

@@ -132,7 +132,7 @@ UINT32 flyball_state::screen_update_flyball(screen_device &screen, bitmap_ind16
 	m_tmap->draw(screen, bitmap, cliprect, 0, 0);
 
 	/* draw pitcher */
-	 m_gfxdecode->gfx(1)->transpen(bitmap,cliprect, m_pitcher_pic ^ 0xf, 0, 1, 0, pitcherx, pitchery, 1);
+	m_gfxdecode->gfx(1)->transpen(bitmap,cliprect, m_pitcher_pic ^ 0xf, 0, 1, 0, pitcherx, pitchery, 1);
 
 	/* draw ball */
 

src/mame/drivers/go2000.c

@@ -191,7 +191,7 @@ UINT32 go2000_state::screen_update_go2000(screen_device &screen, bitmap_ind16 &b
 		{
 			int tile = m_videoram[count];
 			int attr = m_videoram2[count];
-			 m_gfxdecode->gfx(0)->opaque(bitmap,cliprect, tile, attr, 0, 0, x * 8, y * 8);
+			m_gfxdecode->gfx(0)->opaque(bitmap,cliprect, tile, attr, 0, 0, x * 8, y * 8);
 			count++;
 		}
 	}
@@ -203,7 +203,7 @@ UINT32 go2000_state::screen_update_go2000(screen_device &screen, bitmap_ind16 &b
 		{
 			int tile = m_videoram[count];
 			int attr = m_videoram2[count];
-			 m_gfxdecode->gfx(0)->transpen(bitmap,cliprect, tile, attr, 0, 0, x * 8, y * 8, 0xf);
+			m_gfxdecode->gfx(0)->transpen(bitmap,cliprect, tile, attr, 0, 0, x * 8, y * 8, 0xf);
 			count++;
 		}
 	}

src/mame/drivers/gpworld.c

@@ -110,7 +110,7 @@ void gpworld_state::gpworld_draw_tiles(bitmap_rgb32 &bitmap,const rectangle &cli
 		{
 			int current_screen_character = (characterY*64) + characterX;
 
-			 m_gfxdecode->gfx(0)->transpen(bitmap,cliprect, m_tile_ram[current_screen_character],
+			m_gfxdecode->gfx(0)->transpen(bitmap,cliprect, m_tile_ram[current_screen_character],
 					characterY, 0, 0, characterX*8, characterY*8, 0);
 		}
 	}

src/mame/drivers/istellar.c

@@ -84,7 +84,7 @@ UINT32 istellar_state::screen_update_istellar(screen_device &screen, bitmap_rgb3
 			int tile = m_tile_ram[x+y*32];
 			int attr = m_tile_control_ram[x+y*32];
 
-			 m_gfxdecode->gfx(0)->transpen(bitmap,cliprect,tile,attr & 0x0f,0, 0, x*8, y*8, 0);
+			m_gfxdecode->gfx(0)->transpen(bitmap,cliprect,tile,attr & 0x0f,0, 0, x*8, y*8, 0);
 		}
 	}
 

src/mame/drivers/jclub2.c

@@ -220,7 +220,7 @@ void darkhors_state::draw_sprites_darkhors(bitmap_ind16 &bitmap, const rectangle
 		sy  =   -sy;
 		sy  +=  0xf8;
 
-		 m_gfxdecode->gfx(0)->transpen(bitmap,cliprect,
+		m_gfxdecode->gfx(0)->transpen(bitmap,cliprect,
 					code/2, color,
 					flipx,  flipy,  sx, sy, 0);
 	}

src/mame/drivers/lbeach.c

@@ -148,7 +148,7 @@ UINT32 lbeach_state::screen_update_lbeach(screen_device &screen, bitmap_ind16 &b
 	int sprite_y = 160;
 
 	m_colmap_car.fill(0, cliprect);
-	 m_gfxdecode->gfx(2)->transpen(m_colmap_car,cliprect, sprite_code, 0, 0, 0, sprite_x, sprite_y, 0);
+	m_gfxdecode->gfx(2)->transpen(m_colmap_car,cliprect, sprite_code, 0, 0, 0, sprite_x, sprite_y, 0);
 	bitmap_ind16 &fg_bitmap = m_fg_tilemap->pixmap();
 
 	m_collision_bg_car = 0;
@@ -167,7 +167,7 @@ UINT32 lbeach_state::screen_update_lbeach(screen_device &screen, bitmap_ind16 &b
 	m_fg_tilemap->draw(screen, bitmap, cliprect, 0, 0);
 
 	// draw player car
-	 m_gfxdecode->gfx(2)->transpen(bitmap,cliprect, sprite_code, 0, 0, 0, sprite_x, sprite_y, 0);
+	m_gfxdecode->gfx(2)->transpen(bitmap,cliprect, sprite_code, 0, 0, 0, sprite_x, sprite_y, 0);
 
 	return 0;
 }

src/mame/drivers/lgp.c

@@ -121,7 +121,7 @@ UINT32 lgp_state::screen_update_lgp(screen_device &screen, bitmap_rgb32 &bitmap,
 
 			/* Somewhere there's a flag that offsets the tilemap by 0x100*x */
 			/* Palette is likely set somewhere as well (tile_control_ram?) */
-			 m_gfxdecode->gfx(0)->transpen(bitmap,cliprect,
+			m_gfxdecode->gfx(0)->transpen(bitmap,cliprect,
 					m_tile_ram[current_screen_character],
 					0,
 					0, 0, charx*8, chary*8, 0);

src/mame/drivers/marinedt.c

@@ -529,14 +529,14 @@ UINT32 marinedt_state::screen_update_marinedt(screen_device &screen, bitmap_ind1
 	m_tx_tilemap->draw(screen, *m_tile, cliprect, 0, 0);
 
 	m_obj1->fill(0);
-	 m_gfxdecode->gfx(1)->transpen(*m_obj1,m_obj1->cliprect(),
+	m_gfxdecode->gfx(1)->transpen(*m_obj1,m_obj1->cliprect(),
 			OBJ_CODE(m_obj1_a),
 			OBJ_COLOR(m_obj1_a),
 			OBJ_FLIPX(m_obj1_a), OBJ_FLIPY(m_obj1_a),
 			0, 0, 0);
 
 	m_obj2->fill(0);
-	 m_gfxdecode->gfx(2)->transpen(*m_obj2,m_obj2->cliprect(),
+	m_gfxdecode->gfx(2)->transpen(*m_obj2,m_obj2->cliprect(),
 			OBJ_CODE(m_obj2_a),
 			OBJ_COLOR(m_obj2_a),
 			OBJ_FLIPX(m_obj2_a), OBJ_FLIPY(m_obj2_a),

src/mame/drivers/mgolf.c

@@ -88,14 +88,14 @@ UINT32 mgolf_state::screen_update_mgolf(screen_device &screen, bitmap_ind16 &bit
 	/* draw sprites */
 	for (i = 0; i < 2; i++)
 	{
-		 m_gfxdecode->gfx(1)->transpen(bitmap,cliprect,
+		m_gfxdecode->gfx(1)->transpen(bitmap,cliprect,
 			m_video_ram[0x399 + 4 * i],
 			i,
 			0, 0,
 			m_video_ram[0x390 + 2 * i] - 7,
 			m_video_ram[0x398 + 4 * i] - 16, 0);
 
-		 m_gfxdecode->gfx(1)->transpen(bitmap,cliprect,
+		m_gfxdecode->gfx(1)->transpen(bitmap,cliprect,
 			m_video_ram[0x39b + 4 * i],
 			i,
 			0, 0,

src/mame/drivers/midas.c

@@ -182,7 +182,7 @@ void midas_state::draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect)
 			UINT16 code     =   codes[y*2];
 			UINT16 attr     =   codes[y*2+1];
 
-			 m_gfxdecode->gfx(0)->zoom_transpen(bitmap,cliprect,
+			m_gfxdecode->gfx(0)->zoom_transpen(bitmap,cliprect,
 							code,
 							attr >> 8,
 							attr & 1, attr & 2,

src/mame/drivers/norautp.c

@@ -589,7 +589,7 @@ UINT32 norautp_state::screen_update_norautp(screen_device &screen, bitmap_ind16
 				int tile = m_np_vram[count] & 0x3f;
 				int colour = (m_np_vram[count] & 0xc0) >> 6;
 
-				 m_gfxdecode->gfx(1)->opaque(bitmap,cliprect, tile, colour, 0, 0, (x * 32) + 8, y * 32);
+				m_gfxdecode->gfx(1)->opaque(bitmap,cliprect, tile, colour, 0, 0, (x * 32) + 8, y * 32);
 
 				count+=2;
 			}
@@ -601,7 +601,7 @@ UINT32 norautp_state::screen_update_norautp(screen_device &screen, bitmap_ind16
 				int tile = m_np_vram[count] & 0x3f;
 				int colour = (m_np_vram[count] & 0xc0) >> 6;
 
-				 m_gfxdecode->gfx(0)->opaque(bitmap,cliprect, tile, colour, 0, 0, x * 16, y * 32);
+				m_gfxdecode->gfx(0)->opaque(bitmap,cliprect, tile, colour, 0, 0, x * 16, y * 32);
 
 				count++;
 			}

src/mame/drivers/pzletime.c

@@ -148,7 +148,7 @@ UINT32 pzletime_state::screen_update_pzletime(screen_device &screen, bitmap_ind1
 
 			// is spriteram[offs + 0] & 0x200 flipy? it's always set
 
-			 m_gfxdecode->gfx(1)->transpen(bitmap,cliprect, spr_offs, colour, 0, 1, sx, sy, 0);
+			m_gfxdecode->gfx(1)->transpen(bitmap,cliprect, spr_offs, colour, 0, 1, sx, sy, 0);
 		}
 	}
 

src/mame/drivers/sbrkout.c

@@ -347,7 +347,7 @@ UINT32 sbrkout_state::screen_update_sbrkout(screen_device &screen, bitmap_ind16
 		int sx = 31 * 8 - videoram[0x380 + 0x10 + ball * 2];
 		int sy = 30 * 8 - videoram[0x380 + 0x18 + ball * 2];
 
-		 m_gfxdecode->gfx(1)->transpen(bitmap,cliprect, code, 0, 0, 0, sx, sy, 0);
+		m_gfxdecode->gfx(1)->transpen(bitmap,cliprect, code, 0, 0, 0, sx, sy, 0);
 	}
 	return 0;
 }

src/mame/drivers/seabattl.c

@@ -156,7 +156,7 @@ UINT32 seabattl_state::screen_update_seabattl(screen_device &screen, bitmap_ind1
 		{
 			for ( x = 0; x < 32; x++ )
 			{
-				 m_gfxdecode->gfx(2)->opaque(bitmap,cliprect, (y & 0x0f) + (((x & 0x0f) + ((screen.frame_number() & 0xe0) >> 4)) << 4), 0, 0, 0, x*8, y*8 );
+				m_gfxdecode->gfx(2)->opaque(bitmap,cliprect, (y & 0x0f) + (((x & 0x0f) + ((screen.frame_number() & 0xe0) >> 4)) << 4), 0, 0, 0, x*8, y*8 );
 			}
 		}
 	}
@@ -180,7 +180,7 @@ UINT32 seabattl_state::screen_update_seabattl(screen_device &screen, bitmap_ind1
 			int x = ((offset & 0x0f) << 4) - ((m_objram[offset] & 0xf0) >> 4);
 			int y = (offset & 0xf0);
 
-			 m_gfxdecode->gfx(0)->transpen(bitmap,cliprect, code, 0, 0, 0, x, y, 0);
+			m_gfxdecode->gfx(0)->transpen(bitmap,cliprect, code, 0, 0, 0, x, y, 0);
 		}
 	}
 

src/mame/drivers/segald.c

@@ -77,7 +77,7 @@ void segald_state::astron_draw_characters(bitmap_rgb32 &bitmap,const rectangle &
 		for (characterY = 0; characterY < 32; characterY++)
 		{
 			int current_screen_character = (characterY*32) + characterX;
-			 m_gfxdecode->gfx(0)->transpen(bitmap,cliprect, m_fix_ram[current_screen_character],
+			m_gfxdecode->gfx(0)->transpen(bitmap,cliprect, m_fix_ram[current_screen_character],
 					1, 0, 0, characterX*8, characterY*8, 0);
 		}
 	}

src/mame/drivers/sigmab98.c

@@ -300,7 +300,7 @@ void sigmab98_state::draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprec
 		{
 			for (x = x0; x != x1; x += dx)
 			{
-				 m_gfxdecode->gfx(gfx)->zoom_transpen(bitmap,cliprect,
+				m_gfxdecode->gfx(gfx)->zoom_transpen(bitmap,cliprect,
 										code++, color,
 										flipx, flipy,
 										(sx + x * dim) / 0x10000, (sy + y * dim) / 0x10000,

src/mame/drivers/supdrapo.c

@@ -125,7 +125,7 @@ UINT32 supdrapo_state::screen_update_supdrapo(screen_device &screen, bitmap_ind1
 			/* Global Column Coloring, GUESS! */
 			color = m_col_line[(x*2) + 1] ? (m_col_line[(x*2) + 1] - 1) & 7 : 0;
 
-			 m_gfxdecode->gfx(0)->opaque(bitmap,cliprect, tile,color, 0, 0, x*8, y*8);
+			m_gfxdecode->gfx(0)->opaque(bitmap,cliprect, tile,color, 0, 0, x*8, y*8);
 
 			count++;
 		}

src/mame/drivers/vroulet.c

@@ -123,7 +123,7 @@ void vroulet_state::video_start()
 UINT32 vroulet_state::screen_update_vroulet(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
 {
 	m_bg_tilemap->draw(screen, bitmap, cliprect, 0, 0);
-	 m_gfxdecode->gfx(0)->transpen(bitmap,cliprect, 0x320, 1, 0, 0,
+	m_gfxdecode->gfx(0)->transpen(bitmap,cliprect, 0x320, 1, 0, 0,
 		m_ball[1], m_ball[0] - 12, 0);
 	return 0;
 }

src/mame/video/1943.c

@@ -234,12 +234,12 @@ void _1943_state::draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect,
 		if (priority)
 		{
 			if (color != 0x0a && color != 0x0b)
-				 m_gfxdecode->gfx(3)->transpen(bitmap,cliprect, code, color, flip_screen(), flip_screen(), sx, sy, 0);
+				m_gfxdecode->gfx(3)->transpen(bitmap,cliprect, code, color, flip_screen(), flip_screen(), sx, sy, 0);
 		}
 		else
 		{
 			if (color == 0x0a || color == 0x0b)
-				 m_gfxdecode->gfx(3)->transpen(bitmap,cliprect, code, color, flip_screen(), flip_screen(), sx, sy, 0);
+				m_gfxdecode->gfx(3)->transpen(bitmap,cliprect, code, color, flip_screen(), flip_screen(), sx, sy, 0);
 		}
 	}
 }

src/mame/video/aeroboto.c

@@ -135,7 +135,7 @@ void aeroboto_state::draw_sprites( bitmap_ind16 &bitmap, const rectangle &clipre
 			y = 240 - y;
 		}
 
-		 m_gfxdecode->gfx(1)->transpen(bitmap,cliprect,
+		m_gfxdecode->gfx(1)->transpen(bitmap,cliprect,
 				m_spriteram[offs + 1],
 				m_spriteram[offs + 2] & 0x07,
 				flip_screen(), flip_screen(),

src/mame/video/alpha68k.c

@@ -473,7 +473,7 @@ void alpha68k_state::kyros_draw_sprites( bitmap_ind16 &bitmap, const rectangle &
 					else
 						jongbou_video_banking(&bank, data);
 
-					 m_gfxdecode->gfx(bank)->transpen(bitmap,cliprect, tile, color, fx, fy, mx, my, 0);
+					m_gfxdecode->gfx(bank)->transpen(bitmap,cliprect, tile, color, fx, fy, mx, my, 0);
 				}
 			}
 //ZT
@@ -532,7 +532,7 @@ void alpha68k_state::sstingry_draw_sprites( bitmap_ind16 &bitmap, const rectangl
 				color = (data >> 7 & 0x18) | (data >> 13 & 7);
 				tile = data & 0x3ff;
 				bank = data >> 10 & 3;
-				 m_gfxdecode->gfx(bank)->transpen(bitmap,cliprect, tile, color, fx, fy, mx, my, 0);
+				m_gfxdecode->gfx(bank)->transpen(bitmap,cliprect, tile, color, fx, fy, mx, my, 0);
 			}
 //ZT
 			if(m_flipscreen)

src/mame/video/atarifb.c

@@ -139,14 +139,14 @@ void atarifb_state::draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprec
 		{
 			shade = ((m_spriteram[obj * 2 + 1 + 0x20]) & 0x07);
 
-			 m_gfxdecode->gfx(gfx + 1)->transpen(bitmap,bigfield_area,
+			m_gfxdecode->gfx(gfx + 1)->transpen(bitmap,bigfield_area,
 				charcode, shade,
 				flipx, flipy, sx, sy, 0);
 
 			shade = ((m_spriteram[obj * 2 + 1 + 0x20]) & 0x08) >> 3;
 		}
 
-		 m_gfxdecode->gfx(gfx)->transpen(bitmap,bigfield_area,
+		m_gfxdecode->gfx(gfx)->transpen(bitmap,bigfield_area,
 				charcode, shade,
 				flipx, flipy, sx, sy, 0);
 
@@ -158,7 +158,7 @@ void atarifb_state::draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprec
 			if ((charcode == 0x11) && (sy == 0x07))
 			{
 				sy = 0xf1; /* When multiplexed, it's 0x10...why? */
-				 m_gfxdecode->gfx(gfx)->transpen(bitmap,bigfield_area,
+				m_gfxdecode->gfx(gfx)->transpen(bitmap,bigfield_area,
 					charcode, 0,
 					flipx, flipy, sx, sy, 0);
 			}

src/mame/video/bigevglf.c

@@ -74,7 +74,7 @@ void bigevglf_state::draw_sprites( bitmap_ind16 &bitmap, const rectangle &clipre
 		sx = m_spriteram2[i + 3];
 		sy = 200 - m_spriteram2[i];
 		for (j = 0; j < 16; j++)
-			 m_gfxdecode->gfx(0)->transpen(bitmap,cliprect,
+			m_gfxdecode->gfx(0)->transpen(bitmap,cliprect,
 				m_spriteram1[(code << 4) + j] + ((m_spriteram1[0x400 + (code << 4) + j] & 0xf) << 8),
 				m_spriteram2[i + 2] & 0xf,
 				0,0,

src/mame/video/bking.c

@@ -229,20 +229,20 @@ UINT32 bking_state::screen_update_bking(screen_device &screen, bitmap_ind16 &bit
 	m_bg_tilemap->draw(screen, bitmap, cliprect, 0, 0);
 
 	/* draw the balls */
-	 m_gfxdecode->gfx(2)->transpen(bitmap,cliprect,
+	m_gfxdecode->gfx(2)->transpen(bitmap,cliprect,
 		m_ball1_pic,
 		m_palette_bank,
 		0, 0,
 		m_xld1, m_yld1, 0);
 
-	 m_gfxdecode->gfx(3)->transpen(bitmap,cliprect,
+	m_gfxdecode->gfx(3)->transpen(bitmap,cliprect,
 		m_ball2_pic,
 		m_palette_bank,
 		0, 0,
 		m_xld2, m_yld2, 0);
 
 	/* draw the crow */
-	 m_gfxdecode->gfx(1)->transpen(bitmap,cliprect,
+	m_gfxdecode->gfx(1)->transpen(bitmap,cliprect,
 		m_crow_pic,
 		m_palette_bank,
 		m_crow_flip, m_crow_flip,
@@ -269,7 +269,7 @@ void bking_state::screen_eof_bking(screen_device &screen, bool state)
 			xld = m_xld1;
 			yld = m_yld1;
 
-			 m_gfxdecode->gfx(2)->opaque(m_colmap_ball,rect, m_ball1_pic, 0, 0, 0, 0, 0);
+			m_gfxdecode->gfx(2)->opaque(m_colmap_ball,rect, m_ball1_pic, 0, 0, 0, 0, 0);
 
 			latch = 0x0c00;
 		}
@@ -278,7 +278,7 @@ void bking_state::screen_eof_bking(screen_device &screen, bool state)
 			xld = m_xld2;
 			yld = m_yld2;
 
-			 m_gfxdecode->gfx(3)->opaque(m_colmap_ball,rect, m_ball2_pic, 0, 0, 0, 0, 0);
+			m_gfxdecode->gfx(3)->opaque(m_colmap_ball,rect, m_ball2_pic, 0, 0, 0, 0, 0);
 
 			latch = 0x0400;
 		}

src/mame/video/blueprnt.c

@@ -145,7 +145,7 @@ void blueprnt_state::draw_sprites( bitmap_ind16 &bitmap, const rectangle &clipre
 		}
 
 		// sprites are slightly misplaced, regardless of the screen flip
-		 m_gfxdecode->gfx(1)->transpen(bitmap,cliprect, code, 0, flipx, flipy, 2 + sx, sy - 1, 0);
+		m_gfxdecode->gfx(1)->transpen(bitmap,cliprect, code, 0, flipx, flipy, 2 + sx, sy - 1, 0);
 	}
 }
 

src/mame/video/bsktball.c

@@ -44,7 +44,7 @@ void bsktball_state::draw_sprites(  bitmap_ind16 &bitmap, const rectangle &clipr
 		pic = (pic & 0x3f);
 		color = (color & 0x3f);
 
-		 m_gfxdecode->gfx(1)->transpen(bitmap,cliprect, pic, color, flipx, 0, sx, sy, 0);
+		m_gfxdecode->gfx(1)->transpen(bitmap,cliprect, pic, color, flipx, 0, sx, sy, 0);
 	}
 }
 

src/mame/video/btime.c

@@ -494,7 +494,7 @@ UINT32 btime_state::screen_update_bnj(screen_device &screen, bitmap_ind16 &bitma
 				sy = 256 - sy;
 			}
 
-			 m_gfxdecode->gfx(2)->opaque(*m_background_bitmap,m_background_bitmap->cliprect(),
+			m_gfxdecode->gfx(2)->opaque(*m_background_bitmap,m_background_bitmap->cliprect(),
 					(m_bnj_backgroundram[offs] >> 4) + ((offs & 0x80) >> 3) + 32,
 					0,
 					flip_screen(), flip_screen(),
@@ -540,7 +540,7 @@ UINT32 btime_state::screen_update_cookrace(screen_device &screen, bitmap_ind16 &
 			sy = 33 - sy;
 		}
 
-		 m_gfxdecode->gfx(2)->opaque(bitmap,cliprect,
+		m_gfxdecode->gfx(2)->opaque(bitmap,cliprect,
 				m_bnj_backgroundram[offs],
 				0,
 				flip_screen(), flip_screen(),

src/mame/video/buggychl.c

@@ -105,7 +105,7 @@ void buggychl_state::draw_bg( bitmap_ind16 &bitmap, const rectangle &cliprect )
 		if (flip_screen_y())
 			sy = 31 - sy;
 
-		 m_gfxdecode->gfx(0)->opaque(m_tmp_bitmap1,m_tmp_bitmap1.cliprect(),
+		m_gfxdecode->gfx(0)->opaque(m_tmp_bitmap1,m_tmp_bitmap1.cliprect(),
 				code,
 				2,
 				flip_screen_x(),flip_screen_y(),

src/mame/video/carjmbre.c

@@ -145,7 +145,7 @@ UINT32 carjmbre_state::screen_update_carjmbre(screen_device &screen, bitmap_ind1
 				flipy = !flipy;
 			}
 
-			 m_gfxdecode->gfx(1)->transpen(bitmap,cliprect,
+			m_gfxdecode->gfx(1)->transpen(bitmap,cliprect,
 					m_spriteram[troffs + 1],
 					m_spriteram[troffs + 2] & 0xf,
 					flipx,flipy,

src/mame/video/ccastles.c

@@ -267,7 +267,7 @@ UINT32 ccastles_state::screen_update_ccastles(screen_device &screen, bitmap_ind1
 		int which = spriteaddr[offs];
 		int color = spriteaddr[offs + 2] >> 7;
 
-		 m_gfxdecode->gfx(0)->transpen(m_spritebitmap,cliprect, which, color, flip, flip, x, y, 7);
+		m_gfxdecode->gfx(0)->transpen(m_spritebitmap,cliprect, which, color, flip, flip, x, y, 7);
 	}
 
 	/* draw the bitmap to the screen, looping over Y */

src/mame/video/centiped.c

@@ -439,7 +439,7 @@ UINT32 centiped_state::screen_update_centiped(screen_device &screen, bitmap_ind1
 		int x = spriteram[offs + 0x20];
 		int y = 240 - spriteram[offs + 0x10];
 
-		 m_gfxdecode->gfx(1)->transmask(bitmap,spriteclip, code, color, flipx, flipy, x, y, m_penmask[color & 0x3f]);
+		m_gfxdecode->gfx(1)->transmask(bitmap,spriteclip, code, color, flipx, flipy, x, y, m_penmask[color & 0x3f]);
 	}
 	return 0;
 }
@@ -484,7 +484,7 @@ UINT32 centiped_state::screen_update_warlords(screen_device &screen, bitmap_ind1
 			flipx = !flipx;
 		}
 
-		 m_gfxdecode->gfx(1)->transpen(bitmap,cliprect, code, color, flipx, flipy, x, y, 0);
+		m_gfxdecode->gfx(1)->transpen(bitmap,cliprect, code, color, flipx, flipy, x, y, 0);
 	}
 	return 0;
 }
@@ -515,7 +515,7 @@ UINT32 centiped_state::screen_update_bullsdrt(screen_device &screen, bitmap_ind1
 		int x = spriteram[offs + 0x20];
 		int y = 240 - spriteram[offs + 0x10];
 
-		 m_gfxdecode->gfx(1)->transpen(bitmap,spriteclip, code, color & 0x3f, 1, flipy, x, y, 0);
+		m_gfxdecode->gfx(1)->transpen(bitmap,spriteclip, code, color & 0x3f, 1, flipy, x, y, 0);
 	}
 	return 0;
 }
@@ -552,7 +552,7 @@ UINT32 centiped_state::screen_update_milliped(screen_device &screen, bitmap_ind1
 			flipy = !flipy;
 		}
 
-		 m_gfxdecode->gfx(1)->transmask(bitmap,spriteclip, code, color, flipx, flipy, x, y, m_penmask[color & 0x3f]);
+		m_gfxdecode->gfx(1)->transmask(bitmap,spriteclip, code, color, flipx, flipy, x, y, m_penmask[color & 0x3f]);
 	}
 	return 0;
 }

src/mame/video/citycon.c

@@ -117,7 +117,7 @@ void citycon_state::draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprec
 			flipx = !flipx;
 		}
 
-		 m_gfxdecode->gfx(m_spriteram[offs + 1] & 0x80 ? 2 : 1)->transpen(bitmap,cliprect,
+		m_gfxdecode->gfx(m_spriteram[offs + 1] & 0x80 ? 2 : 1)->transpen(bitmap,cliprect,
 				m_spriteram[offs + 1] & 0x7f,
 				m_spriteram[offs + 2] & 0x0f,
 				flipx,flip_screen(),

src/mame/video/cloak.c

@@ -212,7 +212,7 @@ void cloak_state::draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect)
 			flipy = !flipy;
 		}
 
-		 m_gfxdecode->gfx(1)->transpen(bitmap,cliprect, code, 0, flipx, flipy,   sx, sy, 0);
+		m_gfxdecode->gfx(1)->transpen(bitmap,cliprect, code, 0, flipx, flipy,   sx, sy, 0);
 	}
 }
 

src/mame/video/cloud9.c

@@ -253,9 +253,9 @@ UINT32 cloud9_state::screen_update_cloud9(screen_device &screen, bitmap_ind16 &b
 			int which = spriteaddr[offs + 0x20];
 			int color = 0;
 
-			 m_gfxdecode->gfx(0)->transpen(m_spritebitmap,cliprect, which, color, xflip, yflip, x, y, 0);
+			m_gfxdecode->gfx(0)->transpen(m_spritebitmap,cliprect, which, color, xflip, yflip, x, y, 0);
 			if (x >= 256 - 16)
-				 m_gfxdecode->gfx(0)->transpen(m_spritebitmap,cliprect, which, color, xflip, yflip, x - 256, y, 0);
+				m_gfxdecode->gfx(0)->transpen(m_spritebitmap,cliprect, which, color, xflip, yflip, x - 256, y, 0);
 		}
 
 	/* draw the bitmap to the screen, looping over Y */

src/mame/video/commando.c

@@ -113,7 +113,7 @@ void commando_state::draw_sprites( bitmap_ind16 &bitmap, const rectangle &clipre
 		}
 
 		if (bank < 3)
-			 m_gfxdecode->gfx(2)->transpen(bitmap,cliprect, code, color, flipx, flipy, sx, sy, 15);
+			m_gfxdecode->gfx(2)->transpen(bitmap,cliprect, code, color, flipx, flipy, sx, sy, 15);
 	}
 }
 

src/mame/video/cvs.c

@@ -154,7 +154,7 @@ UINT32 cvs_state::screen_update_cvs(screen_device &screen, bitmap_ind16 &bitmap,
 
 		int gfxnum = (code < ram_based_char_start_indices[m_character_banking_mode]) ? 0 : 1;
 
-		 m_gfxdecode->gfx(gfxnum)->opaque(m_background_bitmap,m_background_bitmap.cliprect(),
+		m_gfxdecode->gfx(gfxnum)->opaque(m_background_bitmap,m_background_bitmap.cliprect(),
 				code, color,
 				0, 0,
 				x, y);
@@ -170,7 +170,7 @@ UINT32 cvs_state::screen_update_cvs(screen_device &screen, bitmap_ind16 &bitmap,
 				collision_color = 0x102;
 		}
 
-		 m_gfxdecode->gfx(gfxnum)->opaque(m_collision_background,m_collision_background.cliprect(),
+		m_gfxdecode->gfx(gfxnum)->opaque(m_collision_background,m_collision_background.cliprect(),
 				code, collision_color,
 				0, 0,
 				x, y);

src/mame/video/decocass.c

@@ -248,10 +248,10 @@ void decocass_state::draw_object(bitmap_ind16 &bitmap, const rectangle &cliprect
 	else
 		sx = 91 - (m_part_h_shift & 0x7f);
 
-	 m_gfxdecode->gfx(3)->transpen(bitmap,cliprect, 0, color, 0, 0, sx + 64, sy, 0);
-	 m_gfxdecode->gfx(3)->transpen(bitmap,cliprect, 1, color, 0, 0, sx, sy, 0);
-	 m_gfxdecode->gfx(3)->transpen(bitmap,cliprect, 0, color, 0, 1, sx + 64, sy - 64, 0);
-	 m_gfxdecode->gfx(3)->transpen(bitmap,cliprect, 1, color, 0, 1, sx, sy - 64, 0);
+	m_gfxdecode->gfx(3)->transpen(bitmap,cliprect, 0, color, 0, 0, sx + 64, sy, 0);
+	m_gfxdecode->gfx(3)->transpen(bitmap,cliprect, 1, color, 0, 0, sx, sy, 0);
+	m_gfxdecode->gfx(3)->transpen(bitmap,cliprect, 0, color, 0, 1, sx + 64, sy - 64, 0);
+	m_gfxdecode->gfx(3)->transpen(bitmap,cliprect, 1, color, 0, 1, sx, sy - 64, 0);
 }
 
 void decocass_state::draw_center(bitmap_ind16 &bitmap, const rectangle &cliprect)
@@ -515,7 +515,7 @@ void decocass_state::draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprec
 
 		sy -= sprite_y_adjust;
 
-		 m_gfxdecode->gfx(1)->transpen(bitmap,cliprect,
+		m_gfxdecode->gfx(1)->transpen(bitmap,cliprect,
 				sprite_ram[offs + interleave],
 				color,
 				flipx,flipy,
@@ -524,7 +524,7 @@ void decocass_state::draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprec
 		sy += (flip_screen() ? -256 : 256);
 
 		// Wrap around
-		 m_gfxdecode->gfx(1)->transpen(bitmap,cliprect,
+		m_gfxdecode->gfx(1)->transpen(bitmap,cliprect,
 				sprite_ram[offs + interleave],
 				color,
 				flipx,flipy,

src/mame/video/dkong.c

@@ -632,11 +632,11 @@ void dkong_state::draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect,
 			}
 			y = scanline - ((y + add_y + 1 + scanline_vfc) & 0x0F);
 
-			 m_gfxdecode->gfx(1)->transpen(bitmap,cliprect, code, color, flipx, flipy, x, y, 0);
+			m_gfxdecode->gfx(1)->transpen(bitmap,cliprect, code, color, flipx, flipy, x, y, 0);
 
 			// wraparound
-			 m_gfxdecode->gfx(1)->transpen(bitmap,cliprect, code, color, flipx, flipy, m_flip ? x + 256 : x - 256, y, 0);
-			 m_gfxdecode->gfx(1)->transpen(bitmap,cliprect, code, color, flipx, flipy, x, y - 256, 0);
+			m_gfxdecode->gfx(1)->transpen(bitmap,cliprect, code, color, flipx, flipy, m_flip ? x + 256 : x - 256, y, 0);
+			m_gfxdecode->gfx(1)->transpen(bitmap,cliprect, code, color, flipx, flipy, x, y - 256, 0);
 
 			num_sprt++;
 		}

src/mame/video/equites.c

@@ -275,7 +275,7 @@ void equites_state::equites_draw_sprites_block( bitmap_ind16 &bitmap, const rect
 			// sprites are 16x14 centered in a 16x16 square, so skip the first line
 			sy += 1;
 
-			 m_gfxdecode->gfx(2)->transmask(bitmap,cliprect,
+			m_gfxdecode->gfx(2)->transmask(bitmap,cliprect,
 					tile,
 					color,
 					fx, fy,

src/mame/video/exerion.c

@@ -406,7 +406,7 @@ UINT32 exerion_state::screen_update_exerion(screen_device &screen, bitmap_ind16
 			int y = m_cocktail_flip ? (31*8 - 8*sy) : 8*sy;
 
 			offs = sx + sy * 64;
-			 m_gfxdecode->gfx(0)->transpen(bitmap,cliprect,
+			m_gfxdecode->gfx(0)->transpen(bitmap,cliprect,
 				m_videoram[offs] + 256 * m_char_bank,
 				((m_videoram[offs] & 0xf0) >> 4) + m_char_palette * 16,
 				m_cocktail_flip, m_cocktail_flip, x, y, 0);

src/mame/video/exidy.c

@@ -216,7 +216,7 @@ void exidy_state::draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect)
 	int sx = 236 - *m_sprite2_xpos - 4;
 	int sy = 244 - *m_sprite2_ypos - 4;
 
-	 m_gfxdecode->gfx(0)->transpen(bitmap,cliprect,
+	m_gfxdecode->gfx(0)->transpen(bitmap,cliprect,
 			((*m_spriteno >> 4) & 0x0f) + 32 + 16 * sprite_set_2, 1,
 			0, 0, sx, sy, 0);
 
@@ -230,7 +230,7 @@ void exidy_state::draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect)
 
 		if (sy < 0) sy = 0;
 
-		 m_gfxdecode->gfx(0)->transpen(bitmap,cliprect,
+		m_gfxdecode->gfx(0)->transpen(bitmap,cliprect,
 				(*m_spriteno & 0x0f) + 16 * sprite_set_1, 0,
 				0, 0, sx, sy, 0);
 	}
@@ -295,7 +295,7 @@ void exidy_state::check_collision()
 	{
 		org_1_x = 236 - *m_sprite1_xpos - 4;
 		org_1_y = 244 - *m_sprite1_ypos - 4;
-		 m_gfxdecode->gfx(0)->transpen(m_motion_object_1_vid,clip,
+		m_gfxdecode->gfx(0)->transpen(m_motion_object_1_vid,clip,
 				(*m_spriteno & 0x0f) + 16 * sprite_set_1, 0,
 				0, 0, 0, 0, 0);
 	}
@@ -304,7 +304,7 @@ void exidy_state::check_collision()
 	m_motion_object_2_vid.fill(0xff, clip);
 	org_2_x = 236 - *m_sprite2_xpos - 4;
 	org_2_y = 244 - *m_sprite2_ypos - 4;
-	 m_gfxdecode->gfx(0)->transpen(m_motion_object_2_vid,clip,
+	m_gfxdecode->gfx(0)->transpen(m_motion_object_2_vid,clip,
 			((*m_spriteno >> 4) & 0x0f) + 32 + 16 * sprite_set_2, 0,
 			0, 0, 0, 0, 0);
 
@@ -314,7 +314,7 @@ void exidy_state::check_collision()
 	{
 		sx = org_2_x - org_1_x;
 		sy = org_2_y - org_1_y;
-		 m_gfxdecode->gfx(0)->transpen(m_motion_object_2_clip,clip,
+		m_gfxdecode->gfx(0)->transpen(m_motion_object_2_clip,clip,
 				((*m_spriteno >> 4) & 0x0f) + 32 + 16 * sprite_set_2, 0,
 				0, 0, sx, sy, 0);
 	}

src/mame/video/exprraid.c

@@ -109,7 +109,7 @@ void exprraid_state::draw_sprites( bitmap_ind16 &bitmap, const rectangle &clipre
 			flipy = !flipy;
 		}
 
-		 m_gfxdecode->gfx(1)->transpen(bitmap,cliprect,
+		m_gfxdecode->gfx(1)->transpen(bitmap,cliprect,
 			code, color,
 			flipx, flipy,
 			sx, sy, 0);
@@ -118,7 +118,7 @@ void exprraid_state::draw_sprites( bitmap_ind16 &bitmap, const rectangle &clipre
 
 		if (attr & 0x10)
 		{
-			 m_gfxdecode->gfx(1)->transpen(bitmap,cliprect,
+			m_gfxdecode->gfx(1)->transpen(bitmap,cliprect,
 				code + 1, color,
 				flipx, flipy,
 				sx, sy + (flip_screen() ? -16 : 16), 0);

src/mame/video/exzisus.c

@@ -136,7 +136,7 @@ UINT32 exzisus_state::screen_update_exzisus(screen_device &screen, bitmap_ind16
 					y = 248 - y;
 				}
 
-				 m_gfxdecode->gfx(0)->transpen(bitmap,cliprect,
+				m_gfxdecode->gfx(0)->transpen(bitmap,cliprect,
 						code & 0x3fff,
 						color,
 						flip_screen(), flip_screen(),
@@ -205,7 +205,7 @@ UINT32 exzisus_state::screen_update_exzisus(screen_device &screen, bitmap_ind16
 					y = 248 - y;
 				}
 
-				 m_gfxdecode->gfx(1)->transpen(bitmap,cliprect,
+				m_gfxdecode->gfx(1)->transpen(bitmap,cliprect,
 						code & 0x3fff,
 						color,
 						flip_screen(), flip_screen(),

src/mame/video/fcombat.c

@@ -201,7 +201,7 @@ UINT32 fcombat_state::screen_update_fcombat(screen_device &screen, bitmap_ind16
 			int y = m_cocktail_flip ? (31 * 8 - 8 * sy) : 8 * sy;
 
 			offs = sx + sy * 64;
-			 m_gfxdecode->gfx(0)->transpen(bitmap,cliprect,
+			m_gfxdecode->gfx(0)->transpen(bitmap,cliprect,
 				m_videoram[offs] + 256 * m_char_bank,
 				((m_videoram[offs] & 0xf0) >> 4) + m_char_palette * 16,
 				m_cocktail_flip, m_cocktail_flip, x, y, 0);

src/mame/video/fgoal.c

@@ -48,14 +48,14 @@ UINT32 fgoal_state::screen_update_fgoal(screen_device &screen, bitmap_ind16 &bit
 
 	if (m_fgoal_player == 1 && (ioport("IN1")->read() & 0x40))
 	{
-		 m_gfxdecode->gfx(0)->zoom_opaque(m_fgbitmap,cliprect,
+		m_gfxdecode->gfx(0)->zoom_opaque(m_fgbitmap,cliprect,
 			0, (m_fgoal_player << 2) | m_current_color,
 			1, 1,
 			0, 16,
 			0x40000,
 			0x40000);
 
-		 m_gfxdecode->gfx(1)->zoom_opaque(m_bgbitmap,cliprect,
+		m_gfxdecode->gfx(1)->zoom_opaque(m_bgbitmap,cliprect,
 			0, 0,
 			1, 1,
 			0, 16,
@@ -64,14 +64,14 @@ UINT32 fgoal_state::screen_update_fgoal(screen_device &screen, bitmap_ind16 &bit
 	}
 	else
 	{
-		 m_gfxdecode->gfx(0)->zoom_opaque(m_fgbitmap,cliprect,
+		m_gfxdecode->gfx(0)->zoom_opaque(m_fgbitmap,cliprect,
 			0, (m_fgoal_player << 2) | m_current_color,
 			0, 0,
 			0, 0,
 			0x40000,
 			0x40000);
 
-		 m_gfxdecode->gfx(1)->zoom_opaque(m_bgbitmap,cliprect,
+		m_gfxdecode->gfx(1)->zoom_opaque(m_bgbitmap,cliprect,
 			0, 0,
 			0, 0,
 			0, 0,

src/mame/video/funkybee.c

@@ -111,7 +111,7 @@ void funkybee_state::draw_sprites( bitmap_ind16 &bitmap, const rectangle &clipre
 			flipx = !flipx;
 		}
 
-		 m_gfxdecode->gfx(2 + m_gfx_bank)->transpen(bitmap,cliprect,
+		m_gfxdecode->gfx(2 + m_gfx_bank)->transpen(bitmap,cliprect,
 			code, color,
 			flipx, flipy,
 			sx, sy, 0);

src/mame/video/funybubl.c

@@ -65,7 +65,7 @@ void funybubl_state::draw_sprites( bitmap_ind16 &bitmap, const rectangle &clipre
 
 		// bits 0x40 and 0x10 not used?...
 
-		 m_gfxdecode->gfx(1)->transpen(bitmap,cliprect, tile, 0, 0, 0, xpos, ypos, 255);
+		m_gfxdecode->gfx(1)->transpen(bitmap,cliprect, tile, 0, 0, 0, xpos, ypos, 255);
 		source -= 0x20;
 	}
 }
@@ -86,7 +86,7 @@ UINT32 funybubl_state::screen_update_funybubl(screen_device &screen, bitmap_ind1
 			int data;
 
 			data = m_banked_vram[offs] | (m_banked_vram[offs + 1] << 8);
-			 m_gfxdecode->gfx(0)->transpen(bitmap,cliprect, data & 0x7fff, (data & 0x8000) ? 2 : 1, 0, 0, x*8, y*8, 0);
+			m_gfxdecode->gfx(0)->transpen(bitmap,cliprect, data & 0x7fff, (data & 0x8000) ? 2 : 1, 0, 0, x*8, y*8, 0);
 			offs += 2;
 		}
 	}

src/mame/video/galaxold.c

@@ -1700,7 +1700,7 @@ void galaxold_state::draw_sprites(bitmap_ind16 &bitmap, UINT8 *spriteram, size_t
 		if (offs < 3*4)  sy++;
 
 
-		 m_gfxdecode->gfx(1)->transpen(bitmap,m_flipscreen_x ? spritevisibleareaflipx : spritevisiblearea,
+		m_gfxdecode->gfx(1)->transpen(bitmap,m_flipscreen_x ? spritevisibleareaflipx : spritevisiblearea,
 				code,color,
 				flipx,flipy,
 				sx,sy,0);

src/mame/video/gberet.c

@@ -155,7 +155,7 @@ void gberet_state::gberet_draw_sprites( bitmap_ind16 &bitmap, const rectangle &c
 				flipy = !flipy;
 			}
 
-			 m_gfxdecode->gfx(1)->transmask(bitmap,cliprect, code, color, flipx, flipy, sx, sy,
+			m_gfxdecode->gfx(1)->transmask(bitmap,cliprect, code, color, flipx, flipy, sx, sy,
 				colortable_get_transpen_mask(machine().colortable, m_gfxdecode->gfx(1), color, 0));
 		}
 	}
@@ -207,7 +207,7 @@ void gberet_state::gberetb_draw_sprites( bitmap_ind16 &bitmap, const rectangle &
 				flipy = !flipy;
 			}
 
-			 m_gfxdecode->gfx(1)->transmask(bitmap,cliprect, code, color, flipx, flipy, sx, sy,
+			m_gfxdecode->gfx(1)->transmask(bitmap,cliprect, code, color, flipx, flipy, sx, sy,
 				colortable_get_transpen_mask(machine().colortable, m_gfxdecode->gfx(1), color, 0));
 		}
 	}

src/mame/video/gunsmoke.c

@@ -162,7 +162,7 @@ void gunsmoke_state::draw_sprites( bitmap_ind16 &bitmap, const rectangle &clipre
 			flipy = !flipy;
 		}
 
-		 m_gfxdecode->gfx(2)->transpen(bitmap,cliprect, code, color, flipx, flipy, sx, sy, 0);
+		m_gfxdecode->gfx(2)->transpen(bitmap,cliprect, code, color, flipx, flipy, sx, sy, 0);
 	}
 }
 

src/mame/video/himesiki.c

@@ -78,7 +78,7 @@ void himesiki_state::himesiki_draw_sprites( bitmap_ind16 &bitmap, const rectangl
 				y -= 0x100;
 		}
 
-		 m_gfxdecode->gfx(1)->transpen(bitmap,cliprect, code, col, fx, fy, x, y, 15);
+		m_gfxdecode->gfx(1)->transpen(bitmap,cliprect, code, col, fx, fy, x, y, 15);
 	}
 
 	for (offs = 0; offs < 0x100; offs += 4)
@@ -107,7 +107,7 @@ void himesiki_state::himesiki_draw_sprites( bitmap_ind16 &bitmap, const rectangl
 		if (y > 0xf0)
 			y -= 0x100;
 
-		 m_gfxdecode->gfx(2)->transpen(bitmap,cliprect, code, col, f, f, x, y, 15);
+		m_gfxdecode->gfx(2)->transpen(bitmap,cliprect, code, col, f, f, x, y, 15);
 	}
 }
 

src/mame/video/homerun.c

@@ -122,14 +122,14 @@ void homerun_state::draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprec
 		int flipx = (spriteram[offs + 2] & 0x40) >> 6;
 		int flipy = (spriteram[offs + 2] & 0x80) >> 7;
 
-		 m_gfxdecode->gfx(1)->transpen(bitmap,cliprect,
+		m_gfxdecode->gfx(1)->transpen(bitmap,cliprect,
 				code,
 				color,
 				flipx,flipy,
 				sx,sy,0);
 
 		// wraparound
-		 m_gfxdecode->gfx(1)->transpen(bitmap,cliprect,
+		m_gfxdecode->gfx(1)->transpen(bitmap,cliprect,
 				code,
 				color,
 				flipx,flipy,

src/mame/video/ikki.c

@@ -91,7 +91,7 @@ void ikki_state::draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect )
 		if (y > 240)
 			y = y - 256;
 
-		 m_gfxdecode->gfx(1)->transmask(m_sprite_bitmap,cliprect,
+		m_gfxdecode->gfx(1)->transmask(m_sprite_bitmap,cliprect,
 				code, color,
 				m_flipscreen,m_flipscreen,
 				x,y,

src/mame/video/jailbrek.c

@@ -85,7 +85,7 @@ void jailbrek_state::draw_sprites( bitmap_ind16 &bitmap, const rectangle &clipre
 			flipy = !flipy;
 		}
 
-		 m_gfxdecode->gfx(1)->transmask(bitmap,cliprect, code, color, flipx, flipy,
+		m_gfxdecode->gfx(1)->transmask(bitmap,cliprect, code, color, flipx, flipy,
 			sx, sy,
 			colortable_get_transpen_mask(machine().colortable, m_gfxdecode->gfx(1), color, 0));
 	}

src/mame/video/karnov.c

@@ -99,10 +99,10 @@ void karnov_state::draw_background( bitmap_ind16 &bitmap, const rectangle &clipr
 		color = tile >> 12;
 		tile = tile & 0x7ff;
 		if (m_flipscreen)
-			 m_gfxdecode->gfx(1)->opaque(*m_bitmap_f,m_bitmap_f->cliprect(),tile,
+			m_gfxdecode->gfx(1)->opaque(*m_bitmap_f,m_bitmap_f->cliprect(),tile,
 				color, fx, fy, 496-16*mx,496-16*my);
 		else
-			 m_gfxdecode->gfx(1)->opaque(*m_bitmap_f,m_bitmap_f->cliprect(),tile,
+			m_gfxdecode->gfx(1)->opaque(*m_bitmap_f,m_bitmap_f->cliprect(),tile,
 				color, fx, fy, 16*mx,16*my);
 	}
 

src/mame/video/kchamp.c

@@ -89,7 +89,7 @@ void kchamp_state::kchamp_draw_sprites( bitmap_ind16 &bitmap, const rectangle &c
 			flipy = !flipy;
 		}
 
-		 m_gfxdecode->gfx(bank)->transpen(bitmap,cliprect, code, color, flipx, flipy, sx, sy, 0);
+		m_gfxdecode->gfx(bank)->transpen(bitmap,cliprect, code, color, flipx, flipy, sx, sy, 0);
 	}
 }
 
@@ -117,7 +117,7 @@ void kchamp_state::kchampvs_draw_sprites( bitmap_ind16 &bitmap, const rectangle
 			flipy = !flipy;
 		}
 
-		 m_gfxdecode->gfx(bank)->transpen(bitmap,cliprect, code, color, flipx, flipy, sx, sy, 0);
+		m_gfxdecode->gfx(bank)->transpen(bitmap,cliprect, code, color, flipx, flipy, sx, sy, 0);
 	}
 }
 

src/mame/video/kingobox.c

@@ -232,7 +232,7 @@ void kingofb_state::kingofb_draw_sprites(bitmap_ind16 &bitmap, const rectangle &
 			flipy = !flipy;
 		}
 
-		 m_gfxdecode->gfx(2 + bank)->transpen(bitmap,cliprect,
+		m_gfxdecode->gfx(2 + bank)->transpen(bitmap,cliprect,
 			code, color,
 			flipx, flipy,
 			sx, sy, 0);
@@ -289,7 +289,7 @@ void kingofb_state::ringking_draw_sprites( bitmap_ind16 &bitmap, const rectangle
 			flipy = !flipy;
 		}
 
-		 m_gfxdecode->gfx(2 + bank)->transpen(bitmap,cliprect,
+		m_gfxdecode->gfx(2 + bank)->transpen(bitmap,cliprect,
 			code, color,
 			flipx, flipy,
 			sx, sy, 0);

src/mame/video/lasso.c

@@ -301,7 +301,7 @@ void lasso_state::draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect,
 		code = source[1] & 0x3f;
 		color = source[2] & 0x0f;
 
-		 m_gfxdecode->gfx(1)->transpen(bitmap,cliprect,
+		m_gfxdecode->gfx(1)->transpen(bitmap,cliprect,
 				code | ((UINT16)m_gfxbank << 6),
 				color,
 				flipx, flipy,

src/mame/video/lordgun.c

@@ -273,7 +273,7 @@ void lordgun_state::draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect
 		{
 			for (x = x0; x != x1; x += dx)
 			{
-				 m_gfxdecode->gfx(4)->transpen(bitmap,cliprect,
+				m_gfxdecode->gfx(4)->transpen(bitmap,cliprect,
 									code, color + pri * 0x800/0x40,
 									flipx, flipy,
 									sx + x * 0x10, sy + y * 0x10,

src/mame/video/m52.c

@@ -410,7 +410,7 @@ UINT32 m52_state::screen_update_m52(screen_device &screen, bitmap_ind16 &bitmap,
 		clip = cliprect;
 #endif
 
-		 m_gfxdecode->gfx(1)->transmask(bitmap,clip,
+		m_gfxdecode->gfx(1)->transmask(bitmap,clip,
 			code, color, flipx, flipy, sx, sy,
 			colortable_get_transpen_mask(machine().colortable, m_gfxdecode->gfx(1), color, 512 + 32));
 	}

src/mame/video/m57.c

@@ -241,7 +241,7 @@ void m57_state::draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect)
 			flipy = !flipy;
 		}
 
-		 m_gfxdecode->gfx(1 + bank)->transmask(bitmap,cliprect,
+		m_gfxdecode->gfx(1 + bank)->transmask(bitmap,cliprect,
 			tile_number,
 			color,
 			flipx, flipy,

src/mame/video/madalien.c

@@ -148,8 +148,8 @@ VIDEO_START_MEMBER(madalien_state,madalien)
 
 	m_gfxdecode->gfx(0)->set_source(m_charram);
 
-	 m_gfxdecode->gfx(2)->opaque(*m_headlight_bitmap,m_headlight_bitmap->cliprect(), 0, 0, 0, 0, 0x00, 0x00);
-	 m_gfxdecode->gfx(2)->opaque(*m_headlight_bitmap,m_headlight_bitmap->cliprect(), 0, 0, 0, 1, 0x00, 0x40);
+	m_gfxdecode->gfx(2)->opaque(*m_headlight_bitmap,m_headlight_bitmap->cliprect(), 0, 0, 0, 0, 0x00, 0x00);
+	m_gfxdecode->gfx(2)->opaque(*m_headlight_bitmap,m_headlight_bitmap->cliprect(), 0, 0, 0, 1, 0x00, 0x40);
 }
 
 

src/mame/video/magmax.c

@@ -200,7 +200,7 @@ UINT32 magmax_state::screen_update_magmax(screen_device &screen, bitmap_ind16 &b
 			if (code & 0x80)    /* sprite bankswitch */
 				code += (*m_vreg & 0x30) * 0x8;
 
-			 m_gfxdecode->gfx(1)->transmask(bitmap,cliprect,
+			m_gfxdecode->gfx(1)->transmask(bitmap,cliprect,
 					code,
 					color,
 					flipx, flipy,
@@ -230,7 +230,7 @@ UINT32 magmax_state::screen_update_magmax(screen_device &screen, bitmap_ind16 &b
 				sy = 31 - sy;
 			}
 
-			 m_gfxdecode->gfx(0)->transpen(bitmap,cliprect,
+			m_gfxdecode->gfx(0)->transpen(bitmap,cliprect,
 					code,
 					0,
 					m_flipscreen, m_flipscreen,

src/mame/video/malzak.c

@@ -38,7 +38,7 @@ UINT32 malzak_state::screen_update_malzak(screen_device &screen, bitmap_rgb32 &b
 			if (sx < -15*2)
 				sx += 256*2;
 
-			 m_gfxdecode->gfx(0)->zoom_transpen(bitmap,cliprect, m_playfield_code[x * 16 + y], 2, 0, 0, sx, sy, 0x20000, 0x20000, 0);
+			m_gfxdecode->gfx(0)->zoom_transpen(bitmap,cliprect, m_playfield_code[x * 16 + y], 2, 0, 0, sx, sy, 0x20000, 0x20000, 0);
 		}
 
 	/* update the S2636 chips */

src/mame/video/matmania.c

@@ -137,7 +137,7 @@ UINT32 matmania_state::screen_update_matmania(screen_device &screen, bitmap_ind1
 		int sx = 15 - offs / 32;
 		int sy = offs % 32;
 
-		 m_gfxdecode->gfx(1)->opaque(*m_tmpbitmap,m_tmpbitmap->cliprect(),
+		m_gfxdecode->gfx(1)->opaque(*m_tmpbitmap,m_tmpbitmap->cliprect(),
 				m_videoram[offs] + ((m_colorram[offs] & 0x08) << 5),
 				(m_colorram[offs] & 0x30) >> 4,
 				0,sy >= 16, /* flip horizontally tiles on the right half of the bitmap */
@@ -150,7 +150,7 @@ UINT32 matmania_state::screen_update_matmania(screen_device &screen, bitmap_ind1
 		int sx = 15 - offs / 32;
 		int sy = offs % 32;
 
-		 m_gfxdecode->gfx(1)->opaque(*m_tmpbitmap2,m_tmpbitmap2->cliprect(),
+		m_gfxdecode->gfx(1)->opaque(*m_tmpbitmap2,m_tmpbitmap2->cliprect(),
 				m_videoram3[offs] + ((m_colorram3[offs] & 0x08) << 5),
 				(m_colorram3[offs] & 0x30) >> 4,
 				0,sy >= 16, /* flip horizontally tiles on the right half of the bitmap */
@@ -172,7 +172,7 @@ UINT32 matmania_state::screen_update_matmania(screen_device &screen, bitmap_ind1
 	{
 		if (spriteram[offs] & 0x01)
 		{
-			 m_gfxdecode->gfx(2)->transpen(bitmap,cliprect,
+			m_gfxdecode->gfx(2)->transpen(bitmap,cliprect,
 					spriteram[offs + 1] + ((spriteram[offs] & 0xf0) << 4),
 					(spriteram[offs] & 0x08) >> 3,
 					spriteram[offs] & 0x04, spriteram[offs] & 0x02,
@@ -208,7 +208,7 @@ UINT32 matmania_state::screen_update_maniach(screen_device &screen, bitmap_ind16
 		int sx = 15 - offs / 32;
 		int sy = offs % 32;
 
-		 m_gfxdecode->gfx(1)->opaque(*m_tmpbitmap,m_tmpbitmap->cliprect(),
+		m_gfxdecode->gfx(1)->opaque(*m_tmpbitmap,m_tmpbitmap->cliprect(),
 				m_videoram[offs] + ((m_colorram[offs] & 0x03) << 8),
 				(m_colorram[offs] & 0x30) >> 4,
 				0,sy >= 16, /* flip horizontally tiles on the right half of the bitmap */
@@ -221,7 +221,7 @@ UINT32 matmania_state::screen_update_maniach(screen_device &screen, bitmap_ind16
 		int sx = 15 - offs / 32;
 		int sy = offs % 32;
 
-		 m_gfxdecode->gfx(1)->opaque(*m_tmpbitmap2,m_tmpbitmap2->cliprect(),
+		m_gfxdecode->gfx(1)->opaque(*m_tmpbitmap2,m_tmpbitmap2->cliprect(),
 				m_videoram3[offs] + ((m_colorram3[offs] & 0x03) << 8),
 				(m_colorram3[offs] & 0x30) >> 4,
 				0,sy >= 16, /* flip horizontally tiles on the right half of the bitmap */

src/mame/video/meadows.c

@@ -88,7 +88,7 @@ void meadows_state::draw_sprites(bitmap_ind16 &bitmap, const rectangle &clip)
 		int bank = i;                           /* that fixes it for now :-/ */
 		int flip = spriteram[i+8] >> 5;         /* bit #5 flip vertical flag */
 
-		 m_gfxdecode->gfx(bank + 1)->transpen(bitmap,clip, code, 0, flip, 0, x, y, 0);
+		m_gfxdecode->gfx(bank + 1)->transpen(bitmap,clip, code, 0, flip, 0, x, y, 0);
 	}
 }
 

src/mame/video/megazone.c

@@ -133,7 +133,7 @@ UINT32 megazone_state::screen_update_megazone(screen_device &screen, bitmap_ind1
 			flipy = !flipy;
 		}
 
-		 m_gfxdecode->gfx(1)->opaque(*m_tmpbitmap,m_tmpbitmap->cliprect(),
+		m_gfxdecode->gfx(1)->opaque(*m_tmpbitmap,m_tmpbitmap->cliprect(),
 				((int)m_videoram[offs]) + ((m_colorram[offs] & (1 << 7) ? 256 : 0) ),
 				(m_colorram[offs] & 0x0f) + 0x10,
 				flipx,flipy,
@@ -213,7 +213,7 @@ UINT32 megazone_state::screen_update_megazone(screen_device &screen, bitmap_ind1
 
 
 
-			 m_gfxdecode->gfx(1)->opaque(bitmap,cliprect,
+			m_gfxdecode->gfx(1)->opaque(bitmap,cliprect,
 					((int)m_videoram2[offs]) + ((m_colorram2[offs] & (1 << 7) ? 256 : 0) ),
 					(m_colorram2[offs] & 0x0f) + 0x10,
 					flipx,flipy,

src/mame/video/mermaid.c

@@ -310,7 +310,7 @@ void mermaid_state::screen_eof_mermaid(screen_device &screen, bool state)
 
 			m_bg_tilemap->draw(screen, m_helper, rect, 0, 0);
 
-			 m_gfxdecode->gfx(1)->transpen(m_helper2,rect, code, 0, flipx, flipy, sx, sy, 0);
+			m_gfxdecode->gfx(1)->transpen(m_helper2,rect, code, 0, flipx, flipy, sx, sy, 0);
 
 			m_coll_bit2 |= collision_check(rect);
 
@@ -321,7 +321,7 @@ void mermaid_state::screen_eof_mermaid(screen_device &screen, bool state)
 
 			m_fg_tilemap->draw(screen, m_helper, rect, 0, 0);
 
-			 m_gfxdecode->gfx(1)->transpen(m_helper2,rect, code, 0, flipx, flipy, sx, sy, 0);
+			m_gfxdecode->gfx(1)->transpen(m_helper2,rect, code, 0, flipx, flipy, sx, sy, 0);
 
 			m_coll_bit1 |= collision_check(rect);
 
@@ -359,10 +359,10 @@ void mermaid_state::screen_eof_mermaid(screen_device &screen, bool state)
 						sy2 = 240 - sy2;
 					}
 
-					 m_gfxdecode->gfx(1)->transpen(m_helper,rect, code2, 0, flipx2, flipy2, sx2, sy2, 0);
+					m_gfxdecode->gfx(1)->transpen(m_helper,rect, code2, 0, flipx2, flipy2, sx2, sy2, 0);
 				}
 
-			 m_gfxdecode->gfx(1)->transpen(m_helper2,rect, code, 0, flipx, flipy, sx, sy, 0);
+			m_gfxdecode->gfx(1)->transpen(m_helper2,rect, code, 0, flipx, flipy, sx, sy, 0);
 
 			m_coll_bit0 |= collision_check(rect);
 		}
@@ -440,10 +440,10 @@ void mermaid_state::screen_eof_mermaid(screen_device &screen, bool state)
 						sy2 = 240 - sy2;
 					}
 
-					 m_gfxdecode->gfx(1)->transpen(m_helper,rect, code2, 0, flipx2, flipy2, sx2, sy2, 0);
+					m_gfxdecode->gfx(1)->transpen(m_helper,rect, code2, 0, flipx2, flipy2, sx2, sy2, 0);
 				}
 
-			 m_gfxdecode->gfx(1)->transpen(m_helper2,rect, code, 0, flipx, flipy, sx, sy, 0);
+			m_gfxdecode->gfx(1)->transpen(m_helper2,rect, code, 0, flipx, flipy, sx, sy, 0);
 
 			m_coll_bit3 |= collision_check(rect);
 		}
@@ -521,10 +521,10 @@ void mermaid_state::screen_eof_mermaid(screen_device &screen, bool state)
 						sy2 = 240 - sy2;
 					}
 
-					 m_gfxdecode->gfx(1)->transpen(m_helper,rect, code2, 0, flipx2, flipy2, sx2, sy2, 0);
+					m_gfxdecode->gfx(1)->transpen(m_helper,rect, code2, 0, flipx2, flipy2, sx2, sy2, 0);
 				}
 
-			 m_gfxdecode->gfx(1)->transpen(m_helper2,rect, code, 0, flipx, flipy, sx, sy, 0);
+			m_gfxdecode->gfx(1)->transpen(m_helper2,rect, code, 0, flipx, flipy, sx, sy, 0);
 
 			m_coll_bit6 |= collision_check(rect);
 		}

src/mame/video/mrdo.c

@@ -242,7 +242,7 @@ void mrdo_state::draw_sprites( bitmap_ind16 &bitmap,const rectangle &cliprect )
 	{
 		if (spriteram[offs + 1] != 0)
 		{
-			 m_gfxdecode->gfx(2)->transpen(bitmap,cliprect,
+			m_gfxdecode->gfx(2)->transpen(bitmap,cliprect,
 					spriteram[offs], spriteram[offs + 2] & 0x0f,
 					spriteram[offs + 2] & 0x10, spriteram[offs + 2] & 0x20,
 					spriteram[offs + 3], 256 - spriteram[offs + 1], 0);

src/mame/video/mrjong.c

@@ -133,7 +133,7 @@ void mrjong_state::draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect
 			flipy = !flipy;
 		}
 
-		 m_gfxdecode->gfx(1)->transpen(bitmap,cliprect,
+		m_gfxdecode->gfx(1)->transpen(bitmap,cliprect,
 				sprt,
 				color,
 				flipx, flipy,

src/mame/video/nycaptor.c

@@ -173,7 +173,7 @@ void nycaptor_state::draw_sprites( bitmap_ind16 &bitmap, const rectangle &clipre
 			flipx = BIT(m_spriteram[offs + 1], 6);
 			flipy = BIT(m_spriteram[offs + 1], 7);
 
-			 m_gfxdecode->gfx(1)->transpen(bitmap,cliprect,
+			m_gfxdecode->gfx(1)->transpen(bitmap,cliprect,
 					code,
 					pal,
 					flipx,flipy,
@@ -182,7 +182,7 @@ void nycaptor_state::draw_sprites( bitmap_ind16 &bitmap, const rectangle &clipre
 			if (m_spriteram[offs + 3] > 240)
 			{
 				sx = (m_spriteram[offs + 3] - 256);
-				 m_gfxdecode->gfx(1)->transpen(bitmap,cliprect,
+				m_gfxdecode->gfx(1)->transpen(bitmap,cliprect,
 					code,
 					pal,
 					flipx,flipy,

src/mame/video/orbit.c

@@ -69,7 +69,7 @@ void orbit_state::draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect
 		hpos <<= 1;
 		vpos <<= 1;
 
-		 m_gfxdecode->gfx(layout)->zoom_transpen(bitmap,cliprect, code, 0, flip_x, flip_y,
+		m_gfxdecode->gfx(layout)->zoom_transpen(bitmap,cliprect, code, 0, flip_x, flip_y,
 			hpos, vpos, zoom_x, zoom_y, 0);
 	}
 }

src/mame/video/pktgaldx.c

@@ -43,7 +43,7 @@ UINT32 pktgaldx_state::screen_update_pktgaldb(screen_device &screen, bitmap_ind1
 		y &= 0x1ff;
 		y -= 8;
 
-		 m_gfxdecode->gfx(0)->transpen(bitmap,cliprect, tileno ^ 0x1000, colour, 0, 0, x, y, 0);
+		m_gfxdecode->gfx(0)->transpen(bitmap,cliprect, tileno ^ 0x1000, colour, 0, 0, x, y, 0);
 	}
 
 	for (offset = 0x1600/2; offset < 0x2000 / 2; offset += 8)
@@ -57,7 +57,7 @@ UINT32 pktgaldx_state::screen_update_pktgaldb(screen_device &screen, bitmap_ind1
 		y &= 0x1ff;
 		y -= 8;
 
-		 m_gfxdecode->gfx(0)->transpen(bitmap,cliprect, tileno ^ 0x4000, colour, 0, 0, x, y, 0);
+		m_gfxdecode->gfx(0)->transpen(bitmap,cliprect, tileno ^ 0x4000, colour, 0, 0, x, y, 0);
 	}
 
 	for (offset = 0x2000/2; offset < 0x4000 / 2; offset += 8)
@@ -71,7 +71,7 @@ UINT32 pktgaldx_state::screen_update_pktgaldb(screen_device &screen, bitmap_ind1
 		y &= 0x1ff;
 		y -= 8;
 
-		 m_gfxdecode->gfx(0)->transpen(bitmap,cliprect, tileno ^ 0x3000, colour, 0, 0, x, y, 0);
+		m_gfxdecode->gfx(0)->transpen(bitmap,cliprect, tileno ^ 0x3000, colour, 0, 0, x, y, 0);
 	}
 
 	return 0;

src/mame/video/polyplay.c

@@ -57,7 +57,7 @@ UINT32 polyplay_state::screen_update_polyplay(screen_device &screen, bitmap_ind1
 		int sy = offs >> 6 << 3;
 		UINT8 code = videoram[offs];
 
-		 m_gfxdecode->gfx((code >> 7) & 0x01)->opaque(bitmap,cliprect,
+		m_gfxdecode->gfx((code >> 7) & 0x01)->opaque(bitmap,cliprect,
 				code, 0, 0, 0, sx, sy);
 	}
 

src/mame/video/poolshrk.c

@@ -40,7 +40,7 @@ UINT32 poolshrk_state::screen_update_poolshrk(screen_device &screen, bitmap_ind1
 		int hpos = m_hpos_ram[i];
 		int vpos = m_vpos_ram[i];
 
-		 m_gfxdecode->gfx(0)->transpen(bitmap,cliprect, i, (i == 0) ? 0 : 1, 0, 0,
+		m_gfxdecode->gfx(0)->transpen(bitmap,cliprect, i, (i == 0) ? 0 : 1, 0, 0,
 			248 - hpos, vpos - 15, 0);
 	}
 

src/mame/video/popper.c

@@ -213,7 +213,7 @@ void popper_state::draw_sprites( bitmap_ind16 &bitmap,const rectangle &cliprect
 				flipy = !flipy;
 			}
 
-			 m_gfxdecode->gfx(1)->transpen(bitmap,cliprect,
+			m_gfxdecode->gfx(1)->transpen(bitmap,cliprect,
 					m_spriteram[offs + 1],
 					(m_spriteram[offs + 2] & 0x0f),
 					flipx,flipy,

src/mame/video/prehisle.c

@@ -147,7 +147,7 @@ void prehisle_state::draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprec
 
 		if ((foreground && priority) || (!foreground && !priority))
 		{
-			 m_gfxdecode->gfx(3)->transpen(bitmap,cliprect, code, color, flipx, flipy, sx, sy, 15);
+			m_gfxdecode->gfx(3)->transpen(bitmap,cliprect, code, color, flipx, flipy, sx, sy, 15);
 		}
 	}
 }

src/mame/video/renegade.c

@@ -103,7 +103,7 @@ void renegade_state::draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprec
 			if (attributes & 0x80) /* big sprite */
 			{
 				sprite_number &= ~1;
-				 m_gfxdecode->gfx(sprite_bank)->transpen(bitmap,cliprect,
+				m_gfxdecode->gfx(sprite_bank)->transpen(bitmap,cliprect,
 					sprite_number + 1,
 					color,
 					xflip, flip_screen(),
@@ -113,7 +113,7 @@ void renegade_state::draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprec
 			{
 				sy += (flip_screen() ? -16 : 16);
 			}
-			 m_gfxdecode->gfx(sprite_bank)->transpen(bitmap,cliprect,
+			m_gfxdecode->gfx(sprite_bank)->transpen(bitmap,cliprect,
 				sprite_number,
 				color,
 				xflip, flip_screen(),

src/mame/video/rocnrope.c

@@ -129,7 +129,7 @@ void rocnrope_state::draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprec
 	{
 		int color = spriteram_2[offs] & 0x0f;
 
-		 m_gfxdecode->gfx(0)->transmask(bitmap,cliprect,
+		m_gfxdecode->gfx(0)->transmask(bitmap,cliprect,
 				spriteram[offs + 1],
 				color,
 				spriteram_2[offs] & 0x40,~spriteram_2[offs] & 0x80,

src/mame/video/rpunch.c

@@ -218,7 +218,7 @@ void rpunch_state::draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect,
 		if (x >= BITMAP_WIDTH) x -= 512;
 		if (y >= BITMAP_HEIGHT) y -= 512;
 
-		 m_gfxdecode->gfx(2)->transpen(bitmap,cliprect,
+		m_gfxdecode->gfx(2)->transpen(bitmap,cliprect,
 				code, color + (m_sprite_palette / 16), xflip, yflip, x, y, 15);
 	}
 }

src/mame/video/runaway.c

@@ -101,13 +101,13 @@ UINT32 runaway_state::screen_update_runaway(screen_device &screen, bitmap_ind16
 
 		code |= (m_sprite_ram[i + 0x30] << 2) & 0x1c0;
 
-		 m_gfxdecode->gfx(1)->transpen(bitmap,cliprect,
+		m_gfxdecode->gfx(1)->transpen(bitmap,cliprect,
 			code,
 			0,
 			flipx, flipy,
 			x, 240 - y, 0);
 
-		 m_gfxdecode->gfx(1)->transpen(bitmap,cliprect,
+		m_gfxdecode->gfx(1)->transpen(bitmap,cliprect,
 			code,
 			0,
 			flipx, flipy,
@@ -135,13 +135,13 @@ UINT32 runaway_state::screen_update_qwak(screen_device &screen, bitmap_ind16 &bi
 
 		code |= (m_sprite_ram[i + 0x30] << 2) & 0x1c0;
 
-		 m_gfxdecode->gfx(1)->transpen(bitmap,cliprect,
+		m_gfxdecode->gfx(1)->transpen(bitmap,cliprect,
 			code,
 			0,
 			flipx, flipy,
 			x, 240 - y, 0);
 
-		 m_gfxdecode->gfx(1)->transpen(bitmap,cliprect,
+		m_gfxdecode->gfx(1)->transpen(bitmap,cliprect,
 			code,
 			0,
 			flipx, flipy,

src/mame/video/sauro.c

@@ -128,7 +128,7 @@ void sauro_state::sauro_draw_sprites(bitmap_ind16 &bitmap, const rectangle &clip
 			sy = 240 - sy;
 		}
 
-		 m_gfxdecode->gfx(2)->transpen(bitmap,cliprect,
+		m_gfxdecode->gfx(2)->transpen(bitmap,cliprect,
 				code,
 				color,
 				flipx, flipy,

src/mame/video/scotrsht.c

@@ -114,7 +114,7 @@ void scotrsht_state::draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprec
 			flipy = !flipy;
 		}
 
-		 m_gfxdecode->gfx(1)->transmask(bitmap,cliprect, code, color, flipx, flipy,
+		m_gfxdecode->gfx(1)->transmask(bitmap,cliprect, code, color, flipx, flipy,
 			sx, sy,
 			colortable_get_transpen_mask(machine().colortable, m_gfxdecode->gfx(1), color, m_palette_bank * 16));
 	}

src/mame/video/segag80r.c

@@ -644,7 +644,7 @@ void segag80r_state::draw_videoram(bitmap_ind16 &bitmap, const rectangle &clipre
 			UINT8 tile = videoram[offs];
 
 			/* draw the tile */
-			 m_gfxdecode->gfx(0)->transmask(bitmap,cliprect, tile, tile >> 4, m_video_flip, m_video_flip, x*8, y*8, transparent_pens[tile >> 4]);
+			m_gfxdecode->gfx(0)->transmask(bitmap,cliprect, tile, tile >> 4, m_video_flip, m_video_flip, x*8, y*8, transparent_pens[tile >> 4]);
 		}
 	}
 }