empathicqubit/lsnes
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Use named field initializers in cores

Browse source
This commit is contained in:
Ilari Liusvaara 2013-03-13 18:39:08 +02:00
parent 8f57ae5834
commit 43145be27a
3 changed files with 124 additions and 169 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

120
src/emulation/bsnes-legacy/core.cpp
View file

@ -614,12 +614,10 @@ namespace
}
core_core_params _bsnes_core = {
//Identify core.
[]() -> std::string {
.core_identifier = []() -> std::string {
return (stringfmt() << snes_library_id() << " (" << SNES::Info::Profile << " core)").str();
},
//Set region.
[](core_region& region) -> bool {
.set_region = [](core_region& region) -> bool {
if(&region == &region_auto)
SNES::config.region = SNES::System::Region::Autodetect;
else if(&region == &region_ntsc)
@ -630,8 +628,7 @@ namespace
return false;
return true;
},
//Get video rate
[]() -> std::pair<uint32_t, uint32_t> {
.video_rate = []() -> std::pair<uint32_t, uint32_t> {
if(!internal_rom)
return std::make_pair(60, 1);
uint32_t div;
@ -641,18 +638,15 @@ namespace
div = last_interlace ? DURATION_NTSC_FIELD : DURATION_NTSC_FRAME;
return std::make_pair(SNES::system.cpu_frequency(), div);
},
//Get audio rate
[]() -> std::pair<uint32_t, uint32_t> {
.audio_rate = []() -> std::pair<uint32_t, uint32_t> {
if(!internal_rom)
return std::make_pair(64081, 2);
return std::make_pair(SNES::system.apu_frequency(), static_cast<uint32_t>(768));
},
//Get SNES CPU/APU rate.
[]() -> std::pair<uint32_t, uint32_t> {
.snes_rate = []() -> std::pair<uint32_t, uint32_t> {
return std::make_pair(SNES::system.cpu_frequency(), SNES::system.apu_frequency());
},
//Store SRAM.
[]() -> std::map<std::string, std::vector<char>> {
.save_sram = []() -> std::map<std::string, std::vector<char>> {
std::map<std::string, std::vector<char>> out;
if(!internal_rom)
return out;
@ -666,8 +660,7 @@ namespace
}
return out;
},
//Load SRAM.
[](std::map<std::string, std::vector<char>>& sram) -> void {
.load_sram = [](std::map<std::string, std::vector<char>>& sram) -> void {
std::set<std::string> used;
if(!internal_rom) {
for(auto i : sram)
@ -695,16 +688,14 @@ namespace
messages << "WARNING: SRAM '" << i.first << ": Not found on cartridge."
<< std::endl;
},
//Serialize core.
[](std::vector<char>& out) -> void {
.serialize = [](std::vector<char>& out) -> void {
if(!internal_rom)
throw std::runtime_error("No ROM loaded");
serializer s = SNES::system.serialize();
out.resize(s.size());
memcpy(&out[0], s.data(), s.size());
},
//Unserialize core.
[](const char* in, size_t insize) -> void {
.unserialize = [](const char* in, size_t insize) -> void {
if(!internal_rom)
throw std::runtime_error("No ROM loaded");
serializer s(reinterpret_cast<const uint8_t*>(in), insize);
@ -713,37 +704,30 @@ namespace
have_saved_this_frame = true;
do_reset_flag = -1;
},
//Get region.
[]() -> core_region& {
.get_region = []() -> core_region& {
return (SNES::system.region() == SNES::System::Region::PAL) ? region_pal : region_ntsc;
},
//Power the core.
[]() -> void {
.power = []() -> void {
if(internal_rom) snes_power();
},
//Unload the cartridge.
[]() -> void {
.unload_cartridge = []() -> void {
if(!internal_rom) return;
snes_term();
snes_unload_cartridge();
internal_rom = NULL;
},
//Get scale factors.
[](uint32_t width, uint32_t height) -> std::pair<uint32_t, uint32_t> {
.get_scale_factors = [](uint32_t width, uint32_t height) -> std::pair<uint32_t, uint32_t> {
return std::make_pair((width < 400) ? 2 : 1, (height < 400) ? 2 : 1);
},
//Install handler
[]() -> void {
.install_handler = []() -> void {
basic_init();
old = SNES::interface;
SNES::interface = &my_interface_obj;
SNES::system.init();
magic_flags |= 1;
},
//Uninstall handler
[]() -> void { SNES::interface = old; },
//Emulate frame.
[]() -> void {
.uninstall_handler = []() -> void { SNES::interface = old; },
.emulate = []() -> void {
if(!internal_rom)
return;
bool was_delay_reset = false;
@ -828,8 +812,7 @@ again2:
#endif
have_saved_this_frame = false;
},
//Run to save.
[]() -> void {
.runtosave = []() -> void {
if(!internal_rom)
return;
stepping_into_save = true;
@ -837,24 +820,16 @@ again2:
have_saved_this_frame = true;
stepping_into_save = false;
},
//Get poll flag.
[]() -> bool { return SNES::cpu.controller_flag; },
//Set poll flag.
[](bool pflag) -> void {
SNES::cpu.controller_flag = pflag;
},
//Request reset.
[](long delay, bool hard) -> void { do_reset_flag = delay; do_hreset_flag = hard; },
//Port types.
port_types,
//Cover page.
[]() -> framebuffer_raw& {
.get_pflag = []() -> bool { return SNES::cpu.controller_flag; },
.set_pflag = [](bool pflag) -> void { SNES::cpu.controller_flag = pflag; },
.request_reset = [](long delay, bool hard) -> void { do_reset_flag = delay; do_hreset_flag = hard; },
.port_types = port_types,
.draw_cover = []() -> framebuffer_raw& {
static framebuffer_raw x(cover_fbinfo);
redraw_cover_fbinfo();
return x;
},
//Short name.
[]() -> std::string
.get_core_shortname = []() -> std::string
{
#ifdef BSNES_IS_COMPAT
return (stringfmt() << "bsnes" << BSNES_VERSION << "c").str();
@ -862,8 +837,7 @@ again2:
return (stringfmt() << "bsnes" << BSNES_VERSION << "a").str();
#endif
},
//Pre-emulate frame.
[](controller_frame& cf) -> void
.pre_emulate_frame = [](controller_frame& cf) -> void
{
cf.axis3(0, 0, 1, (do_reset_flag >= 0) ? 1 : 0);
if(support_hreset)
@ -881,55 +855,61 @@ again2:
core_core bsnes_core(_bsnes_core);
core_type_params _type_snes = {
"snes", "SNES", 0, BSNES_RESET_LEVEL ,
[](core_romimage* img, std::map<std::string, std::string>& settings, uint64_t secs,
.iname = "snes", .hname = "SNES", .id = 0, .reset_support = BSNES_RESET_LEVEL ,
.load_rom = [](core_romimage* img, std::map<std::string, std::string>& settings, uint64_t secs,
uint64_t subsecs) -> int {
return load_rom<&type_snes>(img, settings, secs, subsecs,
load_rom_X1<snes_load_cartridge_normal>);
},
_controllerconfig, "sfc;smc;swc;fig;ufo;sf2;gd3;gd7;dx2;mgd;mgh", NULL, snes_regions, snes_images,
&bsnes_settings, &bsnes_core, bsnes_get_bus_map, get_VMAlist, srams
.controllerconfig = _controllerconfig, .extensions = "sfc;smc;swc;fig;ufo;sf2;gd3;gd7;dx2;mgd;mgh",
.bios = NULL, .regions = snes_regions, .images = snes_images,
.settings = &bsnes_settings, .core = &bsnes_core, .get_bus_map = bsnes_get_bus_map,
.vma_list = get_VMAlist, .srams = srams
};
core_type_params _type_bsx = {
"bsx", "BS-X (non-slotted)", 1, BSNES_RESET_LEVEL ,
[](core_romimage* img, std::map<std::string, std::string>& settings, uint64_t secs,
.iname = "bsx", .hname = "BS-X (non-slotted)", .id = 1, .reset_support = BSNES_RESET_LEVEL ,
.load_rom = [](core_romimage* img, std::map<std::string, std::string>& settings, uint64_t secs,
uint64_t subsecs) -> int {
return load_rom<&type_bsx>(img, settings, secs, subsecs,
load_rom_X2<snes_load_cartridge_bsx>);
},
_controllerconfig, "bs", "bsx.sfc", bsx_regions, bsx_images, &bsnes_settings, &bsnes_core,
bsnes_get_bus_map, get_VMAlist, srams
.controllerconfig = _controllerconfig, .extensions = "bs", .bios = "bsx.sfc", .regions = bsx_regions,
.images = bsx_images, .settings = &bsnes_settings, .core = &bsnes_core,
.get_bus_map = bsnes_get_bus_map, .vma_list = get_VMAlist, .srams = srams
};
core_type_params _type_bsxslotted = {
"bsxslotted", "BS-X (slotted)", 2, BSNES_RESET_LEVEL ,
[](core_romimage* img, std::map<std::string, std::string>& settings,
.iname = "bsxslotted", .hname = "BS-X (slotted)", .id = 2, .reset_support = BSNES_RESET_LEVEL ,
.load_rom = [](core_romimage* img, std::map<std::string, std::string>& settings,
uint64_t secs, uint64_t subsecs) -> int {
return load_rom<&type_bsxslotted>(img, settings, secs, subsecs,
load_rom_X2<snes_load_cartridge_bsx_slotted>);
},
_controllerconfig, "bss", "bsxslotted.sfc", bsxs_regions, bsxs_images, &bsnes_settings, &bsnes_core,
bsnes_get_bus_map, get_VMAlist, srams
.controllerconfig = _controllerconfig, .extensions = "bss", .bios = "bsxslotted.sfc",
.regions = bsxs_regions, .images = bsxs_images, .settings = &bsnes_settings, .core = &bsnes_core,
.get_bus_map = bsnes_get_bus_map, .vma_list = get_VMAlist, .srams = srams
};
core_type_params _type_sufamiturbo = {
"sufamiturbo", "Sufami Turbo", 3, BSNES_RESET_LEVEL ,
[](core_romimage* img, std::map<std::string, std::string>& settings, uint64_t secs,
.iname = "sufamiturbo", .hname = "Sufami Turbo", .id = 3, .reset_support = BSNES_RESET_LEVEL ,
.load_rom = [](core_romimage* img, std::map<std::string, std::string>& settings, uint64_t secs,
uint64_t subsecs) -> int {
return load_rom<&type_sufamiturbo>(img, settings, secs, subsecs,
load_rom_X3<snes_load_cartridge_sufami_turbo>);
},
_controllerconfig, "st", "sufamiturbo.sfc", sufamiturbo_regions, sufamiturbo_images, &bsnes_settings,
&bsnes_core, bsnes_get_bus_map, get_VMAlist, srams
.controllerconfig = _controllerconfig, .extensions = "st", .bios = "sufamiturbo.sfc",
.regions = sufamiturbo_regions, .images = sufamiturbo_images, .settings = &bsnes_settings,
.core = &bsnes_core, .get_bus_map = bsnes_get_bus_map, .vma_list = get_VMAlist, .srams = srams
};
core_type_params _type_sgb = {
"sgb", "Super Game Boy", 4, BSNES_RESET_LEVEL ,
[](core_romimage* img, std::map<std::string, std::string>& settings, uint64_t secs,
.iname = "sgb", .hname = "Super Game Boy", .id = 4, .reset_support = BSNES_RESET_LEVEL ,
.load_rom = [](core_romimage* img, std::map<std::string, std::string>& settings, uint64_t secs,
uint64_t subsecs) -> int
{
return load_rom<&type_sgb>(img, settings, secs, subsecs,
load_rom_X2<snes_load_cartridge_super_game_boy>);
},
_controllerconfig, "gb;dmg;sgb", "sgb.sfc", sgb_regions, sgb_images, &bsnes_settings, &bsnes_core,
bsnes_get_bus_map, get_VMAlist, srams
.controllerconfig = _controllerconfig, .extensions = "gb;dmg;sgb", .bios = "sgb.sfc",
.regions = sgb_regions, .images = sgb_images, .settings = &bsnes_settings, .core = &bsnes_core,
.get_bus_map = bsnes_get_bus_map, .vma_list = get_VMAlist, .srams = srams
};
core_type type_snes(_type_snes);

100
src/emulation/gambatte/core.cpp
View file

@ -288,19 +288,12 @@ namespace
}
core_core_params _gambatte_core = {
//Get core identifier.
[]() -> std::string { return "libgambatte "+gambatte::GB::version(); },
//Set core region.
[](core_region& region) -> bool { return (&region == &region_world); },
//Get video rate
[]() -> std::pair<uint32_t, uint32_t> { return std::make_pair(262144, 4389); },
//Get audio rate.
[]() -> std::pair<uint32_t, uint32_t> { return std::make_pair(32768, 1); },
//Get SNES CPU/APU rate (N/A).
NULL,
//Store SRAM.
[]() -> std::map<std::string, std::vector<char>>
{
.core_identifier = []() -> std::string { return "libgambatte "+gambatte::GB::version(); },
.set_region = [](core_region& region) -> bool { return (&region == &region_world); },
.video_rate = []() -> std::pair<uint32_t, uint32_t> { return std::make_pair(262144, 4389); },
.audio_rate = []() -> std::pair<uint32_t, uint32_t> { return std::make_pair(32768, 1); },
.snes_rate = NULL,
.save_sram = []() -> std::map<std::string, std::vector<char>> {
std::map<std::string, std::vector<char>> s;
if(!internal_rom)
return s;
@ -313,8 +306,7 @@ namespace
s["rtc"][i] = ((unsigned long long)timebase >> (8 * i));
return s;
},
//Load SRAM.
[](std::map<std::string, std::vector<char>>& sram) -> void {
.load_sram = [](std::map<std::string, std::vector<char>>& sram) -> void {
if(!internal_rom)
return;
std::vector<char> x = sram.count("main") ? sram["main"] : std::vector<char>();
@ -333,8 +325,7 @@ namespace
instance->setRtcBase(timebase);
}
},
//Serialize core state
[](std::vector<char>& out) -> void {
.serialize = [](std::vector<char>& out) -> void {
if(!internal_rom)
throw std::runtime_error("Can't save without ROM");
instance->saveState(out);
@ -345,8 +336,7 @@ namespace
out.push_back(frame_overflow >> 8);
out.push_back(frame_overflow);
},
//Unserialize core state
[](const char* in, size_t insize) -> void {
.unserialize = [](const char* in, size_t insize) -> void {
if(!internal_rom)
throw std::runtime_error("Can't load without ROM");
size_t foffset = insize - 2 - 4 * sizeof(primary_framebuffer) /
@ -363,22 +353,15 @@ namespace
frame_overflow = x1 * 256 + x2;
do_reset_flag = false;
},
//Get region.
[]() -> core_region& { return region_world; },
//Power the core.
[]() -> void {},
//Unload cartridge.
[]() -> void {},
//Get scale factors
[](uint32_t width, uint32_t height) -> std::pair<uint32_t, uint32_t> {
.get_region = []() -> core_region& { return region_world; },
.power = []() -> void {},
.unload_cartridge = []() -> void {},
.get_scale_factors = [](uint32_t width, uint32_t height) -> std::pair<uint32_t, uint32_t> {
return std::make_pair(max(512 / width, (uint32_t)1), max(448 / height, (uint32_t)1));
},
//Install handler
[]() -> void { magic_flags |= 2; },
//Uninstall handler.
[]() -> void {},
//Emulate frame.
[]() -> void {
.install_handler = []() -> void { magic_flags |= 2; },
.uninstall_handler = []() -> void {},
.emulate = []() -> void {
if(!internal_rom)
return;
int16_t reset = ecore_callbacks->get_input(0, 0, 1);
@ -433,26 +416,18 @@ namespace
framebuffer_raw ls(inf);
ecore_callbacks->output_frame(ls, 262144, 4389);
},
//Run to save.
[]() -> void {},
//Get poll flag.
[]() -> bool { return pflag; },
//Set poll flag.
[](bool _pflag) -> void { pflag = _pflag; },
//Request reset.
[](long delay, bool hard) -> void { do_reset_flag = true; },
//Port types.
port_types,
//Cover page.
[]() -> framebuffer_raw& {
.runtosave = []() -> void {},
.get_pflag = []() -> bool { return pflag; },
.set_pflag = [](bool _pflag) -> void { pflag = _pflag; },
.request_reset = [](long delay, bool hard) -> void { do_reset_flag = true; },
.port_types = port_types,
.draw_cover = []() -> framebuffer_raw& {
static framebuffer_raw x(cover_fbinfo);
redraw_cover_fbinfo();
return x;
},
//short identifier.
[]() -> std::string { return "gambatte"+gambatte::GB::version(); },
//Pre-emulate frame.
[](controller_frame& cf) -> void {
.get_core_shortname = []() -> std::string { return "gambatte"+gambatte::GB::version(); },
.pre_emulate_frame = [](controller_frame& cf) -> void {
cf.axis3(0, 0, 1, do_reset_flag ? 1 : 0);
}
};
@ -460,31 +435,34 @@ namespace
core_core gambatte_core(_gambatte_core);
core_type_params _type_dmg = {
"dmg", "Game Boy", 1, 1,
[](core_romimage* img, std::map<std::string, std::string>& settings, uint64_t rtc_sec,
.iname = "dmg", .hname = "Game Boy", .id = 1, .reset_support = 1,
.load_rom = [](core_romimage* img, std::map<std::string, std::string>& settings, uint64_t rtc_sec,
uint64_t rtc_subsec) -> int {
return load_rom_common(img, gambatte::GB::FORCE_DMG, rtc_sec, rtc_subsec, &type_dmg);
},
_controllerconfig, "gb;dmg", NULL, dmg_regions, dmg_images, &gambatte_settings, &gambatte_core,
gambatte_bus_map, get_VMAlist, srams
.controllerconfig = _controllerconfig, .extensions = "gb;dmg", .bios = NULL, .regions = dmg_regions,
.images = dmg_images, .settings = &gambatte_settings, .core = &gambatte_core,
.get_bus_map = gambatte_bus_map, .vma_list = get_VMAlist, .srams = srams
};
core_type_params _type_gbc = {
"gbc", "Game Boy Color", 0, 1,
[](core_romimage* img, std::map<std::string, std::string>& settings, uint64_t rtc_sec,
.iname = "gbc", .hname = "Game Boy Color", .id = 0, .reset_support = 1,
.load_rom = [](core_romimage* img, std::map<std::string, std::string>& settings, uint64_t rtc_sec,
uint64_t rtc_subsec) -> int {
return load_rom_common(img, 0, rtc_sec, rtc_subsec, &type_gbc);
},
_controllerconfig, "gbc;cgb", NULL, gbc_regions, gbc_images, &gambatte_settings, &gambatte_core,
gambatte_bus_map, get_VMAlist, srams
.controllerconfig = _controllerconfig, .extensions = "gbc;cgb", .bios = NULL, .regions = gbc_regions,
.images = gbc_images, .settings = &gambatte_settings, .core = &gambatte_core,
.get_bus_map = gambatte_bus_map, .vma_list = get_VMAlist, .srams = srams
};
core_type_params _type_gbca = {
"gbc_gba", "Game Boy Color (GBA)", 2, 1,
[](core_romimage* img, std::map<std::string, std::string>& settings, uint64_t rtc_sec,
.iname = "gbc_gba", .hname = "Game Boy Color (GBA)", .id = 2, .reset_support = 1,
.load_rom = [](core_romimage* img, std::map<std::string, std::string>& settings, uint64_t rtc_sec,
uint64_t rtc_subsec) -> int {
return load_rom_common(img, gambatte::GB::GBA_CGB, rtc_sec, rtc_subsec, &type_gbca);
},
_controllerconfig, "", NULL, gbca_regions, gbca_images, &gambatte_settings, &gambatte_core,
gambatte_bus_map, get_VMAlist, srams
.controllerconfig = _controllerconfig, .extensions = "", .bios = NULL, .regions = gbca_regions,
.images = gbca_images, .settings = &gambatte_settings, .core = &gambatte_core,
.get_bus_map = gambatte_bus_map, .vma_list = get_VMAlist, .srams = srams
};
core_type type_dmg(_type_dmg);

73
src/emulation/sky/sky.cpp
View file

@ -244,13 +244,14 @@ namespace sky
unsigned world_compat[2] = {0, UINT_MAX};
struct core_region_params world_region_params = {
"world", "World", 0, 0, false, {656250, 18227}, world_compat
.iname = "world", .hname = "World", .priority = 0, .handle = 0, .multi = false,
.framemagic = {656250, 18227}, .compatible_runs = world_compat
};
struct core_region world_region(world_region_params);
struct core_region* regions[] = {&world_region, NULL};
struct core_romimage_info_params skyzip_params = {
"rom", "skyroads.zip", 1, 1, 0
"rom", "skyroads.zip", .mandatory = 1, .pass_mode = 1, .headersize = 0
};
struct core_romimage_info skyzip(skyzip_params);
struct core_romimage_info* images[] = {&skyzip, NULL};
@ -258,12 +259,12 @@ namespace sky
extern struct core_core sky_core;
struct core_core_params sky_core_params = {
[]() -> std::string { return "Sky"; },
[](core_region& region) -> bool { return (&region == &world_region); },
[]() -> std::pair<uint32_t, uint32_t> { return std::make_pair(656250, 18227); },
[]() -> std::pair<uint32_t, uint32_t> { return std::make_pair(48000, 1); },
[]() -> std::pair<uint32_t, uint32_t> { return std::make_pair(0, 0); },
[]() -> std::map<std::string, std::vector<char>> {
.core_identifier = []() -> std::string { return "Sky"; },
.set_region = [](core_region& region) -> bool { return (&region == &world_region); },
.video_rate = []() -> std::pair<uint32_t, uint32_t> { return std::make_pair(656250, 18227); },
.audio_rate = []() -> std::pair<uint32_t, uint32_t> { return std::make_pair(48000, 1); },
.snes_rate = []() -> std::pair<uint32_t, uint32_t> { return std::make_pair(0, 0); },
.save_sram = []() -> std::map<std::string, std::vector<char>> {
std::map<std::string, std::vector<char>> r;
std::vector<char> sram;
sram.resize(32);
@ -271,33 +272,33 @@ namespace sky
r["sram"] = sram;
return r;
},
[](std::map<std::string, std::vector<char>>& sram) -> void {
.load_sram = [](std::map<std::string, std::vector<char>>& sram) -> void {
if(sram.count("sram") && sram["sram"].size() == 32)
memcpy(_gstate.sram, &sram["sram"][0], 32);
else
memset(_gstate.sram, 0, 32);
},
[](std::vector<char>& out) -> void {
.serialize = [](std::vector<char>& out) -> void {
auto wram = _gstate.as_ram();
out.resize(wram.second);
memcpy(&out[0], wram.first, wram.second);
},
[](const char* in, size_t insize) -> void {
.unserialize =[](const char* in, size_t insize) -> void {
auto wram = _gstate.as_ram();
if(insize != wram.second)
throw std::runtime_error("Save is of wrong size");
memcpy(wram.first, in, wram.second);
handle_loadstate(_gstate);
},
[]() -> core_region& { return world_region; },
[]() -> void {},
[]() -> void {},
[](uint32_t w, uint32_t h) -> std::pair<uint32_t, uint32_t> {
.get_region = []() -> core_region& { return world_region; },
.power = []() -> void {},
.unload_cartridge = []() -> void {},
.get_scale_factors = [](uint32_t w, uint32_t h) -> std::pair<uint32_t, uint32_t> {
return std::make_pair(FB_WIDTH / w, FB_HEIGHT / h);
},
[]() -> void { sky_core.hide(); },
[]() -> void {},
[]() -> void {
.install_handler = []() -> void { sky_core.hide(); },
.uninstall_handler = []() -> void {},
.emulate = []() -> void {
static unsigned count[4];
static unsigned tcount[4] = {5, 7, 8, 25};
uint16_t x = 0;
@ -339,17 +340,17 @@ namespace sky
for(unsigned i = 0; i < samples; i++)
information_dispatch::do_sample(sbuf[2 * i + 0], sbuf[2 * i + 1]);
},
[]() -> void {},
[]() -> bool { return pflag; },
[](bool _pflag) -> void { pflag = _pflag; },
[](long delay, bool hard) -> void {},
port_types,
[]() -> framebuffer_raw& {
.runtosave = []() -> void {},
.get_pflag = []() -> bool { return pflag; },
.set_pflag = [](bool _pflag) -> void { pflag = _pflag; },
.request_reset = [](long delay, bool hard) -> void {},
.port_types = port_types,
.draw_cover = []() -> framebuffer_raw& {
static framebuffer_raw x(cover_fbinfo);
return x;
},
[]() -> std::string { return "sky"; },
[](controller_frame& cf) -> void {}
.get_core_shortname = []() -> std::string { return "sky"; },
.pre_emulate_frame = [](controller_frame& cf) -> void {}
};
struct core_core sky_core(sky_core_params);
@ -370,8 +371,8 @@ namespace sky
}
struct core_type_params skytype_params = {
"sky", "Sky", 3522, 0,
[](core_romimage* images, std::map<std::string, std::string>& settings, uint64_t rtc_sec,
.iname = "sky", .hname = "Sky", .id = 3522, .reset_support = 0,
.load_rom = [](core_romimage* images, std::map<std::string, std::string>& settings, uint64_t rtc_sec,
uint64_t rtc_subsec) -> int {
controller_magic();
const unsigned char* _filename = images[0].data;
@ -386,7 +387,7 @@ namespace sky
rom_boot_vector(_gstate);
return 0;
},
[](std::map<std::string, std::string>& settings) -> controller_set
.controllerconfig = [](std::map<std::string, std::string>& settings) -> controller_set
{
controller_magic();
controller_set r;
@ -398,14 +399,10 @@ namespace sky
r.portindex.pcid_map.push_back(std::make_pair(0, 1));
return r;
},
"sky",
NULL,
regions,
images,
&sky_settings,
&sky_core,
[]() -> std::pair<uint64_t, uint64_t> { return std::make_pair(0, 0); },
[]() -> std::list<core_vma_info> {
.extensions = "sky", .bios = NULL, .regions = regions, .images = images, .settings = &sky_settings,
.core = &sky_core,
.get_bus_map = []() -> std::pair<uint64_t, uint64_t> { return std::make_pair(0, 0); },
.vma_list = []() -> std::list<core_vma_info> {
std::list<core_vma_info> r;
core_vma_info ram;
@ -420,7 +417,7 @@ namespace sky
return r;
},
[]() -> std::set<std::string> {
.srams = []() -> std::set<std::string> {
std::set<std::string> r;
r.insert("sram");
return r;