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); }