void tmp68301_device::device_start()
{
int i;
for (i = 0; i < 3; i++)
m_tmp68301_timer[i] = machine().scheduler().timer_alloc(timer_expired_delegate(FUNC(tmp68301_device::timer_callback), this));
}
void isa8_device::install_bank(offs_t start, offs_t end, offs_t mask, offs_t mirror, const char *tag, UINT8 *data)
{
m_prgspace->install_readwrite_bank(start, end, mask, mirror, tag );
machine().root_device().membank(tag)->set_base(data);
}
void ddealer_state::video_start()
{
m_flipscreen = 0;
m_back_tilemap = &machine().tilemap().create(tilemap_get_info_delegate(FUNC(ddealer_state::get_back_tile_info),this), TILEMAP_SCAN_COLS, 8, 8, 64, 32);
}
void good_state::video_start()
{
m_bg_tilemap = &machine().tilemap().create(tilemap_get_info_delegate(FUNC(good_state::get_bg_tile_info),this), TILEMAP_SCAN_ROWS, 16, 16, 32, 32);
m_fg_tilemap = &machine().tilemap().create(tilemap_get_info_delegate(FUNC(good_state::get_fg_tile_info),this), TILEMAP_SCAN_ROWS, 16, 16, 32, 32);
m_fg_tilemap->set_transparent_pen(0xf);
}
if (!(m_input & 0x04)) return ioport("IN2")->read();
if (!(m_input & 0x08)) return ioport("IN3")->read();
if (!(m_input & 0x10)) return ioport("IN4")->read();
logerror("%s: warning, unknown input bits read, input = %02x\n", machine().describe_context(), m_input);
return 0xff;
}
WRITE8_MEMBER(dunhuang_state::dunhuang_rombank_w)
{
// ? data & 0x01
// ? data & 0x02
membank("bank1")->set_entry(((data >> 2) & 0x7));
// COIN OUT: data & 0x20
coin_counter_w(machine(), 0, data & 0x40);
m_hopper = data & 0x80;
}
#ifdef UNUSED_FUNCTION
WRITE8_MEMBER(dunhuang_state::dunhuang_82_w)
{
// popmessage("82 = %02x",dunhuang_82);
}
#endif
static ADDRESS_MAP_START( dunhuang_io_map, AS_IO, 8, dunhuang_state )
AM_RANGE( 0x0000, 0x0000 ) AM_WRITE(dunhuang_pos_x_w )
AM_RANGE( 0x0001, 0x0001 ) AM_WRITE(dunhuang_pos_y_w )
AM_RANGE( 0x0002, 0x0004 ) AM_WRITE(dunhuang_tile_w )
void video_manager::update_throttle(attotime emutime)
{
/*
Throttling theory:
This routine is called periodically with an up-to-date emulated time.
The idea is to synchronize real time with emulated time. We do this
by "throttling", or waiting for real time to catch up with emulated
time.
In an ideal world, it will take less real time to emulate and render
each frame than the emulated time, so we need to slow things down to
get both times in sync.
There are many complications to this model:
* some games run too slow, so each frame we get further and
further behind real time; our only choice here is to not
throttle
* some games have very uneven frame rates; one frame will take
a long time to emulate, and the next frame may be very fast
* we run on top of multitasking OSes; sometimes execution time
is taken away from us, and this means we may not get enough
time to emulate one frame
* we may be paused, and emulated time may not be marching
forward
* emulated time could jump due to resetting the machine or
restoring from a saved state
*/
static const UINT8 popcount[256] =
{
0,1,1,2,1,2,2,3, 1,2,2,3,2,3,3,4, 1,2,2,3,2,3,3,4, 2,3,3,4,3,4,4,5,
1,2,2,3,2,3,3,4, 2,3,3,4,3,4,4,5, 2,3,3,4,3,4,4,5, 3,4,4,5,4,5,5,6,
1,2,2,3,2,3,3,4, 2,3,3,4,3,4,4,5, 2,3,3,4,3,4,4,5, 3,4,4,5,4,5,5,6,
2,3,3,4,3,4,4,5, 3,4,4,5,4,5,5,6, 3,4,4,5,4,5,5,6, 4,5,5,6,5,6,6,7,
1,2,2,3,2,3,3,4, 2,3,3,4,3,4,4,5, 2,3,3,4,3,4,4,5, 3,4,4,5,4,5,5,6,
2,3,3,4,3,4,4,5, 3,4,4,5,4,5,5,6, 3,4,4,5,4,5,5,6, 4,5,5,6,5,6,6,7,
2,3,3,4,3,4,4,5, 3,4,4,5,4,5,5,6, 3,4,4,5,4,5,5,6, 4,5,5,6,5,6,6,7,
3,4,4,5,4,5,5,6, 4,5,5,6,5,6,6,7, 4,5,5,6,5,6,6,7, 5,6,6,7,6,7,7,8
};
// outer scope so we can break out in case of a resync
while (1)
{
// apply speed factor to emu time
if (m_speed != 0 && m_speed != 1000)
{
// multiply emutime by 1000, then divide by the global speed factor
emutime = (emutime * 1000) / m_speed;
}
// compute conversion factors up front
osd_ticks_t ticks_per_second = osd_ticks_per_second();
attoseconds_t attoseconds_per_tick = ATTOSECONDS_PER_SECOND / ticks_per_second;
// if we're paused, emutime will not advance; instead, we subtract a fixed
// amount of time (1/60th of a second) from the emulated time that was passed in,
// and explicitly reset our tracked real and emulated timers to that value ...
// this means we pretend that the last update was exactly 1/60th of a second
// ago, and was in sync in both real and emulated time
if (machine().paused())
{
m_throttle_emutime = emutime - attotime(0, ATTOSECONDS_PER_SECOND / PAUSED_REFRESH_RATE);
m_throttle_realtime = m_throttle_emutime;
}
// attempt to detect anomalies in the emulated time by subtracting the previously
// reported value from our current value; this should be a small value somewhere
// between 0 and 1/10th of a second ... anything outside of this range is obviously
// wrong and requires a resync
attoseconds_t emu_delta_attoseconds = (emutime - m_throttle_emutime).as_attoseconds();
if (emu_delta_attoseconds < 0 || emu_delta_attoseconds > ATTOSECONDS_PER_SECOND / 10)
{
if (LOG_THROTTLE)
logerror("Resync due to weird emutime delta: %s\n", attotime(0, emu_delta_attoseconds).as_string(18));
break;
}
// now determine the current real time in OSD-specified ticks; we have to be careful
// here because counters can wrap, so we only use the difference between the last
// read value and the current value in our computations
osd_ticks_t diff_ticks = osd_ticks() - m_throttle_last_ticks;
m_throttle_last_ticks += diff_ticks;
// if it has been more than a full second of real time since the last call to this
// function, we just need to resynchronize
if (diff_ticks >= ticks_per_second)
{
if (LOG_THROTTLE)
logerror("Resync due to real time advancing by more than 1 second\n");
break;
}
// convert this value into attoseconds for easier comparison
attoseconds_t real_delta_attoseconds = diff_ticks * attoseconds_per_tick;
// now update our real and emulated timers with the current values
m_throttle_emutime = emutime;
m_throttle_realtime += attotime(0, real_delta_attoseconds);
// keep a history of whether or not emulated time beat real time over the last few
// updates; this can be used for future heuristics
m_throttle_history = (m_throttle_history << 1) | (emu_delta_attoseconds > real_delta_attoseconds);
// determine how far ahead real time is versus emulated time; note that we use the
// accumulated times for this instead of the deltas for the current update because
// we want to track time over a longer duration than a single update
attoseconds_t real_is_ahead_attoseconds = (m_throttle_emutime - m_throttle_realtime).as_attoseconds();
// if we're more than 1/10th of a second out, or if we are behind at all and emulation
// is taking longer than the real frame, we just need to resync
if (real_is_ahead_attoseconds < -ATTOSECONDS_PER_SECOND / 10 ||
(real_is_ahead_attoseconds < 0 && popcount[m_throttle_history & 0xff] < 6))
{
if (LOG_THROTTLE)
logerror("Resync due to being behind: %s (history=%08X)\n", attotime(0, -real_is_ahead_attoseconds).as_string(18), m_throttle_history);
break;
}
// if we're behind, it's time to just get out
if (real_is_ahead_attoseconds < 0)
return;
// compute the target real time, in ticks, where we want to be
osd_ticks_t target_ticks = m_throttle_last_ticks + real_is_ahead_attoseconds / attoseconds_per_tick;
// throttle until we read the target, and update real time to match the final time
diff_ticks = throttle_until_ticks(target_ticks) - m_throttle_last_ticks;
m_throttle_last_ticks += diff_ticks;
m_throttle_realtime += attotime(0, diff_ticks * attoseconds_per_tick);
return;
}
// reset realtime and emutime to the same value
m_throttle_realtime = m_throttle_emutime = emutime;
}
void neogeo_state::create_interrupt_timers()
{
m_display_position_interrupt_timer = machine().scheduler().timer_alloc(timer_expired_delegate(FUNC(neogeo_state::display_position_interrupt_callback),this));
m_display_position_vblank_timer = machine().scheduler().timer_alloc(timer_expired_delegate(FUNC(neogeo_state::display_position_vblank_callback),this));
m_vblank_interrupt_timer = machine().scheduler().timer_alloc(timer_expired_delegate(FUNC(neogeo_state::vblank_interrupt_callback),this));
}
void osborne1_state::video_start()
{
machine().first_screen()->register_screen_bitmap(m_bitmap);
}
int osborne1_daisy_device::z80daisy_irq_state()
{
osborne1_state *state = machine().driver_data<osborne1_state>();
return ( state->m_pia_1_irq_state ? Z80_DAISY_INT : 0 );
}
void mm1_state::machine_start()
{
address_space *program = m_maincpu->memory().space(AS_PROGRAM);
/* find memory regions */
m_key_rom = machine().region("keyboard")->base();
/* setup memory banking */
program->install_read_bank(0x0000, 0x0fff, "bank1");
program->unmap_write(0x0000, 0x0fff);
memory_configure_bank(machine(), "bank1", 0, 1, machine().region("bios")->base(), 0);
memory_configure_bank(machine(), "bank1", 1, 1, ram_get_ptr(machine().device(RAM_TAG)), 0);
memory_set_bank(machine(), "bank1", 0);
/* register for state saving */
state_save_register_global(machine(), m_sense);
state_save_register_global(machine(), m_drive);
state_save_register_global(machine(), m_llen);
state_save_register_global(machine(), m_intc);
state_save_register_global(machine(), m_rx21);
state_save_register_global(machine(), m_tx21);
state_save_register_global(machine(), m_rcl);
state_save_register_global(machine(), m_recall);
state_save_register_global(machine(), m_dack3);
}
~debug_area()
{
//this->target->debug_free(*this->container);
machine().debug_view().free_view(*this->view);
}
void z88_32k_rom_device::device_start()
{
m_rom = machine().memory().region_alloc(tag(), get_cart_size(), 1, ENDIANNESS_LITTLE)->base();
}
UINT32 gcpinbal_state::screen_update_gcpinbal(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
{
int i;
UINT16 tile_sets = 0;
UINT8 layer[3];
#ifdef MAME_DEBUG
if (machine().input().code_pressed_once(KEYCODE_V))
{
m_dislayer[0] ^= 1;
popmessage("bg0: %01x", m_dislayer[0]);
}
if (machine().input().code_pressed_once(KEYCODE_B))
{
m_dislayer[1] ^= 1;
popmessage("bg1: %01x", m_dislayer[1]);
}
if (machine().input().code_pressed_once(KEYCODE_N))
{
m_dislayer[2] ^= 1;
popmessage("fg: %01x", m_dislayer[2]);
}
#endif
m_scrollx[0] = m_ioc_ram[0x14 / 2];
m_scrolly[0] = m_ioc_ram[0x16 / 2];
m_scrollx[1] = m_ioc_ram[0x18 / 2];
m_scrolly[1] = m_ioc_ram[0x1a / 2];
m_scrollx[2] = m_ioc_ram[0x1c / 2];
m_scrolly[2] = m_ioc_ram[0x1e / 2];
tile_sets = m_ioc_ram[0x88 / 2];
m_bg0_gfxset = (tile_sets & 0x400) ? 0x1000 : 0;
m_bg1_gfxset = (tile_sets & 0x800) ? 0x1000 : 0;
for (i = 0; i < 3; i++)
{
m_tilemap[i]->set_scrollx(0, m_scrollx[i]);
m_tilemap[i]->set_scrolly(0, m_scrolly[i]);
}
screen.priority().fill(0, cliprect);
bitmap.fill(0, cliprect);
layer[0] = 0;
layer[1] = 1;
layer[2] = 2;
#ifdef MAME_DEBUG
if (m_dislayer[layer[0]] == 0)
#endif
m_tilemap[layer[0]]->draw(screen, bitmap, cliprect, TILEMAP_DRAW_OPAQUE, 1);
#ifdef MAME_DEBUG
if (m_dislayer[layer[1]] == 0)
#endif
m_tilemap[layer[1]]->draw(screen, bitmap, cliprect, 0, 2);
#ifdef MAME_DEBUG
if (m_dislayer[layer[2]] == 0)
#endif
m_tilemap[layer[2]]->draw(screen, bitmap, cliprect, 0, 4);
int sprpri = (m_ioc_ram[0x68 / 2] & 0x8800) ? 0 : 1;
m_sprgen->gcpinbal_draw_sprites(screen, bitmap, cliprect, m_gfxdecode, 16, sprpri);
#if 0
{
// char buf[80];
sprintf(buf,"bg0_gfx: %04x bg1_gfx: %04x ", m_bg0_gfxset, m_bg1_gfxset);
popmessage(buf);
}
#endif
return 0;
}
void sbugger_state::video_start()
{
m_tilemap = &machine().tilemap().create(*m_gfxdecode, tilemap_get_info_delegate(FUNC(sbugger_state::get_tile_info),this), TILEMAP_SCAN_ROWS, 8, 16, 64, 16);
}
void video_manager::postload()
{
m_movie_next_frame_time = machine().time();
}
osd_font sdl_osd_interface::font_open(const char *_name, int &height)
{
#if !(SDLMAME_SDL2)
TTF_Font *font = (TTF_Font *)NULL;
bool bakedstyles = false;
int style = 0;
// accept qualifiers from the name
astring name(_name);
if (name == "default")
{
name = "Liberation Sans";
}
bool bold = (name.replace(0, "[B]", "") + name.replace(0, "[b]", "") > 0);
bool italic = (name.replace(0, "[I]", "") + name.replace(0, "[i]", "") > 0);
bool underline = (name.replace(0, "[U]", "") + name.replace(0, "[u]", "") > 0);
bool strike = (name.replace(0, "[S]", "") + name.replace(0, "[s]", "") > 0);
// first up, try it as a filename
font = TTF_OpenFont_Magic(name, POINT_SIZE);
// if no success, try the font path
if (!font)
{
mame_printf_verbose("Searching font %s in -%s\n", name.cstr(), OPTION_FONTPATH);
emu_file file(machine().options().font_path(), OPEN_FLAG_READ);
if (file.open(name) == FILERR_NONE)
{
astring full_name = file.fullpath();
font = TTF_OpenFont_Magic(full_name, POINT_SIZE);
if (font)
mame_printf_verbose("Found font %s\n", full_name.cstr());
}
}
// if that didn't work, crank up the FontConfig database
#ifndef SDLMAME_HAIKU
if (!font)
{
font = search_font_config(name, bold, italic, underline, bakedstyles);
}
#endif
if (!font)
{
if (!BDF_Check_Magic(name))
{
printf("WARNING: font %s, is not TrueType or BDF, using MAME default\n", name.cstr());
}
return NULL;
}
// apply styles
if (!bakedstyles)
{
style |= bold ? TTF_STYLE_BOLD : 0;
style |= italic ? TTF_STYLE_ITALIC : 0;
}
style |= underline ? TTF_STYLE_UNDERLINE : 0;
// SDL_ttf 2.0.9 and earlier does not define TTF_STYLE_STRIKETHROUGH
#if SDL_VERSIONNUM(TTF_MAJOR_VERSION, TTF_MINOR_VERSION, TTF_PATCHLEVEL) > SDL_VERSIONNUM(2,0,9)
style |= strike ? TTF_STYLE_STRIKETHROUGH : 0;
#else
if (strike)
mame_printf_warning("Ignoring strikethrough for SDL_TTF with version less 2.0.10\n");
#endif // PATCHLEVEL
TTF_SetFontStyle(font, style);
height = TTF_FontLineSkip(font);
return (osd_font)font;
#else
return (osd_font)NULL;
#endif
}
inline int video_manager::original_speed_setting() const
{
return machine().options().speed() * 1000.0 + 0.5;
}
void bsktball_state::video_start()
{
m_bg_tilemap = &machine().tilemap().create(tilemap_get_info_delegate(FUNC(bsktball_state::get_bg_tile_info),this), TILEMAP_SCAN_ROWS, 8, 8, 32, 32);
}
void aquarius_state::video_start()
{
m_tilemap = &machine().tilemap().create(*m_gfxdecode, tilemap_get_info_delegate(FUNC(aquarius_state::aquarius_gettileinfo),this), TILEMAP_SCAN_ROWS, 8, 8, 40, 25);
}
void k053247_device::k053247_sprites_draw_common( _BitmapClass &bitmap, const rectangle &cliprect )
{
#define NUM_SPRITES 256
int code, color, x, y, shadow, shdmask, count, temp, primask;
int sortedlist[NUM_SPRITES];
int offs,zcode;
UINT8 drawmode_table[256];
UINT8 shadowmode_table[256];
memset(drawmode_table, DRAWMODE_SOURCE, sizeof(drawmode_table));
drawmode_table[0] = DRAWMODE_NONE;
memset(shadowmode_table, DRAWMODE_SHADOW, sizeof(shadowmode_table));
shadowmode_table[0] = DRAWMODE_NONE;
/*
safeguard older drivers missing any of the following video attributes:
VIDEO_HAS_SHADOWS | VIDEO_HAS_HIGHLIGHTS
*/
if (m_palette->shadows_enabled())
{
if (sizeof(typename _BitmapClass::pixel_t) == 4 && (m_palette->hilights_enabled()))
shdmask = 3; // enable all shadows and highlights
else
shdmask = 0; // enable default shadows
}
else
shdmask = -1; // disable everything
/*
The k053247 does not draw pixels on top of those with equal or smaller Z-values
regardless of priority. Embedded shadows inherit Z-values from their host sprites
but do not assume host priorities unless explicitly told. In other words shadows
can have priorities different from that of normal pens in the same sprite,
in addition to the ability of masking themselves from specific layers or pixels
on the other sprites.
In front-to-back rendering, sprites cannot sandwich between alpha blended layers
or the draw code will have to figure out the percentage opacities of what is on
top and beneath each sprite pixel and blend the target accordingly. The process
is overly demanding for realtime software and is thus another shortcoming of
pdrawgfx and pixel based mixers. Even mahjong games with straight forward video
subsystems are feeling the impact by which the girls cannot appear under
translucent dialogue boxes.
These are a small part of the k053247's feature set but many games expect them
to be the minimum compliances. The specification will undoubtedly require
redesigning the priority system from the ground up. Drawgfx.c and tilemap.c must
also undergo heavy facelifts but in the end the changes could hurt simpler games
more than they help complex systems; therefore the new engine should remain
completely stand alone and self-contained. Implementation details are being
hammered down but too early to make propositions.
*/
// Prebuild a sorted table by descending Z-order.
zcode = m_z_rejection;
offs = count = 0;
if (zcode == -1)
{
for (; offs < 0x800; offs += 8)
if (m_ram[offs] & 0x8000)
sortedlist[count++] = offs;
}
else
{
for (; offs < 0x800; offs += 8)
if ((m_ram[offs] & 0x8000) && ((m_ram[offs] & 0xff) != zcode))
sortedlist[count++] = offs;
}
int w = count;
count--;
int h = count;
if (!(m_kx47_regs[0xc / 2] & 0x10))
{
// sort objects in decending order(smaller z closer) when OPSET PRI is clear
for (y = 0; y < h; y++)
{
offs = sortedlist[y];
zcode = m_ram[offs] & 0xff;
for (x = y + 1; x < w; x++)
{
temp = sortedlist[x];
code = m_ram[temp] & 0xff;
if (zcode <= code)
{
zcode = code;
sortedlist[x] = offs;
sortedlist[y] = offs = temp;
}
}
}
}
else
{
// sort objects in ascending order(bigger z closer) when OPSET PRI is set
for (y = 0; y < h; y++)
{
offs = sortedlist[y];
zcode = m_ram[offs] & 0xff;
for (x = y + 1; x < w; x++)
{
temp = sortedlist[x];
code = m_ram[temp] & 0xff;
if (zcode >= code)
{
zcode = code;
sortedlist[x] = offs;
sortedlist[y] = offs = temp;
}
}
}
}
for (; count >= 0; count--)
{
offs = sortedlist[count];
code = m_ram[offs + 1];
shadow = color = m_ram[offs + 6];
primask = 0;
m_callback(machine(), &code, &color, &primask);
k053247_draw_single_sprite_gxcore( bitmap, cliprect,
NULL, NULL,
code, m_ram, offs,
color,
/* gx only */
0, 0, 0, 0,
/* non-gx only */
primask,shadow,drawmode_table,shadowmode_table,shdmask
);
} // end of sprite-list loop
#undef NUM_SPRITES
}
inline void ieee488_device::set_signal(device_t *device, int signal, int state)
{
bool changed = false;
if (device == this)
{
if (m_line[signal] != state)
{
if (LOG) logerror("%s IEEE488: '%s' %s %u\n", machine().describe_context(), tag(), SIGNAL_NAME[signal], state);
m_line[signal] = state;
changed = true;
}
}
else
{
daisy_entry *entry = m_device_list.first();
while (entry)
{
if (!strcmp(entry->m_device->tag(), device->tag()))
{
if (entry->m_line[signal] != state)
{
if (LOG) logerror("%s IEEE488: '%s' %s %u\n", machine().describe_context(), device->tag(), SIGNAL_NAME[signal], state);
entry->m_line[signal] = state;
changed = true;
}
}
entry = entry->next();
}
}
if (changed)
{
switch (signal)
{
case EOI: m_out_eoi_func(state); break;
case DAV: m_out_dav_func(state); break;
case NRFD: m_out_nrfd_func(state); break;
case NDAC: m_out_ndac_func(state); break;
case IFC: m_out_ifc_func(state); break;
case SRQ: m_out_srq_func(state); break;
case ATN: m_out_atn_func(state); break;
case REN: m_out_ren_func(state); break;
}
daisy_entry *entry = m_device_list.first();
while (entry)
{
switch (signal)
{
case EOI:
entry->m_interface->ieee488_eoi(state);
break;
case DAV:
entry->m_interface->ieee488_dav(state);
break;
case NRFD:
entry->m_interface->ieee488_nrfd(state);
break;
case NDAC:
entry->m_interface->ieee488_ndac(state);
break;
case IFC:
entry->m_interface->ieee488_ifc(state);
break;
case SRQ:
entry->m_interface->ieee488_srq(state);
break;
case ATN:
entry->m_interface->ieee488_atn(state);
break;
case REN:
entry->m_interface->ieee488_ren(state);
break;
}
entry = entry->next();
}
if (LOG) logerror("IEEE488: EOI %u DAV %u NRFD %u NDAC %u IFC %u SRQ %u ATN %u REN %u DIO %02x\n",
get_signal(EOI), get_signal(DAV), get_signal(NRFD), get_signal(NDAC),
get_signal(IFC), get_signal(SRQ), get_signal(ATN), get_signal(REN), get_data());
}
}
void triplhnt_state::video_start()
{
m_screen->register_screen_bitmap(m_helper);
m_bg_tilemap = &machine().tilemap().create(m_gfxdecode, tilemap_get_info_delegate(FUNC(triplhnt_state::get_tile_info),this), TILEMAP_SCAN_ROWS, 16, 16, 16, 16);
}
/******************************************************************/
void galastrm_state::galastrm_exit()
{
poly_free(m_poly);
}
void galastrm_state::video_start()
{
m_spritelist = auto_alloc_array(machine(), struct gs_tempsprite, 0x4000);
m_screen->register_screen_bitmap(m_tmpbitmaps);
m_screen->register_screen_bitmap(m_polybitmap);
m_poly = poly_alloc(machine(), 16, sizeof(gs_poly_extra_data), POLYFLAG_ALLOW_QUADS);
machine().add_notifier(MACHINE_NOTIFY_EXIT, machine_notify_delegate(FUNC(galastrm_state::galastrm_exit), this));
}
/************************************************************
SPRITE DRAW ROUTINES
We draw a series of small tiles ("chunks") together to
create each big sprite. The spritemap rom provides the lookup
table for this. The game hardware looks up 16x16 sprite chunks
from the spritemap rom, creating a 64x64 sprite like this:
0 1 2 3
4 5 6 7
8 9 10 11
12 13 14 15
file_error video_manager::open_next(emu_file &file, const char *extension)
{
UINT32 origflags = file.openflags();
// handle defaults
const char *snapname = machine().options().snap_name();
if (snapname == NULL || snapname[0] == 0)
snapname = "%g/%i";
astring snapstr(snapname);
// strip any extension in the provided name
int index = snapstr.rchr(0, '.');
if (index != -1)
snapstr.substr(0, index);
// handle %d in the template (for image devices)
astring snapdev("%d_");
int pos = snapstr.find(0, snapdev);
if (pos != -1)
{
// if more %d are found, revert to default and ignore them all
if (snapstr.find(pos + 3, snapdev) != -1)
snapstr.cpy("%g/%i");
// else if there is a single %d, try to create the correct snapname
else
{
int name_found = 0;
// find length of the device name
int end1 = snapstr.find(pos + 3, "/");
int end2 = snapstr.find(pos + 3, "%");
int end = -1;
if ((end1 != -1) && (end2 != -1))
end = MIN(end1, end2);
else if (end1 != -1)
end = end1;
else if (end2 != -1)
end = end2;
else
end = snapstr.len();
if (end - pos < 3)
fatalerror("Something very wrong is going on!!!");
// copy the device name to an astring
astring snapdevname;
snapdevname.cpysubstr(snapstr, pos + 3, end - pos - 3);
//printf("check template: %s\n", snapdevname.cstr());
// verify that there is such a device for this system
device_image_interface *image = NULL;
for (bool gotone = machine().devicelist().first(image); gotone; gotone = image->next(image))
{
// get the device name
astring tempdevname(image->brief_instance_name());
//printf("check device: %s\n", tempdevname.cstr());
if (snapdevname.cmp(tempdevname) == 0)
{
// verify that such a device has an image mounted
if (image->basename() != NULL)
{
astring filename(image->basename());
// strip extension
filename.substr(0, filename.rchr(0, '.'));
// setup snapname and remove the %d_
snapstr.replace(0, snapdevname, filename);
snapstr.del(pos, 3);
//printf("check image: %s\n", filename.cstr());
name_found = 1;
}
}
}
// or fallback to default
if (name_found == 0)
snapstr.cpy("%g/%i");
}
}
// add our own extension
snapstr.cat(".").cat(extension);
// substitute path and gamename up front
snapstr.replace(0, "/", PATH_SEPARATOR);
snapstr.replace(0, "%g", machine().basename());
// determine if the template has an index; if not, we always use the same name
astring fname;
if (snapstr.find(0, "%i") == -1)
fname.cpy(snapstr);
// otherwise, we scan for the next available filename
else
{
// try until we succeed
astring seqtext;
file.set_openflags(OPEN_FLAG_READ);
for (int seq = 0; ; seq++)
{
// build up the filename
fname.cpy(snapstr).replace(0, "%i", seqtext.format("%04d", seq).cstr());
// try to open the file; stop when we fail
file_error filerr = file.open(fname);
if (filerr != FILERR_NONE)
break;
}
}
// create the final file
file.set_openflags(origflags);
return file.open(fname);
}
void atarisy4_state::video_start()
{
m_poly = poly_alloc(machine(), 1024, sizeof(poly_extra_data), POLYFLAG_NO_WORK_QUEUE);
}
void video_manager::frame_update(bool debug)
{
// only render sound and video if we're in the running phase
int phase = machine().phase();
bool skipped_it = m_skipping_this_frame;
if (phase == MACHINE_PHASE_RUNNING && (!machine().paused() || machine().options().update_in_pause()))
{
bool anything_changed = finish_screen_updates();
// if none of the screens changed and we haven't skipped too many frames in a row,
// mark this frame as skipped to prevent throttling; this helps for games that
// don't update their screen at the monitor refresh rate
if (!anything_changed && !m_auto_frameskip && m_frameskip_level == 0 && m_empty_skip_count++ < 3)
skipped_it = true;
else
m_empty_skip_count = 0;
}
// draw the user interface
ui_update_and_render(machine(), &machine().render().ui_container());
// update the internal render debugger
debugint_update_during_game(machine());
// if we're throttling, synchronize before rendering
attotime current_time = machine().time();
if (!debug && !skipped_it && effective_throttle())
update_throttle(current_time);
// ask the OSD to update
g_profiler.start(PROFILER_BLIT);
machine().osd().update(!debug && skipped_it);
g_profiler.stop();
// perform tasks for this frame
if (!debug)
machine().call_notifiers(MACHINE_NOTIFY_FRAME);
// update frameskipping
if (!debug)
update_frameskip();
// update speed computations
if (!debug && !skipped_it)
recompute_speed(current_time);
// call the end-of-frame callback
if (phase == MACHINE_PHASE_RUNNING)
{
// reset partial updates if we're paused or if the debugger is active
if (machine().primary_screen != NULL && (machine().paused() || debug || debugger_within_instruction_hook(machine())))
machine().primary_screen->scanline0_callback();
// otherwise, call the video EOF callback
else
{
g_profiler.start(PROFILER_VIDEO);
for (screen_device *screen = machine().first_screen(); screen != NULL; screen = screen->next_screen())
screen->screen_eof();
g_profiler.stop();
}
}
}
void esripsys_state::video_start()
{
struct line_buffer_t *line_buffer = m_line_buffer;
int i;
/* Allocate memory for the two 512-pixel line buffers */
line_buffer[0].colour_buf = auto_alloc_array(machine(), UINT8, 512);
line_buffer[0].intensity_buf = auto_alloc_array(machine(), UINT8, 512);
line_buffer[0].priority_buf = auto_alloc_array(machine(), UINT8, 512);
line_buffer[1].colour_buf = auto_alloc_array(machine(), UINT8, 512);
line_buffer[1].intensity_buf = auto_alloc_array(machine(), UINT8, 512);
line_buffer[1].priority_buf = auto_alloc_array(machine(), UINT8, 512);
/* Create and initialise the HBLANK timers */
m_hblank_start_timer = machine().scheduler().timer_alloc(timer_expired_delegate(FUNC(esripsys_state::hblank_start_callback),this));
m_hblank_end_timer = machine().scheduler().timer_alloc(timer_expired_delegate(FUNC(esripsys_state::hblank_end_callback),this));
m_hblank_start_timer->adjust(m_screen->time_until_pos(0, ESRIPSYS_HBLANK_START));
/* Create the sprite scaling table */
m_scale_table = auto_alloc_array(machine(), UINT8, 64 * 64);
for (i = 0; i < 64; ++i)
{
int j;
for (j = 1; j < 65; ++j)
{
int p0 = 0;
int p1 = 0;
int p2 = 0;
int p3 = 0;
int p4 = 0;
int p5 = 0;
if (i & 0x1)
p0 = BIT(j, 5) && !BIT(j, 4) && !BIT(j,3) && !BIT(j, 2) && !BIT(j, 1) && !BIT(j, 0);
if (i & 0x2)
p1 = BIT(j, 4) && !BIT(j, 3) && !BIT(j, 2) && !BIT(j, 1) && !BIT(j, 0);
if (i & 0x4)
p2 = BIT(j,3) && !BIT(j, 2) && !BIT(j, 1) && !BIT(j, 0);
if (i & 0x8)
p3 = BIT(j, 2) && !BIT(j,1) && !BIT(j,0);
if (i & 0x10)
p4 = BIT(j, 1) && !BIT(j, 0);
if (i & 0x20)
p5 = BIT(j, 0);
m_scale_table[i * 64 + j - 1] = p0 | p1 | p2 | p3 | p4 | p5;
}
}
/* Now create a lookup table for scaling the sprite 'fig' value */
m_fig_scale_table = auto_alloc_array(machine(), UINT8, 1024 * 64);
for (i = 0; i < 1024; ++i)
{
int scale;
for (scale = 0; scale < 64; ++scale)
{
int input_pixels = i + 1;
int scaled_pixels = 0;
while (input_pixels)
{
if (m_scale_table[scale * 64 + (scaled_pixels & 0x3f)] == 0)
input_pixels--;
scaled_pixels++;
}
m_fig_scale_table[i * 64 + scale] = scaled_pixels - 1;
}
}
/* Register stuff for state saving */
save_pointer(NAME(line_buffer[0].colour_buf), 512);
save_pointer(NAME(line_buffer[0].intensity_buf), 512);
save_pointer(NAME(line_buffer[0].priority_buf), 512);
save_pointer(NAME(line_buffer[1].colour_buf), 512);
save_pointer(NAME(line_buffer[1].intensity_buf), 512);
save_pointer(NAME(line_buffer[1].priority_buf), 512);
save_item(NAME(m_video_firq));
save_item(NAME(m_bg_intensity));
save_item(NAME(m_hblank));
save_item(NAME(m_video_firq_en));
save_item(NAME(m_frame_vbl));
save_item(NAME(m_12sel));
}
void video_manager::begin_recording(const char *name, movie_format format)
{
// stop any existign recording
end_recording();
// create a snapshot bitmap so we know what the target size is
create_snapshot_bitmap(NULL);
// reset the state
m_movie_frame = 0;
m_movie_next_frame_time = machine().time();
// start up an AVI recording
if (format == MF_AVI)
{
// build up information about this new movie
avi_movie_info info;
info.video_format = 0;
info.video_timescale = 1000 * ((machine().primary_screen != NULL) ? ATTOSECONDS_TO_HZ(machine().primary_screen->frame_period().attoseconds) : screen_device::DEFAULT_FRAME_RATE);
info.video_sampletime = 1000;
info.video_numsamples = 0;
info.video_width = m_snap_bitmap->width;
info.video_height = m_snap_bitmap->height;
info.video_depth = 24;
info.audio_format = 0;
info.audio_timescale = machine().sample_rate();
info.audio_sampletime = 1;
info.audio_numsamples = 0;
info.audio_channels = 2;
info.audio_samplebits = 16;
info.audio_samplerate = machine().sample_rate();
// create a new temporary movie file
file_error filerr;
astring fullpath;
{
emu_file tempfile(machine().options().snapshot_directory(), OPEN_FLAG_WRITE | OPEN_FLAG_CREATE | OPEN_FLAG_CREATE_PATHS);
if (name != NULL)
filerr = tempfile.open(name);
else
filerr = open_next(tempfile, "avi");
// compute the frame time
m_movie_frame_period = attotime::from_seconds(1000) / info.video_timescale;
// if we succeeded, make a copy of the name and create the real file over top
if (filerr == FILERR_NONE)
fullpath = tempfile.fullpath();
}
if (filerr == FILERR_NONE)
{
// create the file and free the string
avi_error avierr = avi_create(fullpath, &info, &m_avifile);
if (avierr != AVIERR_NONE)
mame_printf_error("Error creating AVI: %s\n", avi_error_string(avierr));
}
}
// start up a MNG recording
else if (format == MF_MNG)
{
// create a new movie file and start recording
m_mngfile = auto_alloc(machine(), emu_file(machine().options().snapshot_directory(), OPEN_FLAG_WRITE | OPEN_FLAG_CREATE | OPEN_FLAG_CREATE_PATHS));
file_error filerr;
if (name != NULL)
filerr = m_mngfile->open(name);
else
filerr = open_next(*m_mngfile, "mng");
if (filerr == FILERR_NONE)
{
// start the capture
int rate = (machine().primary_screen != NULL) ? ATTOSECONDS_TO_HZ(machine().primary_screen->frame_period().attoseconds) : screen_device::DEFAULT_FRAME_RATE;
png_error pngerr = mng_capture_start(*m_mngfile, m_snap_bitmap, rate);
if (pngerr != PNGERR_NONE)
return end_recording();
// compute the frame time
m_movie_frame_period = attotime::from_hz(rate);
}
else
{
mame_printf_error("Error creating MNG\n");
global_free(m_mngfile);
m_mngfile = NULL;
}
}
}
void menu_software_list::handle()
{
const entry_info *entry;
const entry_info *selected_entry = nullptr;
int bestmatch = 0;
// process the menu
const event *event = process(0);
if (event && event->itemref)
{
if ((FPTR)event->itemref == 1 && event->iptkey == IPT_UI_SELECT)
{
m_ordered_by_shortname = !m_ordered_by_shortname;
m_entrylist = nullptr;
// reset the char buffer if we change ordering criterion
memset(m_filename_buffer, '\0', ARRAY_LENGTH(m_filename_buffer));
// reload the menu with the new order
reset(reset_options::REMEMBER_REF);
machine().popmessage(_("Switched Order: entries now ordered by %s"), m_ordered_by_shortname ? _("shortname") : _("description"));
}
// handle selections
else if (event->iptkey == IPT_UI_SELECT)
{
entry_info *info = (entry_info *) event->itemref;
m_result = info->short_name;
menu::stack_pop(machine());
}
else if (event->iptkey == IPT_SPECIAL)
{
auto const buflen = std::strlen(m_filename_buffer);
bool update_selected = false;
if ((event->unichar == 8) || (event->unichar == 0x7f))
{
// if it's a backspace and we can handle it, do so
if (0 < buflen)
{
*const_cast<char *>(utf8_previous_char(&m_filename_buffer[buflen])) = 0;
update_selected = true;
ui().popup_time(ERROR_MESSAGE_TIME, "%s", m_filename_buffer);
}
}
else if (event->is_char_printable())
{
// if it's any other key and we're not maxed out, update
if (event->append_char(m_filename_buffer, buflen))
{
update_selected = true;
ui().popup_time(ERROR_MESSAGE_TIME, "%s", m_filename_buffer);
}
}
if (update_selected)
{
const entry_info *cur_selected;
// if the current selection is a software entry, start search from here
if ((FPTR)event->itemref != 1)
cur_selected= (const entry_info *)get_selection();
// else (if we are on the 'Switch Order' entry) start from the beginning
else
cur_selected = m_entrylist;
// check for entries which matches our filename_buffer:
// from current entry to the end
for (entry = cur_selected; entry != nullptr; entry = entry->next)
{
const char *compare_name = m_ordered_by_shortname ? entry->short_name : entry->long_name;
if (compare_name != nullptr && m_filename_buffer != nullptr)
{
int match = 0;
for (int i = 0; i < ARRAY_LENGTH(m_filename_buffer); i++)
{
if (core_strnicmp(compare_name, m_filename_buffer, i) == 0)
match = i;
}
if (match > bestmatch)
{
bestmatch = match;
selected_entry = entry;
}
}
}
// and from the first entry to current one
for (entry = m_entrylist; entry != cur_selected; entry = entry->next)
{
const char *compare_name = m_ordered_by_shortname ? entry->short_name : entry->long_name;
if (compare_name != nullptr && m_filename_buffer != nullptr)
{
int match = 0;
for (int i = 0; i < ARRAY_LENGTH(m_filename_buffer); i++)
{
if (core_strnicmp(compare_name, m_filename_buffer, i) == 0)
match = i;
}
if (match > bestmatch)
{
bestmatch = match;
selected_entry = entry;
}
}
}
if (selected_entry != nullptr && selected_entry != cur_selected)
{
set_selection((void *)selected_entry);
top_line = selected - (visible_lines / 2);
}
}
}
else if (event->iptkey == IPT_UI_CANCEL)
{
// reset the char buffer also in this case
if (m_filename_buffer[0] != '\0')
memset(m_filename_buffer, '\0', ARRAY_LENGTH(m_filename_buffer));
m_result = m_filename_buffer;
menu::stack_pop(machine());
}
}
}
void hvyunit_state::video_start()
{
m_bg_tilemap = &machine().tilemap().create(tilemap_get_info_delegate(FUNC(hvyunit_state::get_bg_tile_info),this), TILEMAP_SCAN_ROWS, 16, 16, 32, 32);
}