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

drawgfx: Make the palette optional [O. Galibert]

Browse Source 
device_gfx_interface does two things:
- go from a possibly weird rom layout to a one-byte-per-pixel tiled layout
- draw the tiles so created

The second part requires a palette, but the first doesn't.  And
low-level emulations of individual graphic chips (konami tilemap or
sprite generators for instance) are not supposed to care about the
palette.  They just output bits which are partly indexes into
palettes, and partly not, and in any case become pen ids only much
further in the rendering chain.  But they need access to the decoding
step, because one-byte-per-pixel is real nice..  So now such a device,
which inherits from device_gfx_interface, can call
set_palette_disable(true) and no palette tag will be required.
Calling the draw functions will segfault though.

As a side effect, the gfx_element constructor now takes a palette
pointer instead of a reference, since it's now optional.
This commit is contained in:
Olivier Galibert 2017-05-28 11:11:19 +02:00
parent 8ad55eced8
commit 53feb420a4
39 changed files with 112 additions and 91 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/devices/bus/iq151/video32.cpp
View File

@ -67,7 +67,7 @@ iq151_video32_device::iq151_video32_device(const machine_config &mconfig, const
void iq151_video32_device::device_start()
{
set_gfx(0, std::make_unique<gfx_element>(palette(), iq151_video32_charlayout, m_chargen, 0, 1, 0));
set_gfx(0, std::make_unique<gfx_element>(&palette(), iq151_video32_charlayout, m_chargen, 0, 1, 0));
}
//-------------------------------------------------

2
src/devices/bus/iq151/video64.cpp
View File

@ -67,7 +67,7 @@ iq151_video64_device::iq151_video64_device(const machine_config &mconfig, const
void iq151_video64_device::device_start()
{
set_gfx(0, std::make_unique<gfx_element>(palette(), iq151_video64_charlayout, m_chargen, 0, 1, 0));
set_gfx(0, std::make_unique<gfx_element>(&palette(), iq151_video64_charlayout, m_chargen, 0, 1, 0));
}
//-------------------------------------------------

2
src/devices/machine/tc009xlvc.cpp
View File

@ -278,7 +278,7 @@ void tc0091lvc_device::device_start()
//printf("m_gfx_index %d\n", m_gfx_index);
device_palette_interface &palette = m_gfxdecode->palette();
m_gfxdecode->set_gfx(m_gfx_index, std::make_unique<gfx_element>(palette, char_layout, (uint8_t *)m_pcg_ram, 0, palette.entries() / 16, 0));
m_gfxdecode->set_gfx(m_gfx_index, std::make_unique<gfx_element>(&palette, char_layout, (uint8_t *)m_pcg_ram, 0, palette.entries() / 16, 0));
}
const address_space_config *tc0091lvc_device::memory_space_config(address_spacenum spacenum) const

92
src/emu/digfx.cpp
View File

@ -27,6 +27,7 @@ device_gfx_interface::device_gfx_interface(const machine_config &mconfig, device
m_gfxdecodeinfo(gfxinfo),
m_palette_tag(palette_tag),
m_palette_is_sibling(palette_tag == nullptr),
m_palette_is_disabled(false),
m_decoded(false)
{
}
@ -71,6 +72,17 @@ void device_gfx_interface::static_set_palette(device_t &device, const char *tag)
}
//-------------------------------------------------
// set_palette_disable: configuration helper to
// disable the use of a palette by the device
//-------------------------------------------------
void device_gfx_interface::set_palette_disable(bool disable)
{
m_palette_is_disabled = disable;
}
//-------------------------------------------------
// interface_pre_start - make sure all our input
// devices are started
@ -78,26 +90,29 @@ void device_gfx_interface::static_set_palette(device_t &device, const char *tag)
void device_gfx_interface::interface_pre_start()
{
if (m_palette_tag == nullptr)
fatalerror("No palette specified for device\n");
if (!m_palette_is_disabled)
{
if (m_palette_tag == nullptr)
fatalerror("No palette specified for device\n");
// find our palette device, either as a sibling device or subdevice
device_t *paldev;
if (m_palette_is_sibling)
paldev = device().owner()->subdevice(m_palette_tag);
else
paldev = device().subdevice(m_palette_tag);
// find our palette device, either as a sibling device or subdevice
device_t *paldev;
if (m_palette_is_sibling)
paldev = device().owner()->subdevice(m_palette_tag);
else
paldev = device().subdevice(m_palette_tag);
if (paldev == nullptr)
fatalerror("Device '%s' specifies nonexistent %sdevice '%s' as palette\n",
device().tag(),
(m_palette_is_sibling ? "sibling " : "sub"),
m_palette_tag);
if (!paldev->interface(m_palette))
fatalerror("Device '%s' specifies %sdevice '%s' as palette, but it has no palette interface\n",
device().tag(),
(m_palette_is_sibling ? "sibling " : "sub"),
m_palette_tag);
if (paldev == nullptr)
fatalerror("Device '%s' specifies nonexistent %sdevice '%s' as palette\n",
device().tag(),
(m_palette_is_sibling ? "sibling " : "sub"),
m_palette_tag);
if (!paldev->interface(m_palette))
fatalerror("Device '%s' specifies %sdevice '%s' as palette, but it has no palette interface\n",
device().tag(),
(m_palette_is_sibling ? "sibling " : "sub"),
m_palette_tag);
}
// if palette device isn't started, wait for it
// if (!m_palette->device().started())
@ -282,7 +297,7 @@ void device_gfx_interface::decode_gfx(const gfx_decode_entry *gfxdecodeinfo)
}
// allocate the graphics
m_gfx[curgfx] = std::make_unique<gfx_element>(*m_palette, glcopy, (region_base != nullptr) ? region_base + gfx.start : nullptr, xormask, gfx.total_color_codes, gfx.color_codes_start);
m_gfx[curgfx] = std::make_unique<gfx_element>(m_palette, glcopy, (region_base != nullptr) ? region_base + gfx.start : nullptr, xormask, gfx.total_color_codes, gfx.color_codes_start);
}
m_decoded = true;
@ -296,27 +311,30 @@ void device_gfx_interface::decode_gfx(const gfx_decode_entry *gfxdecodeinfo)
void device_gfx_interface::interface_validity_check(validity_checker &valid) const
{
// validate palette tag
if (m_palette_tag == nullptr)
osd_printf_error("No palette specified for device '%s'\n", device().tag());
else
if (!m_palette_is_disabled)
{
device_t *paldev;
if (m_palette_is_sibling)
paldev = device().owner()->subdevice(m_palette_tag);
else
paldev = device().subdevice(m_palette_tag);
if (paldev == nullptr)
osd_printf_error("Nonexistent %sdevice '%s' specified as palette\n",
(m_palette_is_sibling ? "sibling " : "sub"),
m_palette_tag);
// validate palette tag
if (m_palette_tag == nullptr)
osd_printf_error("No palette specified for device '%s'\n", device().tag());
else
{
device_palette_interface *palintf;
if (!paldev->interface(palintf))
osd_printf_error("%sdevice '%s' specified as palette, but it has no palette interface\n",
(m_palette_is_sibling ? "Sibling " : "Sub"),
m_palette_tag);
device_t *paldev;
if (m_palette_is_sibling)
paldev = device().owner()->subdevice(m_palette_tag);
else
paldev = device().subdevice(m_palette_tag);
if (paldev == nullptr)
osd_printf_error("Nonexistent %sdevice '%s' specified as palette\n",
(m_palette_is_sibling ? "sibling " : "sub"),
m_palette_tag);
else
{
device_palette_interface *palintf;
if (!paldev->interface(palintf))
osd_printf_error("%sdevice '%s' specified as palette, but it has no palette interface\n",
(m_palette_is_sibling ? "Sibling " : "Sub"),
m_palette_tag);
}
}
}

3
src/emu/digfx.h
View File

@ -195,6 +195,8 @@ public:
static void static_set_info(device_t &device, const gfx_decode_entry *gfxinfo);
static void static_set_palette(device_t &device, const char *tag);
void set_palette_disable(bool disable);
// getters
device_palette_interface &palette() const { assert(m_palette != nullptr); return *m_palette; }
gfx_element *gfx(u8 index) const { assert(index < MAX_GFX_ELEMENTS); return m_gfx[index].get(); }
@ -219,6 +221,7 @@ private:
const gfx_decode_entry * m_gfxdecodeinfo; // pointer to array of gfx decode information
const char * m_palette_tag; // configured tag for palette device
bool m_palette_is_sibling; // is palette a sibling or a subdevice?
bool m_palette_is_disabled; // no palette associated with this gfx decode
// internal state
bool m_decoded; // have we processed our decode info yet?

8
src/emu/drawgfx.cpp
View File

@ -86,8 +86,8 @@ gfxdecode_device::gfxdecode_device(const machine_config &mconfig, const char *ta
// gfx_element - constructor
//-------------------------------------------------
gfx_element::gfx_element(device_palette_interface &palette, u8 *base, u16 width, u16 height, u32 rowbytes, u32 total_colors, u32 color_base, u32 color_granularity)
: m_palette(&palette),
gfx_element::gfx_element(device_palette_interface *palette, u8 *base, u16 width, u16 height, u32 rowbytes, u32 total_colors, u32 color_base, u32 color_granularity)
: m_palette(palette),
m_width(width),
m_height(height),
m_startx(0),
@ -111,8 +111,8 @@ gfx_element::gfx_element(device_palette_interface &palette, u8 *base, u16 width,
{
}
gfx_element::gfx_element(device_palette_interface &palette, const gfx_layout &gl, const u8 *srcdata, u32 xormask, u32 total_colors, u32 color_base)
: m_palette(&palette),
gfx_element::gfx_element(device_palette_interface *palette, const gfx_layout &gl, const u8 *srcdata, u32 xormask, u32 total_colors, u32 color_base)
: m_palette(palette),
m_width(0),
m_height(0),
m_startx(0),

6
src/emu/drawgfx.h
View File

@ -151,8 +151,8 @@ public:
#ifdef UNUSED_FUNCTION
gfx_element();
#endif
gfx_element(device_palette_interface &palette, const gfx_layout &gl, const u8 *srcdata, u32 xormask, u32 total_colors, u32 color_base);
gfx_element(device_palette_interface &palette, u8 *base, u16 width, u16 height, u32 rowbytes, u32 total_colors, u32 color_base, u32 color_granularity);
gfx_element(device_palette_interface *palette, const gfx_layout &gl, const u8 *srcdata, u32 xormask, u32 total_colors, u32 color_base);
gfx_element(device_palette_interface *palette, u8 *base, u16 width, u16 height, u32 rowbytes, u32 total_colors, u32 color_base, u32 color_granularity);
// getters
device_palette_interface &palette() const { return *m_palette; }
@ -269,7 +269,7 @@ private:
void decode(u32 code);
// internal state
device_palette_interface *m_palette; // palette used for drawing
device_palette_interface *m_palette; // palette used for drawing (optional when used as a pure decoder)
u16 m_width; // current pixel width of each element (changeable with source clipping)
u16 m_height; // current pixel height of each element (changeable with source clipping)

4
src/mame/drivers/casloopy.cpp
View File

@ -237,8 +237,8 @@ void casloopy_state::video_start()
for(int i=0;i<0x10000;i++)
m_vram[i] = i & 0xff;
m_gfxdecode->set_gfx(m_gfx_index, std::make_unique<gfx_element>(*m_palette, casloopy_4bpp_layout, m_vram.get(), 0, 0x10, 0));
m_gfxdecode->set_gfx(m_gfx_index+1, std::make_unique<gfx_element>(*m_palette, casloopy_8bpp_layout, m_vram.get(), 0, 1, 0));
m_gfxdecode->set_gfx(m_gfx_index, std::make_unique<gfx_element>(m_palette, casloopy_4bpp_layout, m_vram.get(), 0, 0x10, 0));
m_gfxdecode->set_gfx(m_gfx_index+1, std::make_unique<gfx_element>(m_palette, casloopy_8bpp_layout, m_vram.get(), 0, 1, 0));
}
uint32_t casloopy_state::screen_update_casloopy(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)

2
src/mame/drivers/coolridr.cpp
View File

@ -570,7 +570,7 @@ void coolridr_state::video_start()
m_screen->register_screen_bitmap(m_screen1_bitmap);
m_screen->register_screen_bitmap(m_screen2_bitmap);
m_gfxdecode->set_gfx(m_gfx_index, std::make_unique<gfx_element>(*m_palette, h1_tile_layout, m_h1_pcg.get(), 0, 8, 0));
m_gfxdecode->set_gfx(m_gfx_index, std::make_unique<gfx_element>(m_palette, h1_tile_layout, m_h1_pcg.get(), 0, 8, 0));
}
/*

4
src/mame/drivers/cps3.cpp
View File

@ -912,12 +912,12 @@ void cps3_state::video_start()
save_pointer(NAME(m_char_ram.get()), 0x800000 /4);
/* create the char set (gfx will then be updated dynamically from RAM) */
m_gfxdecode->set_gfx(0, std::make_unique<gfx_element>(*m_palette, cps3_tiles8x8_layout, (uint8_t *)m_ss_ram.get(), 0, m_palette->entries() / 16, 0));
m_gfxdecode->set_gfx(0, std::make_unique<gfx_element>(m_palette, cps3_tiles8x8_layout, (uint8_t *)m_ss_ram.get(), 0, m_palette->entries() / 16, 0));
//decode_ssram();
/* create the char set (gfx will then be updated dynamically from RAM) */
m_gfxdecode->set_gfx(1, std::make_unique<gfx_element>(*m_palette, cps3_tiles16x16_layout, (uint8_t *)m_char_ram.get(), 0, m_palette->entries() / 64, 0));
m_gfxdecode->set_gfx(1, std::make_unique<gfx_element>(m_palette, cps3_tiles16x16_layout, (uint8_t *)m_char_ram.get(), 0, m_palette->entries() / 64, 0));
m_gfxdecode->gfx(1)->set_granularity(64);
//decode_charram();

2
src/mame/drivers/limenko.cpp
View File

@ -464,7 +464,7 @@ void limenko_state::draw_sprites(uint32_t *sprites, const rectangle &cliprect, i
continue;
/* prepare GfxElement on the fly */
gfx_element gfx(*m_palette, gfxdata, width, height, width, m_palette->entries(), 0, 256);
gfx_element gfx(m_palette, gfxdata, width, height, width, m_palette->entries(), 0, 256);
draw_single_sprite(m_sprites_bitmap,cliprect,&gfx,0,color,flipx,flipy,x,y,pri);

2
src/mame/drivers/mpu4vid.cpp
View File

@ -438,7 +438,7 @@ VIDEO_START_MEMBER(mpu4vid_state,mpu4_vid)
assert(m_gfx_index != MAX_GFX_ELEMENTS);
/* create the char set (gfx will then be updated dynamically from RAM) */
m_gfxdecode->set_gfx(m_gfx_index+0, std::make_unique<gfx_element>(*m_palette, mpu4_vid_char_8x8_layout, reinterpret_cast<uint8_t *>(m_vid_vidram.target()), NATIVE_ENDIAN_VALUE_LE_BE(8,0), m_palette->entries() / 16, 0));
m_gfxdecode->set_gfx(m_gfx_index+0, std::make_unique<gfx_element>(m_palette, mpu4_vid_char_8x8_layout, reinterpret_cast<uint8_t *>(m_vid_vidram.target()), NATIVE_ENDIAN_VALUE_LE_BE(8,0), m_palette->entries() / 16, 0));
}
EF9369_COLOR_UPDATE( mpu4vid_state::ef9369_color_update )

4
src/mame/drivers/mz2500.cpp
View File

@ -1773,8 +1773,8 @@ void mz2500_state::machine_start()
save_pointer(NAME(m_emm_ram.get()), 0x100000);
/* TODO: gfx[4] crashes as per now */
m_gfxdecode->set_gfx(3, std::make_unique<gfx_element>(*m_palette, mz2500_pcg_layout_1bpp, m_pcg_ram.get(), 0, 0x10, 0));
m_gfxdecode->set_gfx(4, std::make_unique<gfx_element>(*m_palette, mz2500_pcg_layout_3bpp, m_pcg_ram.get(), 0, 4, 0));
m_gfxdecode->set_gfx(3, std::make_unique<gfx_element>(m_palette, mz2500_pcg_layout_1bpp, m_pcg_ram.get(), 0, 0x10, 0));
m_gfxdecode->set_gfx(4, std::make_unique<gfx_element>(m_palette, mz2500_pcg_layout_3bpp, m_pcg_ram.get(), 0, 4, 0));
}
void mz2500_state::machine_reset()

2
src/mame/drivers/peoplepc.cpp
View File

@ -177,7 +177,7 @@ void peoplepc_state::machine_reset()
void peoplepc_state::machine_start()
{
m_gfxdecode->set_gfx(0, std::make_unique<gfx_element>(*m_palette, peoplepc_charlayout, &m_charram[0], 0, 1, 0));
m_gfxdecode->set_gfx(0, std::make_unique<gfx_element>(m_palette, peoplepc_charlayout, &m_charram[0], 0, 1, 0));
m_dma0pg = 0;
// FIXME: cheat as there no docs about how or obvious ports that set to control the motor

2
src/mame/drivers/smc777.cpp
View File

@ -918,7 +918,7 @@ void smc777_state::machine_start()
save_pointer(NAME(m_gvram.get()), 0x8000);
save_pointer(NAME(m_pcg.get()), 0x800);
m_gfxdecode->set_gfx(0, std::make_unique<gfx_element>(*m_palette, smc777_charlayout, m_pcg.get(), 0, 8, 0));
m_gfxdecode->set_gfx(0, std::make_unique<gfx_element>(m_palette, smc777_charlayout, m_pcg.get(), 0, 8, 0));
}
void smc777_state::machine_reset()

2
src/mame/drivers/srmp6.cpp
View File

@ -175,7 +175,7 @@ void srmp6_state::video_start()
m_sprram_old = make_unique_clear<uint16_t[]>(0x80000/2);
/* create the char set (gfx will then be updated dynamically from RAM) */
m_gfxdecode->set_gfx(0, std::make_unique<gfx_element>(*m_palette, tiles8x8_layout, (uint8_t*)m_tileram.get(), 0, m_palette->entries() / 256, 0));
m_gfxdecode->set_gfx(0, std::make_unique<gfx_element>(m_palette, tiles8x8_layout, (uint8_t*)m_tileram.get(), 0, m_palette->entries() / 256, 0));
m_gfxdecode->gfx(0)->set_granularity(256);
m_brightness = 0x60;

2
src/mame/drivers/taitopjc.cpp
View File

@ -237,7 +237,7 @@ void taitopjc_state::video_start()
m_tilemap[0]->set_transparent_pen(0);
m_tilemap[1]->set_transparent_pen(1);
m_gfxdecode->set_gfx(0, std::make_unique<gfx_element>(*m_palette, char_layout, (uint8_t*)m_screen_ram.get(), 0, m_palette->entries() / 256, 0));
m_gfxdecode->set_gfx(0, std::make_unique<gfx_element>(m_palette, char_layout, (uint8_t*)m_screen_ram.get(), 0, m_palette->entries() / 256, 0));
machine().add_notifier(MACHINE_NOTIFY_EXIT, machine_notify_delegate(&taitopjc_state::video_exit, this));
}

2
src/mame/drivers/x1.cpp
View File

@ -2507,7 +2507,7 @@ MACHINE_START_MEMBER(x1_state,x1)
save_pointer(NAME(m_emm_ram.get()), 0x1000000);
save_pointer(NAME(m_pcg_ram.get()), 0x1800);
m_gfxdecode->set_gfx(3, std::make_unique<gfx_element>(*m_palette, x1_pcg_8x8, m_pcg_ram.get(), 0, 1, 0));
m_gfxdecode->set_gfx(3, std::make_unique<gfx_element>(m_palette, x1_pcg_8x8, m_pcg_ram.get(), 0, 1, 0));
}
PALETTE_INIT_MEMBER(x1_state,x1)

2
src/mame/machine/st0016.cpp
View File

@ -582,7 +582,7 @@ void st0016_cpu_device::startup()
assert(gfx_index != MAX_GFX_ELEMENTS);
/* create the char set (gfx will then be updated dynamically from RAM) */
set_gfx(gfx_index, std::make_unique<gfx_element>(palette(), charlayout, m_charram.get(), 0, 0x40, 0));
set_gfx(gfx_index, std::make_unique<gfx_element>(&palette(), charlayout, m_charram.get(), 0, 0x40, 0));
st0016_ramgfx = gfx_index;
spr_dx=0;

6
src/mame/video/atarisy1.cpp
View File

@ -617,15 +617,15 @@ int atarisy1_state::get_bank(uint8_t prom1, uint8_t prom2, int bpp)
switch (bpp)
{
case 4:
m_gfxdecode->set_gfx(gfx_index,std::make_unique<gfx_element>(*m_palette, objlayout_4bpp, srcdata, 0, 0x40, 256));
m_gfxdecode->set_gfx(gfx_index,std::make_unique<gfx_element>(m_palette, objlayout_4bpp, srcdata, 0, 0x40, 256));
break;
case 5:
m_gfxdecode->set_gfx(gfx_index,std::make_unique<gfx_element>(*m_palette, objlayout_5bpp, srcdata, 0, 0x40, 256));
m_gfxdecode->set_gfx(gfx_index,std::make_unique<gfx_element>(m_palette, objlayout_5bpp, srcdata, 0, 0x40, 256));
break;
case 6:
m_gfxdecode->set_gfx(gfx_index,std::make_unique<gfx_element>(*m_palette, objlayout_6bpp, srcdata, 0, 0x40, 256));
m_gfxdecode->set_gfx(gfx_index,std::make_unique<gfx_element>(m_palette, objlayout_6bpp, srcdata, 0, 0x40, 256));
break;
default:

4
src/mame/video/hyprduel.cpp
View File

@ -545,7 +545,7 @@ void hyprduel_state::draw_sprites( screen_device &screen, bitmap_ind16 &bitmap,
if ((gfxstart + width * height - 1) >= gfx_size)
continue;
gfx_element gfx(*m_palette, base_gfx8 + gfxstart, width, height, width, m_palette->entries(), 0, 256);
gfx_element gfx(m_palette, base_gfx8 + gfxstart, width, height, width, m_palette->entries(), 0, 256);
gfx.prio_zoom_transpen(bitmap,cliprect,
0,
@ -561,7 +561,7 @@ void hyprduel_state::draw_sprites( screen_device &screen, bitmap_ind16 &bitmap,
if ((gfxstart + width / 2 * height - 1) >= gfx_size)
continue;
gfx_element gfx(*m_palette, base_gfx4 + 2 * gfxstart, width, height, width, m_palette->entries(), 0, 16);
gfx_element gfx(m_palette, base_gfx4 + 2 * gfxstart, width, height, width, m_palette->entries(), 0, 16);
gfx.prio_zoom_transpen(bitmap,cliprect,
0,

2
src/mame/video/igs017_igs031.cpp
View File

@ -296,7 +296,7 @@ void igs017_igs031_device::draw_sprite(bitmap_ind16 &bitmap,const rectangle &cli
if ( addr + dimx * dimy >= m_sprites_gfx_size )
return;
gfx_element gfx(*m_palette, m_sprites_gfx.get() + addr, dimx, dimy, dimx, m_palette->entries(), 0x100, 32);
gfx_element gfx(m_palette, m_sprites_gfx.get() + addr, dimx, dimy, dimx, m_palette->entries(), 0x100, 32);
gfx.transpen(bitmap,cliprect,
0, color,

4
src/mame/video/k001604.cpp
View File

@ -89,8 +89,8 @@ void k001604_device::device_start()
m_layer_8x8[0]->set_transparent_pen(0);
m_layer_8x8[1]->set_transparent_pen(0);
set_gfx(0, std::make_unique<gfx_element>(palette(), k001604_char_layout_layer_8x8, (uint8_t*)&m_char_ram[0], 0, palette().entries() / 16, 0));
set_gfx(1, std::make_unique<gfx_element>(palette(), k001604_char_layout_layer_16x16, (uint8_t*)&m_char_ram[0], 0, palette().entries() / 16, 0));
set_gfx(0, std::make_unique<gfx_element>(&palette(), k001604_char_layout_layer_8x8, (uint8_t*)&m_char_ram[0], 0, palette().entries() / 16, 0));
set_gfx(1, std::make_unique<gfx_element>(&palette(), k001604_char_layout_layer_16x16, (uint8_t*)&m_char_ram[0], 0, palette().entries() / 16, 0));
save_pointer(NAME(m_reg.get()), 0x400 / 4);
save_pointer(NAME(m_char_ram.get()), 0x200000 / 4);

2
src/mame/video/k037122.cpp
View File

@ -57,7 +57,7 @@ void k037122_device::device_start()
m_layer[0]->set_transparent_pen(0);
m_layer[1]->set_transparent_pen(0);
set_gfx(m_gfx_index,std::make_unique<gfx_element>(palette(), k037122_char_layout, (uint8_t*)m_char_ram.get(), 0, palette().entries() / 16, 0));
set_gfx(m_gfx_index,std::make_unique<gfx_element>(&palette(), k037122_char_layout, (uint8_t*)m_char_ram.get(), 0, palette().entries() / 16, 0));
save_pointer(NAME(m_reg.get()), 0x400 / 4);
save_pointer(NAME(m_char_ram.get()), 0x200000 / 4);

2
src/mame/video/konami_helper.cpp
View File

@ -12,7 +12,7 @@ void konami_decode_gfx(device_gfx_interface &gfxdecode, int gfx_index, uint8_t *
memcpy(&gl, layout, sizeof(gl));
gl.total = total;
gfxdecode.set_gfx(gfx_index, std::make_unique<gfx_element>(palette, gl, data, 0, palette.entries() >> bpp, 0));
gfxdecode.set_gfx(gfx_index, std::make_unique<gfx_element>(&palette, gl, data, 0, palette.entries() >> bpp, 0));
}

4
src/mame/video/m10.cpp
View File

@ -100,14 +100,14 @@ VIDEO_START_MEMBER(m10_state,m10)
m_tx_tilemap = &machine().tilemap().create(*m_gfxdecode, tilemap_get_info_delegate(FUNC(m10_state::get_tile_info),this), tilemap_mapper_delegate(FUNC(m10_state::tilemap_scan),this), 8, 8, 32, 32);
m_tx_tilemap->set_transparent_pen(0);
m_gfxdecode->set_gfx(1, std::make_unique<gfx_element>(*m_palette, backlayout, m_chargen, 0, 8, 0));
m_gfxdecode->set_gfx(1, std::make_unique<gfx_element>(m_palette, backlayout, m_chargen, 0, 8, 0));
m_back_gfx = m_gfxdecode->gfx(1);
return ;
}
VIDEO_START_MEMBER(m10_state,m15)
{
m_gfxdecode->set_gfx(0,std::make_unique<gfx_element>(*m_palette, charlayout, m_chargen, 0, 8, 0));
m_gfxdecode->set_gfx(0,std::make_unique<gfx_element>(m_palette, charlayout, m_chargen, 0, 8, 0));
m_tx_tilemap = &machine().tilemap().create(*m_gfxdecode, tilemap_get_info_delegate(FUNC(m10_state::get_tile_info),this),tilemap_mapper_delegate(FUNC(m10_state::tilemap_scan),this), 8, 8, 32, 32);

4
src/mame/video/metro.cpp
View File

@ -495,7 +495,7 @@ void metro_state::metro_draw_sprites( screen_device &screen, bitmap_ind16 &bitma
if ((gfxstart + width * height - 1) >= gfx_size)
continue;
gfx_element gfx(*m_palette, base_gfx8 + gfxstart, width, height, width, m_palette->entries(), 0, 256);
gfx_element gfx(m_palette, base_gfx8 + gfxstart, width, height, width, m_palette->entries(), 0, 256);
gfx.prio_zoom_transpen(bitmap,cliprect,
0,
@ -511,7 +511,7 @@ void metro_state::metro_draw_sprites( screen_device &screen, bitmap_ind16 &bitma
if ((gfxstart + width / 2 * height - 1) >= gfx_size)
continue;
gfx_element gfx(*m_palette, base_gfx4 + 2 * gfxstart, width, height, width, m_palette->entries(),0, 16);
gfx_element gfx(m_palette, base_gfx4 + 2 * gfxstart, width, height, width, m_palette->entries(),0, 16);
gfx.prio_zoom_transpen(bitmap,cliprect,
0,

4
src/mame/video/model3.cpp
View File

@ -207,10 +207,10 @@ void model3_state::video_start()
m_layer8[3] = &machine().tilemap().create(*m_gfxdecode, tilemap_get_info_delegate(FUNC(model3_state::tile_info_layer3_8bit), this), TILEMAP_SCAN_ROWS, 8, 8, 64, 64);
// 4-bit tiles
m_gfxdecode->set_gfx(0, std::make_unique<gfx_element>(*m_palette, char4_layout, (uint8_t*)m_m3_char_ram.get(), 0, m_palette->entries() / 16, 0));
m_gfxdecode->set_gfx(0, std::make_unique<gfx_element>(m_palette, char4_layout, (uint8_t*)m_m3_char_ram.get(), 0, m_palette->entries() / 16, 0));
// 8-bit tiles
m_gfxdecode->set_gfx(1, std::make_unique<gfx_element>(*m_palette, char8_layout, (uint8_t*)m_m3_char_ram.get(), 0, m_palette->entries() / 256, 0));
m_gfxdecode->set_gfx(1, std::make_unique<gfx_element>(m_palette, char8_layout, (uint8_t*)m_m3_char_ram.get(), 0, m_palette->entries() / 256, 0));
init_matrix_stack();
}

2
src/mame/video/pcd.cpp
View File

@ -401,7 +401,7 @@ void pcd_video_device::device_start()
{
m_maincpu->space(AS_IO).install_readwrite_handler(0xfb00, 0xfb01, read8_delegate(FUNC(pcdx_video_device::detect_r), this), write8_delegate(FUNC(pcdx_video_device::detect_w), this), 0xff00);
m_maincpu->space(AS_PROGRAM).install_readwrite_handler(0xf0000, 0xf7fff, read8_delegate(FUNC(pcd_video_device::vram_r), this), write8_delegate(FUNC(pcd_video_device::vram_w), this), 0xffff);
set_gfx(0, std::make_unique<gfx_element>(palette(), pcd_charlayout, &m_charram[0], 0, 1, 0));
set_gfx(0, std::make_unique<gfx_element>(&palette(), pcd_charlayout, &m_charram[0], 0, 1, 0));
}
void pcd_video_device::device_reset()

2
src/mame/video/plygonet.cpp
View File

@ -102,7 +102,7 @@ void polygonet_state::video_start()
assert(m_ttl_gfx_index != MAX_GFX_ELEMENTS);
/* decode the ttl layer's gfx */
m_gfxdecode->set_gfx(m_ttl_gfx_index, std::make_unique<gfx_element>(*m_palette, charlayout, memregion("gfx1")->base(), 0, m_palette->entries() / 16, 0));
m_gfxdecode->set_gfx(m_ttl_gfx_index, std::make_unique<gfx_element>(m_palette, charlayout, memregion("gfx1")->base(), 0, m_palette->entries() / 16, 0));
/* create the tilemap */
m_ttl_tilemap = &machine().tilemap().create(*m_gfxdecode, tilemap_get_info_delegate(FUNC(polygonet_state::ttl_get_tile_info),this), tilemap_mapper_delegate(FUNC(polygonet_state::plygonet_scan),this), 8, 8, 64, 32);

2
src/mame/video/rungun.cpp
View File

@ -95,7 +95,7 @@ void rungun_state::video_start()
assert(gfx_index != MAX_GFX_ELEMENTS);
// decode the ttl layer's gfx
m_gfxdecode->set_gfx(gfx_index, std::make_unique<gfx_element>(*m_palette, charlayout, memregion("gfx3")->base(), 0, m_palette->entries() / 16, 0));
m_gfxdecode->set_gfx(gfx_index, std::make_unique<gfx_element>(m_palette, charlayout, memregion("gfx3")->base(), 0, m_palette->entries() / 16, 0));
m_ttl_gfx_index = gfx_index;
// create the tilemaps

2
src/mame/video/segaic24.cpp
View File

@ -96,7 +96,7 @@ void segas24_tile_device::device_start()
memset(char_ram.get(), 0, 0x80000);
memset(tile_ram.get(), 0, 0x10000);
set_gfx(char_gfx_index, std::make_unique<gfx_element>(palette(), char_layout, (uint8_t *)char_ram.get(), NATIVE_ENDIAN_VALUE_LE_BE(8,0), palette().entries() / 16, 0));
set_gfx(char_gfx_index, std::make_unique<gfx_element>(&palette(), char_layout, (uint8_t *)char_ram.get(), NATIVE_ENDIAN_VALUE_LE_BE(8,0), palette().entries() / 16, 0));
save_pointer(NAME(tile_ram.get()), 0x10000/2);
save_pointer(NAME(char_ram.get()), 0x80000/2);

2
src/mame/video/st0020.cpp
View File

@ -79,7 +79,7 @@ void st0020_device::device_start()
{ STEP8(0,16*8) },
16*8*8
};
set_gfx(0, std::make_unique<gfx_element>(palette(), layout_16x8x8, (uint8_t *)m_gfxram.get(), 0, palette().entries() / granularity, 0));
set_gfx(0, std::make_unique<gfx_element>(&palette(), layout_16x8x8, (uint8_t *)m_gfxram.get(), 0, palette().entries() / granularity, 0));
gfx(0)->set_granularity(granularity); /* 256 colour sprites with palette selectable on 64 colour boundaries */
// Tilemaps

2
src/mame/video/taitojc.cpp
View File

@ -317,7 +317,7 @@ void taitojc_state::video_start()
m_tile_ram = make_unique_clear<uint32_t[]>(0x4000/4);
/* create the char set (gfx will then be updated dynamically from RAM) */
m_gfxdecode->set_gfx(m_gfx_index, std::make_unique<gfx_element>(*m_palette, taitojc_char_layout, (uint8_t *)m_char_ram.get(), 0, m_palette->entries() / 16, 0));
m_gfxdecode->set_gfx(m_gfx_index, std::make_unique<gfx_element>(m_palette, taitojc_char_layout, (uint8_t *)m_char_ram.get(), 0, m_palette->entries() / 16, 0));
}
uint32_t taitojc_state::screen_update_taitojc(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)

2
src/mame/video/tc0080vco.cpp
View File

@ -185,7 +185,7 @@ void tc0080vco_device::device_start()
m_scroll_ram = m_ram.get() + 0x20800 / 2;
/* create the char set (gfx will then be updated dynamically from RAM) */
m_gfxdecode->set_gfx(m_txnum, std::make_unique<gfx_element>(m_gfxdecode->palette(), charlayout, (uint8_t *)m_char_ram, 0, 1, 512));
m_gfxdecode->set_gfx(m_txnum, std::make_unique<gfx_element>(&m_gfxdecode->palette(), charlayout, (uint8_t *)m_char_ram, 0, 1, 512));
save_pointer(NAME(m_ram.get()), TC0080VCO_RAM_SIZE / 2);
machine().save().register_postload(save_prepost_delegate(FUNC(tc0080vco_device::postload), this));

2
src/mame/video/tc0100scn.cpp
View File

@ -290,7 +290,7 @@ void tc0100scn_device::device_start()
set_layer_ptrs();
/* create the char set (gfx will then be updated dynamically from RAM) */
m_gfxdecode->set_gfx(m_txnum, std::make_unique<gfx_element>(*m_palette, tc0100scn_charlayout, (uint8_t *)m_char_ram, NATIVE_ENDIAN_VALUE_LE_BE(8,0), 256, 0));
m_gfxdecode->set_gfx(m_txnum, std::make_unique<gfx_element>(m_palette, tc0100scn_charlayout, (uint8_t *)m_char_ram, NATIVE_ENDIAN_VALUE_LE_BE(8,0), 256, 0));
gfx_element *gfx = m_gfxdecode->gfx(m_gfxnum);
gfx_element *txt = m_gfxdecode->gfx(m_txnum);

2
src/mame/video/tc0480scp.cpp
View File

@ -287,7 +287,7 @@ void tc0480scp_device::device_start()
set_layer_ptrs();
/* create the char set (gfx will then be updated dynamically from RAM) */
m_gfxdecode->set_gfx(m_txnum, std::make_unique<gfx_element>(m_gfxdecode->palette(), tc0480scp_charlayout, (uint8_t *)m_char_ram, NATIVE_ENDIAN_VALUE_LE_BE(8,0), 64, m_col_base));
m_gfxdecode->set_gfx(m_txnum, std::make_unique<gfx_element>(&m_gfxdecode->palette(), tc0480scp_charlayout, (uint8_t *)m_char_ram, NATIVE_ENDIAN_VALUE_LE_BE(8,0), 64, m_col_base));
m_gfxdecode->gfx(m_gfxnum)->set_colorbase(m_col_base);
save_item(NAME(m_ram));

4
src/mame/video/tceptor.cpp
View File

@ -252,13 +252,13 @@ void tceptor_state::decode_bg(const char * region)
memcpy(src, &buffer[0], len);
/* decode the graphics */
m_gfxdecode->set_gfx(gfx_index, std::make_unique<gfx_element>(*m_palette, bg_layout, memregion(region)->base(), 0, 64, 0x0a00));
m_gfxdecode->set_gfx(gfx_index, std::make_unique<gfx_element>(m_palette, bg_layout, memregion(region)->base(), 0, 64, 0x0a00));
}
void tceptor_state::decode_sprite(int gfx_index, const gfx_layout *layout, const void *data)
{
/* decode the graphics */
m_gfxdecode->set_gfx(gfx_index, std::make_unique<gfx_element>(*m_palette, *layout, (const uint8_t *)data, 0, 64, 1024));
m_gfxdecode->set_gfx(gfx_index, std::make_unique<gfx_element>(m_palette, *layout, (const uint8_t *)data, 0, 64, 1024));
}
// fix sprite order

4
src/mame/video/x68k.cpp
View File

@ -1093,11 +1093,11 @@ VIDEO_START_MEMBER(x68k_state,x68000)
break;
/* create the char set (gfx will then be updated dynamically from RAM) */
m_gfxdecode->set_gfx(gfx_index, std::make_unique<gfx_element>(*m_pcgpalette, x68k_pcg_8, memregion("user1")->base(), 0, 32, 0));
m_gfxdecode->set_gfx(gfx_index, std::make_unique<gfx_element>(m_pcgpalette, x68k_pcg_8, memregion("user1")->base(), 0, 32, 0));
gfx_index++;
m_gfxdecode->set_gfx(gfx_index, std::make_unique<gfx_element>(*m_pcgpalette, x68k_pcg_16, memregion("user1")->base(), 0, 32, 0));
m_gfxdecode->set_gfx(gfx_index, std::make_unique<gfx_element>(m_pcgpalette, x68k_pcg_16, memregion("user1")->base(), 0, 32, 0));
m_gfxdecode->gfx(gfx_index)->set_colors(32);
/* Tilemaps */