void device_execute_interface::interface_post_reset()
{
// reset the interrupt vectors and queues
for (int line = 0; line < ARRAY_LENGTH(m_input); line++)
m_input[line].reset();
// reconfingure VBLANK interrupts
if (m_vblank_interrupt_screen != NULL)
{
// get the screen that will trigger the VBLANK
astring tempstring;
screen_device *screen = downcast<screen_device *>(device().machine().device(device().siblingtag(tempstring,m_vblank_interrupt_screen)));
assert(screen != NULL);
screen->register_vblank_callback(vblank_state_delegate(FUNC(device_execute_interface::on_vblank), this));
}
// reconfigure periodic interrupts
if (m_timed_interrupt_period != attotime::zero)
{
attotime timedint_period = m_timed_interrupt_period;
assert(m_timedint_timer != NULL);
m_timedint_timer->adjust(timedint_period, 0, timedint_period);
}
}
void k052109_device::device_start()
{
if (m_screen_tag != nullptr)
{
// make sure our screen is started
screen_device *screen = m_owner->subdevice<screen_device>(m_screen_tag);
if (!screen->started())
throw device_missing_dependencies();
// and register a callback for vblank state
screen->register_vblank_callback(vblank_state_delegate(FUNC(k052109_device::vblank_callback), this));
}
if (region() != nullptr)
{
m_char_rom = region()->base();
m_char_size = region()->bytes();
}
decode_gfx();
gfx(0)->set_colors(palette().entries() / gfx(0)->depth());
m_ram = make_unique_clear<UINT8[]>(0x6000);
m_colorram_F = &m_ram[0x0000];
m_colorram_A = &m_ram[0x0800];
m_colorram_B = &m_ram[0x1000];
m_videoram_F = &m_ram[0x2000];
m_videoram_A = &m_ram[0x2800];
m_videoram_B = &m_ram[0x3000];
m_videoram2_F = &m_ram[0x4000];
m_videoram2_A = &m_ram[0x4800];
m_videoram2_B = &m_ram[0x5000];
m_tilemap[0] = &machine().tilemap().create(*this, tilemap_get_info_delegate(FUNC(k052109_device::get_tile_info0),this), TILEMAP_SCAN_ROWS, 8, 8, 64, 32);
m_tilemap[1] = &machine().tilemap().create(*this, tilemap_get_info_delegate(FUNC(k052109_device::get_tile_info1),this), TILEMAP_SCAN_ROWS, 8, 8, 64, 32);
m_tilemap[2] = &machine().tilemap().create(*this, tilemap_get_info_delegate(FUNC(k052109_device::get_tile_info2),this), TILEMAP_SCAN_ROWS, 8, 8, 64, 32);
m_tilemap[0]->set_transparent_pen(0);
m_tilemap[1]->set_transparent_pen(0);
m_tilemap[2]->set_transparent_pen(0);
// bind callbacks
m_k052109_cb.bind_relative_to(*owner());
// resolve callbacks
m_irq_handler.resolve_safe();
m_firq_handler.resolve_safe();
m_nmi_handler.resolve_safe();
save_pointer(NAME(m_ram.get()), 0x6000);
save_item(NAME(m_rmrd_line));
save_item(NAME(m_romsubbank));
save_item(NAME(m_scrollctrl));
save_item(NAME(m_irq_enabled));
save_item(NAME(m_charrombank));
save_item(NAME(m_charrombank_2));
save_item(NAME(m_has_extra_video_ram));
machine().save().register_postload(save_prepost_delegate(FUNC(k052109_device::tileflip_reset), this));
}
void device_execute_interface::interface_post_reset()
{
// reset the interrupt vectors and queues
for (int line = 0; line < ARRAY_LENGTH(m_input); line++)
m_input[line].reset();
// reconfingure VBLANK interrupts
if (m_vblank_interrupts_per_frame > 0 || m_vblank_interrupt_screen != NULL)
{
// get the screen that will trigger the VBLANK
// new style - use screen tag directly
screen_device *screen;
if (m_vblank_interrupt_screen != NULL)
screen = downcast<screen_device *>(device().machine().device(m_vblank_interrupt_screen));
// old style 'hack' setup - use screen #0
else
screen = device().machine().first_screen();
assert(screen != NULL);
screen->register_vblank_callback(vblank_state_delegate(FUNC(device_execute_interface::on_vblank), this));
}
// reconfigure periodic interrupts
if (m_timed_interrupt_period != attotime::zero)
{
attotime timedint_period = m_timed_interrupt_period;
assert(m_timedint_timer != NULL);
m_timedint_timer->adjust(timedint_period, 0, timedint_period);
}
}
void k052109_device::device_start()
{
if (m_screen.found())
{
// make sure our screen is started
if (!m_screen->started())
throw device_missing_dependencies();
// and register a callback for vblank state
m_screen->register_vblank_callback(vblank_state_delegate(&k052109_device::vblank_callback, this));
}
decode_gfx();
gfx(0)->set_colors(palette().entries() / gfx(0)->depth());
m_ram = make_unique_clear<uint8_t[]>(0x6000);
m_colorram_F = &m_ram[0x0000];
m_colorram_A = &m_ram[0x0800];
m_colorram_B = &m_ram[0x1000];
m_videoram_F = &m_ram[0x2000];
m_videoram_A = &m_ram[0x2800];
m_videoram_B = &m_ram[0x3000];
m_videoram2_F = &m_ram[0x4000];
m_videoram2_A = &m_ram[0x4800];
m_videoram2_B = &m_ram[0x5000];
m_tilemap[0] = &machine().tilemap().create(*this, tilemap_get_info_delegate(FUNC(k052109_device::get_tile_info0),this), TILEMAP_SCAN_ROWS, 8, 8, 64, 32);
m_tilemap[1] = &machine().tilemap().create(*this, tilemap_get_info_delegate(FUNC(k052109_device::get_tile_info1),this), TILEMAP_SCAN_ROWS, 8, 8, 64, 32);
m_tilemap[2] = &machine().tilemap().create(*this, tilemap_get_info_delegate(FUNC(k052109_device::get_tile_info2),this), TILEMAP_SCAN_ROWS, 8, 8, 64, 32);
m_tilemap[0]->set_transparent_pen(0);
m_tilemap[1]->set_transparent_pen(0);
m_tilemap[2]->set_transparent_pen(0);
// bind callbacks
m_k052109_cb.bind_relative_to(*owner());
// resolve callbacks
m_irq_handler.resolve_safe();
m_firq_handler.resolve_safe();
m_nmi_handler.resolve_safe();
save_pointer(NAME(m_ram), 0x6000);
save_item(NAME(m_rmrd_line));
save_item(NAME(m_romsubbank));
save_item(NAME(m_scrollctrl));
save_item(NAME(m_irq_enabled));
save_item(NAME(m_charrombank));
save_item(NAME(m_charrombank_2));
save_item(NAME(m_has_extra_video_ram));
}
void watchdog_timer_device::device_start()
{
// initialize the watchdog
m_counter = 0;
m_timer = timer_alloc();
if (m_vblank_count != 0)
{
// fetch the screen
screen_device *screen = siblingdevice<screen_device>(m_screen_tag);
if (screen != nullptr)
screen->register_vblank_callback(vblank_state_delegate(FUNC(watchdog_timer_device::watchdog_vblank), this));
}
save_item(NAME(m_enabled));
save_item(NAME(m_counter));
}
void crosshair_init(running_machine &machine)
{
/* request a callback upon exiting */
machine.add_notifier(MACHINE_NOTIFY_EXIT, machine_notify_delegate(FUNC(crosshair_exit), &machine));
/* clear all the globals */
memset(&global, 0, sizeof(global));
/* setup the default auto visibility time */
global.auto_time = CROSSHAIR_VISIBILITY_AUTOTIME_DEFAULT;
/* determine who needs crosshairs */
for (ioport_port *port = machine.ioport().first_port(); port != NULL; port = port->next())
for (ioport_field *field = port->first_field(); field != NULL; field = field->next())
if (field->crosshair_axis() != CROSSHAIR_AXIS_NONE)
{
int player = field->player();
assert(player < MAX_PLAYERS);
/* mark as used and set the default visibility and mode */
global.usage = TRUE;
global.used[player] = TRUE;
global.mode[player] = CROSSHAIR_VISIBILITY_DEFAULT;
global.visible[player] = (CROSSHAIR_VISIBILITY_DEFAULT == CROSSHAIR_VISIBILITY_OFF) ? FALSE : TRUE;
/* for now, use the main screen */
global.screen[player] = machine.primary_screen;
create_bitmap(machine, player);
}
/* register callbacks for when we load/save configurations */
if (global.usage)
config_register(machine, "crosshairs", config_saveload_delegate(FUNC(crosshair_load), &machine), config_saveload_delegate(FUNC(crosshair_save), &machine));
/* register the animation callback */
if (machine.primary_screen != NULL)
machine.primary_screen->register_vblank_callback(vblank_state_delegate(FUNC(animate), &machine));
}
crosshair_manager::crosshair_manager(running_machine &machine)
: m_machine(machine)
{
/* request a callback upon exiting */
machine.add_notifier(MACHINE_NOTIFY_EXIT, machine_notify_delegate(FUNC(crosshair_manager::exit), this));
/* setup the default auto visibility time */
m_auto_time = CROSSHAIR_VISIBILITY_AUTOTIME_DEFAULT;
/* determine who needs crosshairs */
for (auto &port : machine.ioport().ports())
for (ioport_field &field : port.second->fields())
if (field.crosshair_axis() != CROSSHAIR_AXIS_NONE)
{
int player = field.player();
assert(player < MAX_PLAYERS);
/* mark as used and set the default visibility and mode */
m_usage = TRUE;
m_used[player] = TRUE;
m_mode[player] = CROSSHAIR_VISIBILITY_DEFAULT;
m_visible[player] = (CROSSHAIR_VISIBILITY_DEFAULT == CROSSHAIR_VISIBILITY_OFF) ? FALSE : TRUE;
/* for now, use the main screen */
m_screen[player] = machine.first_screen();
create_bitmap(player);
}
/* register callbacks for when we load/save configurations */
if (m_usage)
machine.configuration().config_register("crosshairs", config_saveload_delegate(FUNC(crosshair_manager::config_load), this), config_saveload_delegate(FUNC(crosshair_manager::config_save), this));
/* register the animation callback */
if (machine.first_screen() != nullptr)
machine.first_screen()->register_vblank_callback(vblank_state_delegate(FUNC(crosshair_manager::animate), this));
}
void running_machine::watchdog_reset()
{
// if we're not enabled, skip it
if (!m_watchdog_enabled)
m_watchdog_timer->adjust(attotime::never);
// VBLANK-based watchdog?
else if (config().m_watchdog_vblank_count != 0)
{
// register a VBLANK callback for the primary screen
m_watchdog_counter = config().m_watchdog_vblank_count;
if (primary_screen != NULL)
primary_screen->register_vblank_callback(vblank_state_delegate(FUNC(running_machine::watchdog_vblank), this));
}
// timer-based watchdog?
else if (config().m_watchdog_time != attotime::zero)
m_watchdog_timer->adjust(config().m_watchdog_time);
// default to an obscene amount of time (3 seconds)
else
m_watchdog_timer->adjust(attotime::from_seconds(3));
}
crosshair_manager::crosshair_manager(running_machine &machine)
: m_machine(machine)
, m_usage(false)
, m_animation_counter(0)
, m_auto_time(CROSSHAIR_VISIBILITY_AUTOTIME_DEFAULT)
{
/* request a callback upon exiting */
machine.add_notifier(MACHINE_NOTIFY_EXIT, machine_notify_delegate(&crosshair_manager::exit, this));
for (int player = 0; player < MAX_PLAYERS; player++)
m_crosshair[player] = std::make_unique<render_crosshair>(machine, player);
/* determine who needs crosshairs */
for (auto &port : machine.ioport().ports())
for (ioport_field &field : port.second->fields())
if (field.crosshair_axis() != CROSSHAIR_AXIS_NONE)
{
int player = field.player();
assert(player < MAX_PLAYERS);
/* mark as used and set the default visibility and mode */
m_usage = true;
m_crosshair[player]->set_used(true);
m_crosshair[player]->set_mode(CROSSHAIR_VISIBILITY_DEFAULT);
m_crosshair[player]->set_visible(CROSSHAIR_VISIBILITY_DEFAULT != CROSSHAIR_VISIBILITY_OFF);
m_crosshair[player]->set_default_bitmap();
}
/* register callbacks for when we load/save configurations */
if (m_usage)
machine.configuration().config_register("crosshairs", config_saveload_delegate(&crosshair_manager::config_load, this), config_saveload_delegate(&crosshair_manager::config_save, this));
/* register the animation callback */
if (machine.first_screen() != nullptr)
machine.first_screen()->register_vblank_callback(vblank_state_delegate(&crosshair_manager::animate, this));
}
void device_execute_interface::interface_post_reset()
{
// reset the interrupt vectors and queues
for (auto & elem : m_input)
elem.reset();
// reconfingure VBLANK interrupts
if (m_vblank_interrupt_screen != nullptr)
{
// get the screen that will trigger the VBLANK
screen_device *screen = downcast<screen_device *>(device().machine().device(device().siblingtag(m_vblank_interrupt_screen).c_str()));
assert(screen != nullptr);
screen->register_vblank_callback(vblank_state_delegate(FUNC(device_execute_interface::on_vblank), this));
}
// reconfigure periodic interrupts
if (m_timed_interrupt_period != attotime::zero)
{
attotime timedint_period = m_timed_interrupt_period;
assert(m_timedint_timer != nullptr);
m_timedint_timer->adjust(timedint_period, 0, timedint_period);
}
}
void watchdog_reset(running_machine &machine)
{
/* if we're not enabled, skip it */
if (!watchdog_enabled)
watchdog_timer->adjust(attotime::never);
/* VBLANK-based watchdog? */
else if (machine.config().m_watchdog_vblank_count != 0)
{
watchdog_counter = machine.config().m_watchdog_vblank_count;
/* register a VBLANK callback for the primary screen */
if (machine.primary_screen != NULL)
machine.primary_screen->register_vblank_callback(vblank_state_delegate(FUNC(on_vblank), &machine));
}
/* timer-based watchdog? */
else if (machine.config().m_watchdog_time != attotime::zero)
watchdog_timer->adjust(machine.config().m_watchdog_time);
/* default to an obscene amount of time (3 seconds) */
else
watchdog_timer->adjust(attotime::from_seconds(3));
}
void laserdisc_device::init_video()
{
// register for VBLANK callbacks
m_screen->register_vblank_callback(vblank_state_delegate(FUNC(laserdisc_device::vblank_state_changed), this));
// allocate palette for applying brightness/contrast/gamma
m_videopalette = palette_t::alloc(256);
if (m_videopalette == nullptr)
throw emu_fatalerror("Out of memory allocating video palette");
for (int index = 0; index < 256; index++)
m_videopalette->entry_set_color(index, rgb_t(index, index, index));
// allocate video frames
for (auto & frame : m_frame)
{
// first allocate a YUY16 bitmap at 2x the height
frame.m_bitmap.allocate(m_width, m_height * 2);
frame.m_bitmap.set_palette(m_videopalette);
fillbitmap_yuy16(frame.m_bitmap, 40, 109, 240);
// make a copy of the bitmap that clips out the VBI and horizontal blanking areas
frame.m_visbitmap.wrap(&frame.m_bitmap.pix16(44, frame.m_bitmap.width() * 8 / 720),
frame.m_bitmap.width() - 2 * frame.m_bitmap.width() * 8 / 720,
frame.m_bitmap.height() - 44,
frame.m_bitmap.rowpixels());
frame.m_visbitmap.set_palette(m_videopalette);
}
// allocate an empty frame of the same size
m_emptyframe.allocate(m_width, m_height * 2);
m_emptyframe.set_palette(m_videopalette);
fillbitmap_yuy16(m_emptyframe, 0, 128, 128);
// allocate texture for rendering
m_videoenable = true;
m_videotex = machine().render().texture_alloc();
if (m_videotex == nullptr)
fatalerror("Out of memory allocating video texture\n");
// allocate overlay
m_overenable = overlay_configured();
if (m_overenable)
{
// bind our handlers
m_overupdate_ind16.bind_relative_to(*owner());
m_overupdate_rgb32.bind_relative_to(*owner());
// configure bitmap formats
bitmap_format format = !m_overupdate_ind16.isnull() ? BITMAP_FORMAT_IND16 : BITMAP_FORMAT_RGB32;
texture_format texformat = !m_overupdate_ind16.isnull() ? TEXFORMAT_PALETTEA16 : TEXFORMAT_ARGB32;
// allocate overlay bitmaps
for (auto & elem : m_overbitmap)
{
elem.set_format(format, texformat);
if (format==BITMAP_FORMAT_IND16)
elem.set_palette(m_overlay_palette->palette());
elem.resize(m_overwidth, m_overheight);
}
// allocate overlay texture
m_overtex = machine().render().texture_alloc();
if (m_overtex == nullptr)
fatalerror("Out of memory allocating overlay texture\n");
}
}
void running_machine::start()
{
// initialize basic can't-fail systems here
config_init(*this);
m_input = auto_alloc(*this, input_manager(*this));
output_init(*this);
palette_init(*this);
m_render = auto_alloc(*this, render_manager(*this));
generic_machine_init(*this);
// allocate a soft_reset timer
m_soft_reset_timer = m_scheduler.timer_alloc(timer_expired_delegate(FUNC(running_machine::soft_reset), this));
// init the osd layer
m_osd.init(*this);
// create the video manager
m_video = auto_alloc(*this, video_manager(*this));
ui_init(*this);
// initialize the base time (needed for doing record/playback)
::time(&m_base_time);
// initialize the input system and input ports for the game
// this must be done before memory_init in order to allow specifying
// callbacks based on input port tags
time_t newbase = m_ioport.initialize();
if (newbase != 0)
m_base_time = newbase;
// intialize UI input
ui_input_init(*this);
// initialize the streams engine before the sound devices start
m_sound = auto_alloc(*this, sound_manager(*this));
// first load ROMs, then populate memory, and finally initialize CPUs
// these operations must proceed in this order
rom_init(*this);
m_memory.initialize();
// initialize the watchdog
m_watchdog_timer = m_scheduler.timer_alloc(timer_expired_delegate(FUNC(running_machine::watchdog_fired), this));
if (config().m_watchdog_vblank_count != 0 && primary_screen != NULL)
primary_screen->register_vblank_callback(vblank_state_delegate(FUNC(running_machine::watchdog_vblank), this));
save().save_item(NAME(m_watchdog_enabled));
save().save_item(NAME(m_watchdog_counter));
// allocate the gfx elements prior to device initialization
gfx_init(*this);
// initialize image devices
image_init(*this);
m_tilemap = auto_alloc(*this, tilemap_manager(*this));
crosshair_init(*this);
network_init(*this);
// initialize the debugger
if ((debug_flags & DEBUG_FLAG_ENABLED) != 0)
debugger_init(*this);
// call the game driver's init function
// this is where decryption is done and memory maps are altered
// so this location in the init order is important
ui_set_startup_text(*this, "Initializing...", true);
// register callbacks for the devices, then start them
add_notifier(MACHINE_NOTIFY_RESET, machine_notify_delegate(FUNC(running_machine::reset_all_devices), this));
add_notifier(MACHINE_NOTIFY_EXIT, machine_notify_delegate(FUNC(running_machine::stop_all_devices), this));
save().register_presave(save_prepost_delegate(FUNC(running_machine::presave_all_devices), this));
start_all_devices();
save().register_postload(save_prepost_delegate(FUNC(running_machine::postload_all_devices), this));
// if we're coming in with a savegame request, process it now
const char *savegame = options().state();
if (savegame[0] != 0)
schedule_load(savegame);
// if we're in autosave mode, schedule a load
else if (options().autosave() && (m_system.flags & GAME_SUPPORTS_SAVE) != 0)
schedule_load("auto");
// set up the cheat engine
m_cheat = auto_alloc(*this, cheat_manager(*this));
// allocate autoboot timer
m_autoboot_timer = scheduler().timer_alloc(timer_expired_delegate(FUNC(running_machine::autoboot_callback), this));
// initialize lua
m_lua_engine.initialize();
// disallow save state registrations starting here
m_save.allow_registration(false);
}
