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

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

@ -288,19 +288,12 @@ namespace
} }
core_core_params _gambatte_core = { core_core_params _gambatte_core = {
//Get core identifier. .core_identifier = []() -> std::string { return "libgambatte "+gambatte::GB::version(); },
[]() -> std::string { return "libgambatte "+gambatte::GB::version(); }, .set_region = [](core_region& region) -> bool { return (&region == &region_world); },
//Set core region. .video_rate = []() -> std::pair<uint32_t, uint32_t> { return std::make_pair(262144, 4389); },
[](core_region& region) -> bool { return (&region == &region_world); }, .audio_rate = []() -> std::pair<uint32_t, uint32_t> { return std::make_pair(32768, 1); },
//Get video rate .snes_rate = NULL,
[]() -> std::pair<uint32_t, uint32_t> { return std::make_pair(262144, 4389); }, .save_sram = []() -> std::map<std::string, std::vector<char>> {
//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>>
{
std::map<std::string, std::vector<char>> s; std::map<std::string, std::vector<char>> s;
if(!internal_rom) if(!internal_rom)
return s; return s;
@ -313,8 +306,7 @@ namespace
s["rtc"][i] = ((unsigned long long)timebase >> (8 * i)); s["rtc"][i] = ((unsigned long long)timebase >> (8 * i));
return s; return s;
}, },
//Load SRAM. .load_sram = [](std::map<std::string, std::vector<char>>& sram) -> void {
[](std::map<std::string, std::vector<char>>& sram) -> void {
if(!internal_rom) if(!internal_rom)
return; return;
std::vector<char> x = sram.count("main") ? sram["main"] : std::vector<char>(); std::vector<char> x = sram.count("main") ? sram["main"] : std::vector<char>();
@ -333,8 +325,7 @@ namespace
instance->setRtcBase(timebase); instance->setRtcBase(timebase);
} }
}, },
//Serialize core state .serialize = [](std::vector<char>& out) -> void {
[](std::vector<char>& out) -> void {
if(!internal_rom) if(!internal_rom)
throw std::runtime_error("Can't save without ROM"); throw std::runtime_error("Can't save without ROM");
instance->saveState(out); instance->saveState(out);
@ -345,8 +336,7 @@ namespace
out.push_back(frame_overflow >> 8); out.push_back(frame_overflow >> 8);
out.push_back(frame_overflow); out.push_back(frame_overflow);
}, },
//Unserialize core state .unserialize = [](const char* in, size_t insize) -> void {
[](const char* in, size_t insize) -> void {
if(!internal_rom) if(!internal_rom)
throw std::runtime_error("Can't load without ROM"); throw std::runtime_error("Can't load without ROM");
size_t foffset = insize - 2 - 4 * sizeof(primary_framebuffer) / size_t foffset = insize - 2 - 4 * sizeof(primary_framebuffer) /
@ -363,22 +353,15 @@ namespace
frame_overflow = x1 * 256 + x2; frame_overflow = x1 * 256 + x2;
do_reset_flag = false; do_reset_flag = false;
}, },
//Get region. .get_region = []() -> core_region& { return region_world; },
[]() -> core_region& { return region_world; }, .power = []() -> void {},
//Power the core. .unload_cartridge = []() -> void {},
[]() -> void {}, .get_scale_factors = [](uint32_t width, uint32_t height) -> std::pair<uint32_t, uint32_t> {
//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)); return std::make_pair(max(512 / width, (uint32_t)1), max(448 / height, (uint32_t)1));
}, },
//Install handler .install_handler = []() -> void { magic_flags |= 2; },
[]() -> void { magic_flags |= 2; }, .uninstall_handler = []() -> void {},
//Uninstall handler. .emulate = []() -> void {
[]() -> void {},
//Emulate frame.
[]() -> void {
if(!internal_rom) if(!internal_rom)
return; return;
int16_t reset = ecore_callbacks->get_input(0, 0, 1); int16_t reset = ecore_callbacks->get_input(0, 0, 1);
@ -433,26 +416,18 @@ namespace
framebuffer_raw ls(inf); framebuffer_raw ls(inf);
ecore_callbacks->output_frame(ls, 262144, 4389); ecore_callbacks->output_frame(ls, 262144, 4389);
}, },
//Run to save. .runtosave = []() -> void {},
[]() -> void {}, .get_pflag = []() -> bool { return pflag; },
//Get poll flag. .set_pflag = [](bool _pflag) -> void { pflag = _pflag; },
[]() -> bool { return pflag; }, .request_reset = [](long delay, bool hard) -> void { do_reset_flag = true; },
//Set poll flag. .port_types = port_types,
[](bool _pflag) -> void { pflag = _pflag; }, .draw_cover = []() -> framebuffer_raw& {
//Request reset.
[](long delay, bool hard) -> void { do_reset_flag = true; },
//Port types.
port_types,
//Cover page.
[]() -> framebuffer_raw& {
static framebuffer_raw x(cover_fbinfo); static framebuffer_raw x(cover_fbinfo);
redraw_cover_fbinfo(); redraw_cover_fbinfo();
return x; return x;
}, },
//short identifier. .get_core_shortname = []() -> std::string { return "gambatte"+gambatte::GB::version(); },
[]() -> std::string { return "gambatte"+gambatte::GB::version(); }, .pre_emulate_frame = [](controller_frame& cf) -> void {
//Pre-emulate frame.
[](controller_frame& cf) -> void {
cf.axis3(0, 0, 1, do_reset_flag ? 1 : 0); cf.axis3(0, 0, 1, do_reset_flag ? 1 : 0);
} }
}; };
@ -460,31 +435,34 @@ namespace
core_core gambatte_core(_gambatte_core); core_core gambatte_core(_gambatte_core);
core_type_params _type_dmg = { core_type_params _type_dmg = {
"dmg", "Game Boy", 1, 1, .iname = "dmg", .hname = "Game Boy", .id = 1, .reset_support = 1,
[](core_romimage* img, std::map<std::string, std::string>& settings, uint64_t rtc_sec, .load_rom = [](core_romimage* img, std::map<std::string, std::string>& settings, uint64_t rtc_sec,
uint64_t rtc_subsec) -> int { uint64_t rtc_subsec) -> int {
return load_rom_common(img, gambatte::GB::FORCE_DMG, rtc_sec, rtc_subsec, &type_dmg); 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, .controllerconfig = _controllerconfig, .extensions = "gb;dmg", .bios = NULL, .regions = dmg_regions,
gambatte_bus_map, get_VMAlist, srams .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 = { core_type_params _type_gbc = {
"gbc", "Game Boy Color", 0, 1, .iname = "gbc", .hname = "Game Boy Color", .id = 0, .reset_support = 1,
[](core_romimage* img, std::map<std::string, std::string>& settings, uint64_t rtc_sec, .load_rom = [](core_romimage* img, std::map<std::string, std::string>& settings, uint64_t rtc_sec,
uint64_t rtc_subsec) -> int { uint64_t rtc_subsec) -> int {
return load_rom_common(img, 0, rtc_sec, rtc_subsec, &type_gbc); return load_rom_common(img, 0, rtc_sec, rtc_subsec, &type_gbc);
}, },
_controllerconfig, "gbc;cgb", NULL, gbc_regions, gbc_images, &gambatte_settings, &gambatte_core, .controllerconfig = _controllerconfig, .extensions = "gbc;cgb", .bios = NULL, .regions = gbc_regions,
gambatte_bus_map, get_VMAlist, srams .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 = { core_type_params _type_gbca = {
"gbc_gba", "Game Boy Color (GBA)", 2, 1, .iname = "gbc_gba", .hname = "Game Boy Color (GBA)", .id = 2, .reset_support = 1,
[](core_romimage* img, std::map<std::string, std::string>& settings, uint64_t rtc_sec, .load_rom = [](core_romimage* img, std::map<std::string, std::string>& settings, uint64_t rtc_sec,
uint64_t rtc_subsec) -> int { uint64_t rtc_subsec) -> int {
return load_rom_common(img, gambatte::GB::GBA_CGB, rtc_sec, rtc_subsec, &type_gbca); 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, .controllerconfig = _controllerconfig, .extensions = "", .bios = NULL, .regions = gbca_regions,
gambatte_bus_map, get_VMAlist, srams .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); 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}; unsigned world_compat[2] = {0, UINT_MAX};
struct core_region_params world_region_params = { 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 world_region(world_region_params);
struct core_region* regions[] = {&world_region, NULL}; struct core_region* regions[] = {&world_region, NULL};
struct core_romimage_info_params skyzip_params = { 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 skyzip(skyzip_params);
struct core_romimage_info* images[] = {&skyzip, NULL}; struct core_romimage_info* images[] = {&skyzip, NULL};
@ -258,12 +259,12 @@ namespace sky
extern struct core_core sky_core; extern struct core_core sky_core;
struct core_core_params sky_core_params = { struct core_core_params sky_core_params = {
[]() -> std::string { return "Sky"; }, .core_identifier = []() -> std::string { return "Sky"; },
[](core_region& region) -> bool { return (&region == &world_region); }, .set_region = [](core_region& region) -> bool { return (&region == &world_region); },
[]() -> std::pair<uint32_t, uint32_t> { return std::make_pair(656250, 18227); }, .video_rate = []() -> std::pair<uint32_t, uint32_t> { return std::make_pair(656250, 18227); },
[]() -> std::pair<uint32_t, uint32_t> { return std::make_pair(48000, 1); }, .audio_rate = []() -> std::pair<uint32_t, uint32_t> { return std::make_pair(48000, 1); },
[]() -> std::pair<uint32_t, uint32_t> { return std::make_pair(0, 0); }, .snes_rate = []() -> std::pair<uint32_t, uint32_t> { return std::make_pair(0, 0); },
[]() -> std::map<std::string, std::vector<char>> { .save_sram = []() -> std::map<std::string, std::vector<char>> {
std::map<std::string, std::vector<char>> r; std::map<std::string, std::vector<char>> r;
std::vector<char> sram; std::vector<char> sram;
sram.resize(32); sram.resize(32);
@ -271,33 +272,33 @@ namespace sky
r["sram"] = sram; r["sram"] = sram;
return r; 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) if(sram.count("sram") && sram["sram"].size() == 32)
memcpy(_gstate.sram, &sram["sram"][0], 32); memcpy(_gstate.sram, &sram["sram"][0], 32);
else else
memset(_gstate.sram, 0, 32); memset(_gstate.sram, 0, 32);
}, },
[](std::vector<char>& out) -> void { .serialize = [](std::vector<char>& out) -> void {
auto wram = _gstate.as_ram(); auto wram = _gstate.as_ram();
out.resize(wram.second); out.resize(wram.second);
memcpy(&out[0], wram.first, 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(); auto wram = _gstate.as_ram();
if(insize != wram.second) if(insize != wram.second)
throw std::runtime_error("Save is of wrong size"); throw std::runtime_error("Save is of wrong size");
memcpy(wram.first, in, wram.second); memcpy(wram.first, in, wram.second);
handle_loadstate(_gstate); handle_loadstate(_gstate);
}, },
[]() -> core_region& { return world_region; }, .get_region = []() -> core_region& { return world_region; },
[]() -> void {}, .power = []() -> void {},
[]() -> void {}, .unload_cartridge = []() -> void {},
[](uint32_t w, uint32_t h) -> std::pair<uint32_t, uint32_t> { .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); return std::make_pair(FB_WIDTH / w, FB_HEIGHT / h);
}, },
[]() -> void { sky_core.hide(); }, .install_handler = []() -> void { sky_core.hide(); },
[]() -> void {}, .uninstall_handler = []() -> void {},
[]() -> void { .emulate = []() -> void {
static unsigned count[4]; static unsigned count[4];
static unsigned tcount[4] = {5, 7, 8, 25}; static unsigned tcount[4] = {5, 7, 8, 25};
uint16_t x = 0; uint16_t x = 0;
@ -339,17 +340,17 @@ namespace sky
for(unsigned i = 0; i < samples; i++) for(unsigned i = 0; i < samples; i++)
information_dispatch::do_sample(sbuf[2 * i + 0], sbuf[2 * i + 1]); information_dispatch::do_sample(sbuf[2 * i + 0], sbuf[2 * i + 1]);
}, },
[]() -> void {}, .runtosave = []() -> void {},
[]() -> bool { return pflag; }, .get_pflag = []() -> bool { return pflag; },
[](bool _pflag) -> void { pflag = _pflag; }, .set_pflag = [](bool _pflag) -> void { pflag = _pflag; },
[](long delay, bool hard) -> void {}, .request_reset = [](long delay, bool hard) -> void {},
port_types, .port_types = port_types,
[]() -> framebuffer_raw& { .draw_cover = []() -> framebuffer_raw& {
static framebuffer_raw x(cover_fbinfo); static framebuffer_raw x(cover_fbinfo);
return x; return x;
}, },
[]() -> std::string { return "sky"; }, .get_core_shortname = []() -> std::string { return "sky"; },
[](controller_frame& cf) -> void {} .pre_emulate_frame = [](controller_frame& cf) -> void {}
}; };
struct core_core sky_core(sky_core_params); struct core_core sky_core(sky_core_params);
@ -370,8 +371,8 @@ namespace sky
} }
struct core_type_params skytype_params = { struct core_type_params skytype_params = {
"sky", "Sky", 3522, 0, .iname = "sky", .hname = "Sky", .id = 3522, .reset_support = 0,
[](core_romimage* images, std::map<std::string, std::string>& settings, uint64_t rtc_sec, .load_rom = [](core_romimage* images, std::map<std::string, std::string>& settings, uint64_t rtc_sec,
uint64_t rtc_subsec) -> int { uint64_t rtc_subsec) -> int {
controller_magic(); controller_magic();
const unsigned char* _filename = images[0].data; const unsigned char* _filename = images[0].data;
@ -386,7 +387,7 @@ namespace sky
rom_boot_vector(_gstate); rom_boot_vector(_gstate);
return 0; return 0;
}, },
[](std::map<std::string, std::string>& settings) -> controller_set .controllerconfig = [](std::map<std::string, std::string>& settings) -> controller_set
{ {
controller_magic(); controller_magic();
controller_set r; controller_set r;
@ -398,14 +399,10 @@ namespace sky
r.portindex.pcid_map.push_back(std::make_pair(0, 1)); r.portindex.pcid_map.push_back(std::make_pair(0, 1));
return r; return r;
}, },
"sky", .extensions = "sky", .bios = NULL, .regions = regions, .images = images, .settings = &sky_settings,
NULL, .core = &sky_core,
regions, .get_bus_map = []() -> std::pair<uint64_t, uint64_t> { return std::make_pair(0, 0); },
images, .vma_list = []() -> std::list<core_vma_info> {
&sky_settings,
&sky_core,
[]() -> std::pair<uint64_t, uint64_t> { return std::make_pair(0, 0); },
[]() -> std::list<core_vma_info> {
std::list<core_vma_info> r; std::list<core_vma_info> r;
core_vma_info ram; core_vma_info ram;
@ -420,7 +417,7 @@ namespace sky
return r; return r;
}, },
[]() -> std::set<std::string> { .srams = []() -> std::set<std::string> {
std::set<std::string> r; std::set<std::string> r;
r.insert("sram"); r.insert("sram");
return r; return r;