libretro/MesenCE
1
0 Fork 0
mirror of https://github.com/libretro/MesenCE.git synced 2026-11-09 11:31:46 -10:00
Code Issues Packages Projects Releases Wiki Activity
Files
dev
MesenCE/Libretro/libretro.cpp
T

2575 lines
101 KiB
C++
Raw Permalink Blame History

#include <string>
#include <cstdlib>
#include <cstdio>
#include <cstdarg>
#include <sstream>
#include <algorithm>
#include <fstream>
#include <vector>
#include <iterator>
#include <sys/stat.h>
#if __has_include(<filesystem>)
#include <filesystem>
namespace fs = std::filesystem;
#define HAS_STD_FILESYSTEM 1
#elif __has_include(<experimental/filesystem>)
#include <experimental/filesystem>
namespace fs = std::experimental::filesystem;
#define HAS_STD_FILESYSTEM 1
#endif
#include "LibretroKeyManager.h"
#include "LibretroMessageManager.h"
#include "libretro.h"
#include "../Core/Shared/Audio/SoundMixer.h"
#include "../Core/Shared/BaseControlManager.h"
#include "../Core/NES/NesConsole.h"
#include "../Core/SNES/SnesConsole.h"
#include "../Core/Gameboy/Gameboy.h"
#include "../Core/GBA/GbaConsole.h"
#include "../Core/PCE/PceConsole.h"
#include "../Core/SMS/SmsConsole.h"
#include "../Core/WS/WsConsole.h"
#include "../Core/Shared/Video/VideoDecoder.h"
#include "../Core/Shared/Video/BaseVideoFilter.h"
#include "../Core/Shared/Video/VideoRenderer.h"
#include "../Core/Shared/ColorUtilities.h"
#include "../Core/NES/NesMemoryManager.h"
#include "../Core/NES/BaseMapper.h"
#include "../Core/Shared/EmuSettings.h"
#include "../Core/Shared/CheatManager.h"
#include "../Core/NES/HdPacks/HdData.h"
#include "../Core/Shared/SaveStateManager.h"
#include "../Core/Debugger/DebugTypes.h"
#include "../Core/NES/GameDatabase.h"
#include "../Core/NES/NesSoundMixer.h"
#include "../Core/Shared/Interfaces/IAudioDevice.h"
#include "../Utilities/FolderUtilities.h"
#include "../Utilities/HexUtilities.h"
#include "../Utilities/VirtualFile.h"
#include "VfsFile.h"
#include "../Utilities/UTF8Util.h"
#define DEVICE_AUTO RETRO_DEVICE_JOYPAD
#define DEVICE_GAMEPAD RETRO_DEVICE_SUBCLASS(RETRO_DEVICE_JOYPAD, 0)
#define DEVICE_POWERPAD RETRO_DEVICE_SUBCLASS(RETRO_DEVICE_JOYPAD, 1)
#define DEVICE_FAMILYTRAINER RETRO_DEVICE_SUBCLASS(RETRO_DEVICE_JOYPAD, 2)
#define DEVICE_PARTYTAP RETRO_DEVICE_SUBCLASS(RETRO_DEVICE_JOYPAD, 3)
#define DEVICE_PACHINKO RETRO_DEVICE_SUBCLASS(RETRO_DEVICE_JOYPAD, 4)
#define DEVICE_EXCITINGBOXING RETRO_DEVICE_SUBCLASS(RETRO_DEVICE_JOYPAD, 5)
#define DEVICE_KONAMIHYPERSHOT RETRO_DEVICE_SUBCLASS(RETRO_DEVICE_JOYPAD, 6)
#define DEVICE_SNESGAMEPAD RETRO_DEVICE_SUBCLASS(RETRO_DEVICE_JOYPAD, 7)
#define DEVICE_GAMEBOYGAMEPAD RETRO_DEVICE_SUBCLASS(RETRO_DEVICE_JOYPAD, 8)
#define DEVICE_VBGAMEPAD RETRO_DEVICE_SUBCLASS(RETRO_DEVICE_JOYPAD, 9)
#define DEVICE_ZAPPER RETRO_DEVICE_SUBCLASS(RETRO_DEVICE_POINTER, 0)
#define DEVICE_OEKAKIDS RETRO_DEVICE_SUBCLASS(RETRO_DEVICE_POINTER, 1)
#define DEVICE_BANDAIHYPERSHOT RETRO_DEVICE_SUBCLASS(RETRO_DEVICE_POINTER, 2)
#define DEVICE_ARKANOID RETRO_DEVICE_SUBCLASS(RETRO_DEVICE_MOUSE, 0)
#define DEVICE_HORITRACK RETRO_DEVICE_SUBCLASS(RETRO_DEVICE_MOUSE, 1)
#define DEVICE_SNESMOUSE RETRO_DEVICE_SUBCLASS(RETRO_DEVICE_MOUSE, 2)
#define DEVICE_ASCIITURBOFILE RETRO_DEVICE_SUBCLASS(RETRO_DEVICE_NONE, 0)
#define DEVICE_BATTLEBOX RETRO_DEVICE_SUBCLASS(RETRO_DEVICE_NONE, 1)
#define DEVICE_FOURPLAYERADAPTER RETRO_DEVICE_SUBCLASS(RETRO_DEVICE_NONE, 2)
static retro_log_printf_t logCallback = nullptr;
retro_environment_t env_cb = nullptr;
static unsigned _inputDevices[5] = { DEVICE_AUTO, DEVICE_AUTO, DEVICE_AUTO, DEVICE_AUTO, DEVICE_AUTO };
static bool _hdPacksEnabled = false;
static string _mesenVersion = "";
static int32_t _saveStateSize = -1;
static bool _shiftButtonsClockwise = false;
static int32_t _audioSampleRate = 44100;
//Include game database as a byte array (representing the MesenDB.txt file)
#include "MesenDB.inc"
static std::unique_ptr<Emulator> _emu;
// shared_ptr to the console (IConsole interface, may be null until emulator initialized)
// Supports all console types: NES, SNES, Gameboy, GBA, PC Engine, SMS, Wonderswan
static std::shared_ptr<IConsole> _console;
static bool FolderExists(const string& folder)
{
if(VfsIo::SupportsFolderOps()) {
//The path may not exist on the real filesystem (e.g. Android SAF)
return VfsIo::IsFolder(folder);
}
#ifdef HAS_STD_FILESYSTEM
return fs::exists(folder) && fs::is_directory(folder);
#else
struct stat st;
return stat(folder.c_str(), &st) == 0 && S_ISDIR(st.st_mode);
#endif
}
static bool CreatePceFirmwareStub(const string& systemFolder, string& createdPath, string& backupPath)
{
if(systemFolder.empty()) {
return false;
}
static const vector<string> firmwareSources = { "syscard3.pce", "syscard3.bin", "syscard.pce", "syscard.bin" };
const string targetName = "[BIOS] Super CD-ROM System (Japan) (v3.0).pce";
string target = FolderUtilities::CombinePath(systemFolder, targetName);
createdPath.clear();
backupPath.clear();
VirtualFile targetFile(target);
if(targetFile.IsValid() && targetFile.GetSize() == 0x40000) {
return false;
}
for(const string& sourceName : firmwareSources) {
string sourcePath = FolderUtilities::CombinePath(systemFolder, sourceName);
VirtualFile sourceFile(sourcePath);
if(!sourceFile.IsValid()) {
continue;
}
uint64_t sourceSize = sourceFile.GetSize();
if(sourceSize < 0x40000) {
continue;
}
vector<uint8_t> sourceData;
if(!sourceFile.ReadFile(sourceData) || sourceData.size() < 0x40000) {
continue;
}
size_t sourceOffset = 0;
if(sourceSize == 0x60200 || sourceSize == 0x40200) {
sourceOffset = 0x200;
}
if(targetFile.IsValid()) {
backupPath = target + ".libretro.bak";
int backupIndex = 1;
while(utf8::ifstream(backupPath, std::ios::binary).good()) {
backupPath = target + ".libretro.bak" + std::to_string(backupIndex);
backupIndex++;
}
if(!VfsIo::Rename(target, backupPath)) {
backupPath.clear();
break;
}
}
utf8::ofstream out(target, std::ios::binary | std::ios::trunc);
if(!out) {
if(!backupPath.empty()) {
VfsIo::Rename(backupPath, target);
}
continue;
}
out.write((const char*)sourceData.data() + sourceOffset, 0x40000);
out.close();
VirtualFile verified(target);
if(verified.IsValid() && verified.GetSize() == 0x40000) {
createdPath = target;
return true;
}
if(!backupPath.empty()) {
VfsIo::Rename(backupPath, target);
}
}
return false;
}
static void RestorePceFirmwareStub(const string& createdPath, const string& backupPath)
{
if(createdPath.empty()) {
return;
}
if(!backupPath.empty()) {
VfsIo::Rename(backupPath, createdPath);
} else {
VfsIo::Remove(createdPath);
}
}
static std::shared_ptr<LibretroKeyManager> _keyManager;
static std::unique_ptr<LibretroMessageManager> _message_manager;
static retro_audio_sample_batch_t _audioSampleBatch = nullptr;
static retro_video_refresh_t _videoRefresh = nullptr;
// Saved input callbacks (set by frontend before core may be ready)
static retro_input_state_t _savedGetInputState = nullptr;
static retro_input_poll_t _savedPollInput = nullptr;
// Store user palette locally until renderer API is wired
static std::vector<uint32_t> _userRgbPalette;
// keep selected filter string until we map to EmuSettings
static std::string _selectedNtscFilter;
// local stubs for settings not yet mapped
static bool _videoFilterRaw = false;
static int _ppuNmiBefore = 0;
static int _ppuNmiAfter = 0;
static uint8_t _overscanLeft = 0, _overscanRight = 0, _overscanTop = 0, _overscanBottom = 0;
// store other high-level choices locally until mapped to EmuSettings
static std::string _selectedAspectRatio;
static std::string _selectedRegion;
static std::string _selectedRamState;
// new local stub for screen rotation
static int _screenRotation = 0;
extern "C" void logMessage(retro_log_level level, const char* message);
static bool isSgbDebugEnabled()
{
static bool initialized = false;
static bool enabled = false;
if(!initialized) {
enabled = getenv("MESEN_LIBRETRO_DEBUG_SGB") != nullptr;
initialized = true;
}
return enabled;
}
static void logSgbDebugf(const char* fmt, ...)
{
char buffer[1024];
va_list args;
va_start(args, fmt);
vsnprintf(buffer, sizeof(buffer), fmt, args);
va_end(args);
fprintf(stderr, "[libretro] %s\n", buffer);
fflush(stderr);
if(logCallback) {
logCallback(RETRO_LOG_INFO, buffer);
}
}
// Geometry tracking
static bool _geometryDirty = false;
static VideoConfig _lastVideoConfig = {};
static NesConfig _lastNesConfig = {};
static uint32_t _lastReportedWidth = 256;
static uint32_t _lastReportedHeight = 240;
// Small audio device implementation that forwards audio from the core's
// SoundMixer to libretro's audio callback (_audioSampleBatch).
class LibretroAudioDevice : public IAudioDevice {
public:
LibretroAudioDevice() {
}
~LibretroAudioDevice() override {
}
void PlayBuffer(int16_t *soundBuffer, uint32_t bufferSize, uint32_t sampleRate, bool isStereo) override {
// bufferSize is number of frames. _audioSampleBatch expects interleaved int16_t samples and frame count.
if(!_audioSampleBatch) {
return;
}
// Choose output buffer pointer (interleaved samples)
const int16_t* outPtr = nullptr;
if(isStereo) {
outPtr = soundBuffer;
} else {
// Convert mono -> stereo by duplicating samples into a temporary buffer
_monoBuffer.resize(bufferSize * 2);
for(uint32_t i = 0; i < bufferSize; ++i) {
int16_t s = soundBuffer[i];
_monoBuffer[i * 2 + 0] = s;
_monoBuffer[i * 2 + 1] = s;
}
outPtr = _monoBuffer.data();
}
// Forward frames (bufferSize is frame count)
_audioSampleBatch((const int16_t*)outPtr, (size_t)bufferSize);
}
void Stop() override {}
void Pause() override {}
void ProcessEndOfFrame() override {}
string GetAvailableDevices() override { return string(); }
void SetAudioDevice(string deviceName) override { (void)deviceName; }
AudioStatistics GetStatistics() override { return AudioStatistics(); }
private:
// reused buffer for mono->stereo conversion
std::vector<int16_t> _monoBuffer;
};
static std::unique_ptr<LibretroAudioDevice> _audioDevice;
static constexpr const char* MesenNtscFilter = "mesen_ntsc_filter";
static constexpr const char* MesenPalette = "mesen_palette";
static constexpr const char* MesenSpriteLimit = "mesen_sprite_limit";
static constexpr const char* MesenEnablePalBorders = "mesen_enable_pal_borders";
static constexpr const char* MesenSpritesEnabled = "mesen_sprites_enabled";
static constexpr const char* MesenBackgroundEnabled = "mesen_background_enabled";
static constexpr const char* MesenAllowInvalidInput = "mesen_allow_invalid_input";
static constexpr const char* MesenDisableGameGenieBusConflicts = "mesen_disable_game_genie_bus_conflicts";
static constexpr const char* MesenRandomizeMapperPowerOnState = "mesen_randomize_mapper_power_on_state";
static constexpr const char* MesenRandomizeCpuPpuAlignment = "mesen_randomize_cpu_ppu_alignment";
static constexpr const char* MesenOverclock = "mesen_overclock";
static constexpr const char* MesenOverclockType = "mesen_overclock_type";
//static constexpr const char* MesenOverscanLeft = "mesen_overscan_left";
//static constexpr const char* MesenOverscanRight = "mesen_overscan_right";
//static constexpr const char* MesenOverscanTop = "mesen_overscan_up";
//static constexpr const char* MesenOverscanBottom = "mesen_overscan_down";
//static constexpr const char* MesenAspectRatio = "mesen_aspect_ratio";
static constexpr const char* MesenRegion = "mesen_region";
static constexpr const char* MesenRamState = "mesen_ramstate";
static constexpr const char* MesenControllerTurboSpeed = "mesen_controllerturbospeed";
static constexpr const char* MesenFdsAutoSelectDisk = "mesen_fdsautoinsertdisk";
static constexpr const char* MesenFdsFastForwardLoad = "mesen_fdsfastforwardload";
// static constexpr const char* MesenHdPacks = "mesen_hdpacks";
// static constexpr const char* MesenScreenRotation = "mesen_screenrotation";
static constexpr const char* MesenFakeStereo = "mesen_fake_stereo";
static constexpr const char* MesenMuteTriangleUltrasonic = "mesen_mute_triangle_ultrasonic";
static constexpr const char* MesenReduceDmcPopping = "mesen_reduce_dmc_popping";
static constexpr const char* MesenSwapDutyCycle = "mesen_swap_duty_cycle";
static constexpr const char* MesenDisableNoiseModeFlag = "mesen_disable_noise_mode_flag";
// static constexpr const char* MesenShiftButtonsClockwise = "mesen_shift_buttons_clockwise";
static constexpr const char* MesenAudioSampleRate = "mesen_audio_sample_rate";
uint32_t defaultPalette[0x40] { 0xFF666666, 0xFF002A88, 0xFF1412A7, 0xFF3B00A4, 0xFF5C007E, 0xFF6E0040, 0xFF6C0600, 0xFF561D00, 0xFF333500, 0xFF0B4800, 0xFF005200, 0xFF004F08, 0xFF00404D, 0xFF000000, 0xFF000000, 0xFF000000, 0xFFADADAD, 0xFF155FD9, 0xFF4240FF, 0xFF7527FE, 0xFFA01ACC, 0xFFB71E7B, 0xFFB53120, 0xFF994E00, 0xFF6B6D00, 0xFF388700, 0xFF0C9300, 0xFF008F32, 0xFF007C8D, 0xFF000000, 0xFF000000, 0xFF000000, 0xFFFFFEFF, 0xFF64B0FF, 0xFF9290FF, 0xFFC676FF, 0xFFF36AFF, 0xFFFE6ECC, 0xFFFE8170, 0xFFEA9E22, 0xFFBCBE00, 0xFF88D800, 0xFF5CE430, 0xFF45E082, 0xFF48CDDE, 0xFF4F4F4F, 0xFF000000, 0xFF000000, 0xFFFFFEFF, 0xFFC0DFFF, 0xFFD3D2FF, 0xFFE8C8FF, 0xFFFBC2FF, 0xFFFEC4EA, 0xFFFECCC5, 0xFFF7D8A5, 0xFFE4E594, 0xFFCFEF96, 0xFFBDF4AB, 0xFFB3F3CC, 0xFFB5EBF2, 0xFFB8B8B8, 0xFF000000, 0xFF000000 };
uint32_t unsaturatedPalette[0x40] { 0xFF6B6B6B, 0xFF001E87, 0xFF1F0B96, 0xFF3B0C87, 0xFF590D61, 0xFF5E0528, 0xFF551100, 0xFF461B00, 0xFF303200, 0xFF0A4800, 0xFF004E00, 0xFF004619, 0xFF003A58, 0xFF000000, 0xFF000000, 0xFF000000, 0xFFB2B2B2, 0xFF1A53D1, 0xFF4835EE, 0xFF7123EC, 0xFF9A1EB7, 0xFFA51E62, 0xFFA52D19, 0xFF874B00, 0xFF676900, 0xFF298400, 0xFF038B00, 0xFF008240, 0xFF007891, 0xFF000000, 0xFF000000, 0xFF000000, 0xFFFFFFFF, 0xFF63ADFD, 0xFF908AFE, 0xFFB977FC, 0xFFE771FE, 0xFFF76FC9, 0xFFF5836A, 0xFFDD9C29, 0xFFBDB807, 0xFF84D107, 0xFF5BDC3B, 0xFF48D77D, 0xFF48CCCE, 0xFF555555, 0xFF000000, 0xFF000000, 0xFFFFFFFF, 0xFFC4E3FE, 0xFFD7D5FE, 0xFFE6CDFE, 0xFFF9CAFE, 0xFFFEC9F0, 0xFFFED1C7, 0xFFF7DCAC, 0xFFE8E89C, 0xFFD1F29D, 0xFFBFF4B1, 0xFFB7F5CD, 0xFFB7F0EE, 0xFFBEBEBE, 0xFF000000, 0xFF000000 };
uint32_t yuvPalette[0x40] { 0xFF666666, 0xFF002A88, 0xFF1412A7, 0xFF3B00A4, 0xFF5C007E, 0xFF6E0040, 0xFF6C0700, 0xFF561D00, 0xFF333500, 0xFF0C4800, 0xFF005200, 0xFF004C18, 0xFF003E5B, 0xFF000000, 0xFF000000, 0xFF000000, 0xFFADADAD, 0xFF155FD9, 0xFF4240FF, 0xFF7527FE, 0xFFA01ACC, 0xFFB71E7B, 0xFFB53120, 0xFF994E00, 0xFF6B6D00, 0xFF388700, 0xFF0D9300, 0xFF008C47, 0xFF007AA0, 0xFF000000, 0xFF000000, 0xFF000000, 0xFFFFFFFF, 0xFF64B0FF, 0xFF9290FF, 0xFFC676FF, 0xFFF26AFF, 0xFFFF6ECC, 0xFFFF8170, 0xFFEA9E22, 0xFFBCBE00, 0xFF88D800, 0xFF5CE430, 0xFF45E082, 0xFF48CDDE, 0xFF4F4F4F, 0xFF000000, 0xFF000000, 0xFFFFFFFF, 0xFFC0DFFF, 0xFFD3D2FF, 0xFFE8C8FF, 0xFFFAC2FF, 0xFFFFC4EA, 0xFFFFCCC5, 0xFFF7D8A5, 0xFFE4E594, 0xFFCFEF96, 0xFFBDF4AB, 0xFFB3F3CC, 0xFFB5EBF2, 0xFFB8B8B8, 0xFF000000, 0xFF000000 };
uint32_t nestopiaRgbPalette[0x40] { 0xFF6D6D6D, 0xFF002492, 0xFF0000DB, 0xFF6D49DB, 0xFF92006D, 0xFFB6006D, 0xFFB62400, 0xFF924900, 0xFF6D4900, 0xFF244900, 0xFF006D24, 0xFF009200, 0xFF004949, 0xFF000000, 0xFF000000, 0xFF000000, 0xFFB6B6B6, 0xFF006DDB, 0xFF0049FF, 0xFF9200FF, 0xFFB600FF, 0xFFFF0092, 0xFFFF0000, 0xFFDB6D00, 0xFF926D00, 0xFF249200, 0xFF009200, 0xFF00B66D, 0xFF009292, 0xFF242424, 0xFF000000, 0xFF000000, 0xFFFFFFFF, 0xFF6DB6FF, 0xFF9292FF, 0xFFDB6DFF, 0xFFFF00FF, 0xFFFF6DFF, 0xFFFF9200, 0xFFFFB600, 0xFFDBDB00, 0xFF6DDB00, 0xFF00FF00, 0xFF49FFDB, 0xFF00FFFF, 0xFF494949, 0xFF000000, 0xFF000000, 0xFFFFFFFF, 0xFFB6DBFF, 0xFFDBB6FF, 0xFFFFB6FF, 0xFFFF92FF, 0xFFFFB6B6, 0xFFFFDB92, 0xFFFFFF49, 0xFFFFFF6D, 0xFFB6FF49, 0xFF92FF6D, 0xFF49FFDB, 0xFF92DBFF, 0xFF929292, 0xFF000000, 0xFF000000 };
uint32_t compositeDirectPalette[0x40] { 0xFF656565, 0xFF00127D, 0xFF18008E, 0xFF360082, 0xFF56005D, 0xFF5A0018, 0xFF4F0500, 0xFF381900, 0xFF1D3100, 0xFF003D00, 0xFF004100, 0xFF003B17, 0xFF002E55, 0xFF000000, 0xFF000000, 0xFF000000, 0xFFAFAFAF, 0xFF194EC8, 0xFF472FE3, 0xFF6B1FD7, 0xFF931BAE, 0xFF9E1A5E, 0xFF993200, 0xFF7B4B00, 0xFF5B6700, 0xFF267A00, 0xFF008200, 0xFF007A3E, 0xFF006E8A, 0xFF000000, 0xFF000000, 0xFF000000, 0xFFFFFFFF, 0xFF64A9FF, 0xFF8E89FF, 0xFFB676FF, 0xFFE06FFF, 0xFFEF6CC4, 0xFFF0806A, 0xFFD8982C, 0xFFB9B40A, 0xFF83CB0C, 0xFF5BD63F, 0xFF4AD17E, 0xFF4DC7CB, 0xFF4C4C4C, 0xFF000000, 0xFF000000, 0xFFFFFFFF, 0xFFC7E5FF, 0xFFD9D9FF, 0xFFE9D1FF, 0xFFF9CEFF, 0xFFFFCCF1, 0xFFFFD4CB, 0xFFF8DFB1, 0xFFEDEAA4, 0xFFD6F4A4, 0xFFC5F8B8, 0xFFBEF6D3, 0xFFBFF1F1, 0xFFB9B9B9, 0xFF000000, 0xFF000000 };
uint32_t nesClassicPalette[0x40] { 0xFF60615F, 0xFF000083, 0xFF1D0195, 0xFF340875, 0xFF51055E, 0xFF56000F, 0xFF4C0700, 0xFF372308, 0xFF203A0B, 0xFF0F4B0E, 0xFF194C16, 0xFF02421E, 0xFF023154, 0xFF000000, 0xFF000000, 0xFF000000, 0xFFA9AAA8, 0xFF104BBF, 0xFF4712D8, 0xFF6300CA, 0xFF8800A9, 0xFF930B46, 0xFF8A2D04, 0xFF6F5206, 0xFF5C7114, 0xFF1B8D12, 0xFF199509, 0xFF178448, 0xFF206B8E, 0xFF000000, 0xFF000000, 0xFF000000, 0xFFFBFBFB, 0xFF6699F8, 0xFF8974F9, 0xFFAB58F8, 0xFFD557EF, 0xFFDE5FA9, 0xFFDC7F59, 0xFFC7A224, 0xFFA7BE03, 0xFF75D703, 0xFF60E34F, 0xFF3CD68D, 0xFF56C9CC, 0xFF414240, 0xFF000000, 0xFF000000, 0xFFFBFBFB, 0xFFBED4FA, 0xFFC9C7F9, 0xFFD7BEFA, 0xFFE8B8F9, 0xFFF5BAE5, 0xFFF3CAC2, 0xFFDFCDA7, 0xFFD9E09C, 0xFFC9EB9E, 0xFFC0EDB8, 0xFFB5F4C7, 0xFFB9EAE9, 0xFFABABAB, 0xFF000000, 0xFF000000 };
uint32_t originalHardwarePalette[0x40] { 0xFF6A6D6A, 0xFF00127D, 0xFF1E008A, 0xFF3B007D, 0xFF56005D, 0xFF5A0018, 0xFF4F0D00, 0xFF381E00, 0xFF203100, 0xFF003D00, 0xFF004000, 0xFF003B1E, 0xFF002E55, 0xFF000000, 0xFF000000, 0xFF000000, 0xFFB9BCB9, 0xFF194EC8, 0xFF472FE3, 0xFF751FD7, 0xFF931EAD, 0xFF9E245E, 0xFF963800, 0xFF7B5000, 0xFF5B6700, 0xFF267A00, 0xFF007F00, 0xFF007842, 0xFF006E8A, 0xFF000000, 0xFF000000, 0xFF000000, 0xFFFFFFFF, 0xFF69AEFF, 0xFF9798FF, 0xFFB687FF, 0xFFE278FF, 0xFFF279C7, 0xFFF58F6F, 0xFFDDA932, 0xFFBCB70D, 0xFF88D015, 0xFF60DB49, 0xFF4FD687, 0xFF50CACE, 0xFF515451, 0xFF000000, 0xFF000000, 0xFFFFFFFF, 0xFFCCEAFF, 0xFFDEE2FF, 0xFFEEDAFF, 0xFFFAD7FD, 0xFFFDD7F6, 0xFFFDDCD0, 0xFFFAE8B6, 0xFFF2F1A9, 0xFFDBFBA9, 0xFFCAFFBD, 0xFFC3FBD8, 0xFFC4F6F6, 0xFFBEC1BE, 0xFF000000, 0xFF000000 };
uint32_t pvmStylePalette[0x40] { 0xFF696964, 0xFF001774, 0xFF28007D, 0xFF3E006D, 0xFF560057, 0xFF5E0013, 0xFF531A00, 0xFF3B2400, 0xFF2A3000, 0xFF143A00, 0xFF003F00, 0xFF003B1E, 0xFF003050, 0xFF000000, 0xFF000000, 0xFF000000, 0xFFB9B9B4, 0xFF1453B9, 0xFF4D2CDA, 0xFF7A1EC8, 0xFF98189C, 0xFF9D2344, 0xFFA03E00, 0xFF8D5500, 0xFF656D00, 0xFF2C7900, 0xFF008100, 0xFF007D42, 0xFF00788A, 0xFF000000, 0xFF000000, 0xFF000000, 0xFFFFFFFF, 0xFF69A8FF, 0xFF9A96FF, 0xFFC28AFA, 0xFFEA7DFA, 0xFFF387B4, 0xFFF1986C, 0xFFE6B327, 0xFFD7C805, 0xFF90DF07, 0xFF64E53C, 0xFF45E27D, 0xFF48D5D9, 0xFF4B4B46, 0xFF000000, 0xFF000000, 0xFFFFFFFF, 0xFFD2EAFF, 0xFFE2E2FF, 0xFFF2D8FF, 0xFFF8D2FF, 0xFFF8D9EA, 0xFFFADEB9, 0xFFF9E89B, 0xFFF3F28C, 0xFFD3FA91, 0xFFB8FCA8, 0xFFAEFACA, 0xFFCAF3F3, 0xFFBEBEB9, 0xFF000000, 0xFF000000 };
uint32_t sonyCxa2025AsPalette[0x40] { 0xFF585858, 0xFF00238C, 0xFF00139B, 0xFF2D0585, 0xFF5D0052, 0xFF7A0017, 0xFF7A0800, 0xFF5F1800, 0xFF352A00, 0xFF093900, 0xFF003F00, 0xFF003C22, 0xFF00325D, 0xFF000000, 0xFF000000, 0xFF000000, 0xFFA1A1A1, 0xFF0053EE, 0xFF153CFE, 0xFF6028E4, 0xFFA91D98, 0xFFD41E41, 0xFFD22C00, 0xFFAA4400, 0xFF6C5E00, 0xFF2D7300, 0xFF007D06, 0xFF007852, 0xFF0069A9, 0xFF000000, 0xFF000000, 0xFF000000, 0xFFFFFFFF, 0xFF1FA5FE, 0xFF5E89FE, 0xFFB572FE, 0xFFFE65F6, 0xFFFE6790, 0xFFFE773C, 0xFFFE9308, 0xFFC4B200, 0xFF79CA10, 0xFF3AD54A, 0xFF11D1A4, 0xFF06BFFE, 0xFF424242, 0xFF000000, 0xFF000000, 0xFFFFFFFF, 0xFFA0D9FE, 0xFFBDCCFE, 0xFFE1C2FE, 0xFFFEBCFB, 0xFFFEBDD0, 0xFFFEC5A9, 0xFFFED18E, 0xFFE9DE86, 0xFFC7E992, 0xFFA8EEB0, 0xFF95ECD9, 0xFF91E4FE, 0xFFACACAC, 0xFF000000, 0xFF000000 };
uint32_t wavebeamPalette[0x40] { 0xFF6B6B6B, 0xFF001B88, 0xFF21009A, 0xFF40008C, 0xFF600067, 0xFF64001E, 0xFF590800, 0xFF481600, 0xFF283600, 0xFF004500, 0xFF004908, 0xFF00421D, 0xFF003659, 0xFF000000, 0xFF000000, 0xFF000000, 0xFFB4B4B4, 0xFF1555D3, 0xFF4337EF, 0xFF7425DF, 0xFF9C19B9, 0xFFAC0F64, 0xFFAA2C00, 0xFF8A4B00, 0xFF666B00, 0xFF218300, 0xFF008A00, 0xFF008144, 0xFF007691, 0xFF000000, 0xFF000000, 0xFF000000, 0xFFFFFFFF, 0xFF63B2FF, 0xFF7C9CFF, 0xFFC07DFE, 0xFFE977FF, 0xFFF572CD, 0xFFF4886B, 0xFFDDA029, 0xFFBDBD0A, 0xFF89D20E, 0xFF5CDE3E, 0xFF4BD886, 0xFF4DCFD2, 0xFF525252, 0xFF000000, 0xFF000000, 0xFFFFFFFF, 0xFFBCDFFF, 0xFFD2D2FF, 0xFFE1C8FF, 0xFFEFC7FF, 0xFFFFC3E1, 0xFFFFCAC6, 0xFFF2DAAD, 0xFFEBE3A0, 0xFFD2EDA2, 0xFFBCF4B4, 0xFFB5F1CE, 0xFFB6ECF1, 0xFFBFBFBF, 0xFF000000, 0xFF000000 };
extern "C" {
void logMessage(retro_log_level level, const char* message)
{
if(logCallback) {
logCallback(level, message);
}
}
RETRO_API unsigned retro_api_version()
{
return RETRO_API_VERSION;
}
RETRO_API void retro_init()
{
struct retro_log_callback log;
if(env_cb(RETRO_ENVIRONMENT_GET_LOG_INTERFACE, &log)) {
logCallback = log.log;
if(logCallback) {
logMessage(RETRO_LOG_INFO, "Mesen2 libretro core initialized\n");
}
} else {
logCallback = nullptr;
}
fprintf(stderr, "[libretro] retro_init: logCallback=%p\n", (void*)logCallback);
fflush(stderr);
// Create the emulator and initialize its subsystems
_emu.reset(new Emulator());
_emu->Initialize(); // sets up settings, video/audio subsystems, etc.
// Provide the global KeyManager with the emulator settings so calls like
// KeyManager::SetForceFeedback can safely read configuration values.
KeyManager::SetSettings(_emu->GetSettings());
// Grab the IConsole instance and dynamic_cast to NesConsole when needed
auto consoleIf = _emu->GetConsole(); // shared_ptr<IConsole>
_console = std::dynamic_pointer_cast<NesConsole>(consoleIf);
// Key manager accepts the IConsole shared_ptr returned by the emulator
// and also needs a pointer to the Emulator for mouse positioning.
_keyManager = std::make_shared<LibretroKeyManager>(consoleIf, _emu.get());
// Forward any previously saved input callbacks into the key manager and register it
if(_savedGetInputState) _keyManager->SetGetInputState(_savedGetInputState);
if(_savedPollInput) _keyManager->SetPollInput(_savedPollInput);
// KeyManager now expects a shared_ptr<IKeyManager> for thread-safe registration
KeyManager::RegisterKeyManager(std::shared_ptr<IKeyManager>(_keyManager));
_message_manager.reset(new LibretroMessageManager(logCallback, env_cb));
std::stringstream databaseData;
databaseData.write((const char*)MesenDatabase, sizeof(MesenDatabase));
GameDatabase::LoadGameDb(databaseData);
// Map sample rate into the new EmuSettings API
AudioConfig ac = _emu->GetSettings()->GetAudioConfig();
ac.SampleRate = _audioSampleRate;
_emu->GetSettings()->SetAudioConfig(ac);
// Create libretro audio device so we can register it later once a ROM is loaded
_audioDevice.reset(new LibretroAudioDevice());
if(_emu->GetSoundMixer()) {
_emu->GetSoundMixer()->RegisterAudioDevice(_audioDevice.get());
}
// NOTE: many NES-specific flags moved into NesConfig inside EmuSettings.
// Example: to set FDS auto-load you'd edit NesConfig and call SetNesConfig.
// _emu->GetSettings()->GetNesConfig().FdsAutoLoadDisk = true; // then SetNesConfig(...)
if (env_cb(RETRO_ENVIRONMENT_GET_INPUT_BITMASKS, NULL))
_keyManager->SetSupportsInputBitmasks(true);
}
RETRO_API void retro_deinit()
{
if(_keyManager) _keyManager->SetSupportsInputBitmasks(false);
// Unregister the key manager from the global KeyManager to avoid a
// dangling pointer during emulator shutdown. KeyManager::RegisterKeyManager
// accepts an empty shared_ptr to clear the registered backend.
KeyManager::RegisterKeyManager(std::shared_ptr<IKeyManager>());
_keyManager.reset();
_message_manager.reset();
// Properly shut down the emulator instance
if(_emu) {
// Unregister libretro audio device before releasing the emulator
if(_audioDevice) {
if(_emu->GetSoundMixer()) _emu->GetSoundMixer()->RegisterAudioDevice(nullptr);
_audioDevice.reset();
}
// Destroy console(s) first so their destructors run while the emulator
// (and subsystems like SoundMixer) are still available.
_console.reset();
// Make sure KeyManager is unregistered before calling Release()
// (do nothing here because we already unregistered above)
_emu->Release();
_emu.reset();
}
// Now that the emulator instance has been released, clear the settings
// pointer stored in the global KeyManager to avoid dangling references.
KeyManager::SetSettings(nullptr);
}
RETRO_API void retro_set_environment(retro_environment_t env)
{
env_cb = env;
// Core Options v2: Categories
static const retro_core_option_v2_category option_cats[] = {
{ "system", "System", "System settings (region, RAM, overclock)" },
{ "video", "Video", "Video settings (palette, filters, overscan)" },
{ "audio", "Audio", "Audio settings (filters, channels, sample rate)" },
{ "input", "Input", "Input controller settings" },
{ "enhancements", "Enhancements", "Enhancement options (HD packs, sprite limit)" },
{ NULL, NULL, NULL }
};
// Core Options v2: Definitions
static const retro_core_option_v2_definition option_defs[] = {
// System category
{ MesenRegion, "System - Region", "Region", "Select NES region", NULL, "system",
{{ "Auto", "Auto" }, { "NTSC", "NTSC" }, { "PAL", "PAL" }, { "Dendy", "Dendy" }, { NULL, NULL }},
"Auto" },
{ MesenRamState, "System - RAM Power-On State", "RAM Power-On State", "Default power-on state for RAM", NULL, "system",
{{ "All 0s (Default)", "All 0s" }, { "All 1s", "All 1s" }, { "Random Values", "Random" }, { NULL, NULL }},
"All 0s (Default)" },
{ MesenOverclock, "System - Overclock", "Overclock", "Overclock the NES CPU", NULL, "system",
{{ "None", "None" }, { "Low", "Low" }, { "Medium", "Medium" }, { "High", "High" }, { "Very High", "Very High" }, { NULL, NULL }},
"None" },
{ MesenOverclockType, "System - Overclock Type", "Overclock Type", "When to apply overclock", NULL, "system",
{{ "Before NMI (Recommended)", "Before NMI" }, { "After NMI", "After NMI" }, { NULL, NULL }},
"Before NMI (Recommended)" },
{ MesenFdsAutoSelectDisk, "System - FDS Auto Insert Disk", "FDS Auto Insert", "Automatically insert disks on FDS games", NULL, "system",
{{ "disabled", "Off" }, { "enabled", "On" }, { NULL, NULL }},
"disabled" },
{ MesenFdsFastForwardLoad, "System - FDS Fast Forward On Load", "FDS Fast Forward", "Fast forward while FDS is loading", NULL, "system",
{{ "disabled", "Off" }, { "enabled", "On" }, { NULL, NULL }},
"disabled" },
{ MesenAllowInvalidInput, "System - Allow Invalid Input", "Allow Invalid Input", "Allow invalid input combinations", NULL, "system",
{{ "disabled", "Off" }, { "enabled", "On" }, { NULL, NULL }},
"disabled" },
{ MesenRandomizeMapperPowerOnState, "System - Randomize Mapper Power-On State", "Randomize Mapper Power-On", "Randomize mapper power-on state (for testing)", NULL, "system",
{{ "disabled", "Off" }, { "enabled", "On" }, { NULL, NULL }},
"disabled" },
{ MesenRandomizeCpuPpuAlignment, "System - Randomize CPU/PPU Alignment", "Randomize CPU/PPU Alignment", "Randomize CPU/PPU alignment (for testing)", NULL, "system",
{{ "disabled", "Off" }, { "enabled", "On" }, { NULL, NULL }},
"disabled" },
// Video category
{ MesenPalette, "Video - Palette", "Palette", "Select color palette", NULL, "video",
// TODO:FIXME RAW palette doesn't work
{{ "Default", "Default" }, { "Composite Direct (by FirebrandX)", }, { "Nes Classic", "NES Classic" }, { "Nestopia (RGB)", "Nestopia RGB" }, { "Original Hardware (by FirebrandX)", "Original Hardware" }, { "PVM Style (by FirebrandX)", "PVM Style" }, { "Sony CXA2025AS", "Sony CXA2025AS" }, { "Unsaturated v6 (by FirebrandX)", "Unsaturated v6" }, { "YUV v3 (by FirebrandX)", "YUV v3" }, { "Wavebeam (by nakedarthur)", "Wavebeam" }, { "Custom", "Custom" }, /*{ "Raw", "Raw" },*/ { NULL, NULL }},
"Default" },
// TODO:FIXME the commented NTSC filters don't work
{ MesenNtscFilter, "Video - NTSC Filter", "NTSC Filter", "NTSC video filter", NULL, "video",
{{ "Disabled", "Disabled" }, { "Composite (Blargg)", "Composite (Blargg)" }, /*{ "S-Video (Blargg)", "S-Video (Blargg)" }, { "RGB (Blargg)", "RGB (Blargg)" }, { "Monochrome (Blargg)", "Monochrome (Blargg)" }, { "Bisqwit 2x", "Bisqwit 2x" }, { "Bisqwit 4x", "Bisqwit 4x" }, { "Bisqwit 8x", "Bisqwit 8x" },*/ { NULL, NULL }},
"Disabled" },
// TODO:FIXME overscan cropping and AR options don't work
/* { MesenOverscanLeft, "Video - Overscan Left", "Overscan Left", "Left overscan", NULL, "video",
{{ "None", "None" }, { "4px", "4px" }, { "8px", "8px" }, { "12px", "12px" }, { "16px", "16px" }, { NULL, NULL }},
"None" },
{ MesenOverscanRight, "Video - Overscan Right", "Overscan Right", "Right overscan", NULL, "video",
{{ "None", "None" }, { "4px", "4px" }, { "8px", "8px" }, { "12px", "12px" }, { "16px", "16px" }, { NULL, NULL }},
"None" },
{ MesenOverscanTop, "Video - Overscan Top", "Overscan Top", "Top overscan", NULL, "video",
{{ "None", "None" }, { "4px", "4px" }, { "8px", "8px" }, { "12px", "12px" }, { "16px", "16px" }, { NULL, NULL }},
"None" },
{ MesenOverscanBottom, "Video - Overscan Bottom", "Overscan Bottom", "Bottom overscan", NULL, "video",
{{ "None", "None" }, { "4px", "4px" }, { "8px", "8px" }, { "12px", "12px" }, { "16px", "16px" }, { NULL, NULL }},
"None" },
{ MesenAspectRatio, "Video - Aspect Ratio", "Aspect Ratio", "Display aspect ratio", NULL, "video",
{{ "Auto", "Auto" }, { "No Stretching", "No Stretching" }, { "NTSC", "NTSC" }, { "PAL", "PAL" }, { "4:3", "4:3" }, { "4:3 (Preserved)", "4:3 (Preserved)" }, { "16:9", "16:9" }, { "16:9 (Preserved)", "16:9 (Preserved)" }, { NULL, NULL }},
"Auto" },
{ MesenScreenRotation, "Video - Screen Rotation", "Screen Rotation", "Rotate screen display", NULL, "video",
{{ "None", "None" }, { "90 degrees", "90 degrees" }, { "180 degrees", "180 degrees" }, { "270 degrees", "270 degrees" }, { NULL, NULL }},
"None" },
*/
{ MesenEnablePalBorders, "Video - Enable PAL Borders", "PAL Borders", "Show borders in PAL mode", NULL, "video",
{{ "disabled", "Off" }, { "enabled", "On" }, { NULL, NULL }},
"disabled" },
// Audio category
{ MesenFakeStereo, "Audio - Fake Stereo", "Fake Stereo", "Enable fake stereo effect", NULL, "audio",
{{ "disabled", "Off" }, { "enabled", "On" }, { NULL, NULL }},
"disabled" },
{ MesenMuteTriangleUltrasonic, "Audio - Reduce Triangle Popping", "Reduce Triangle Popping", "Mute Triangle channel ultrasonic frequencies", NULL, "audio",
{{ "enabled", "On" }, { "disabled", "Off" }, { NULL, NULL }},
"enabled" },
{ MesenReduceDmcPopping, "Audio - Reduce DMC Popping", "Reduce DMC Popping", "Reduce popping on DMC channel", NULL, "audio",
{{ "enabled", "On" }, { "disabled", "Off" }, { NULL, NULL }},
"enabled" },
{ MesenSwapDutyCycle, "Audio - Swap Duty Cycles", "Swap Duty Cycles", "Swap Square channel duty cycles", NULL, "audio",
{{ "disabled", "Off" }, { "enabled", "On" }, { NULL, NULL }},
"disabled" },
{ MesenDisableNoiseModeFlag, "Audio - Disable Noise Mode Flag", "Disable Noise Mode", "Disable Noise channel mode flag", NULL, "audio",
{{ "disabled", "Off" }, { "enabled", "On" }, { NULL, NULL }},
"disabled" },
{ MesenAudioSampleRate, "Audio - Sample Rate", "Sample Rate", "Audio output sample rate", NULL, "audio",
{{ "48000", "48000 Hz" }, { "96000", "96000 Hz" }, { "11025", "11025 Hz" }, { "22050", "22050 Hz" }, { "44100", "44100 Hz" }, { NULL, NULL }},
"44100" },
// Input category
{ MesenControllerTurboSpeed, "Input - Controller Turbo Speed", "Turbo Speed", "Turbo button speed", NULL, "input",
{{ "Fast", "Fast" }, { "Very Fast", "Very Fast" }, { "Disabled", "Disabled" }, { "Slow", "Slow" }, { "Normal", "Normal" }, { NULL, NULL }},
"Normal" },
/*
{ MesenShiftButtonsClockwise, "Input - Shift Buttons Clockwise", "Shift Buttons", "Shift A/B/X/Y buttons clockwise", NULL, "input",
{{ "disabled", "Off" }, { "enabled", "On" }, { NULL, NULL }},
"disabled" },
*/
// Enhancements category (additional options)
{ MesenSpritesEnabled, "Enhancements - Sprites Enabled", "Sprites Enabled", "Enable sprite rendering", NULL, "enhancements",
{{ "enabled", "On" }, { "disabled", "Off" }, { NULL, NULL }},
"enabled" },
{ MesenBackgroundEnabled, "Enhancements - Background Enabled", "Background Enabled", "Enable background rendering", NULL, "enhancements",
{{ "enabled", "On" }, { "disabled", "Off" }, { NULL, NULL }},
"enabled" },
{ MesenDisableGameGenieBusConflicts, "Enhancements - Disable Game Genie Bus Conflicts", "Game Genie Bus Conflicts", "Disable Game Genie bus conflicts", NULL, "enhancements",
{{ "disabled", "Off" }, { "enabled", "On" }, { NULL, NULL }},
"disabled" },
/*
// Enhancements category
{ MesenHdPacks, "Enhancements - HD Packs", "HD Packs", "Enable HD graphics packs", NULL, "enhancements",
{{ "enabled", "On" }, { "disabled", "Off" }, { NULL, NULL }},
"enabled" },
*/
{ MesenSpriteLimit, "Enhancements - Sprite Limit", "Sprite Limit", "8-sprite scanline limit", NULL, "enhancements",
{{ "normal", "Normal" }, { "adaptive", "Adaptive" }, { "off", "Off" }, { NULL, NULL }},
"normal" },
{ NULL, NULL, NULL, NULL, NULL, NULL, {{ NULL, NULL }}, NULL }
};
static retro_core_options_v2 core_opt_info = {
(retro_core_option_v2_category*)option_cats,
(retro_core_option_v2_definition*)option_defs
};
env_cb(RETRO_ENVIRONMENT_SET_CORE_OPTIONS_V2, &core_opt_info);
static constexpr struct retro_controller_description pads1[] = {
{ "Auto", DEVICE_AUTO },
{ "Standard Controller", DEVICE_GAMEPAD },
{ "Zapper", DEVICE_ZAPPER },
{ "Power Pad", DEVICE_POWERPAD },
{ "Arkanoid", DEVICE_ARKANOID },
{ "SNES Controller", DEVICE_SNESGAMEPAD },
{ "SNES Mouse", DEVICE_SNESMOUSE },
{ "Gameboy Controller", DEVICE_GAMEBOYGAMEPAD },
{ "Virtual Boy Controller" ,DEVICE_VBGAMEPAD },
{ NULL, 0 },
};
static constexpr struct retro_controller_description pads2[] = {
{ "Auto", DEVICE_AUTO },
{ "Standard Controller", DEVICE_GAMEPAD },
{ "Zapper", DEVICE_ZAPPER },
{ "Power Pad", DEVICE_POWERPAD },
{ "Arkanoid", DEVICE_ARKANOID },
{ "SNES Controller", DEVICE_SNESGAMEPAD },
{ "SNES Mouse", DEVICE_SNESMOUSE },
{ "Virtual Boy Controller", DEVICE_VBGAMEPAD },
{ NULL, 0 },
};
static constexpr struct retro_controller_description pads3[] = {
{ "Auto", DEVICE_AUTO },
{ "Standard Controller", DEVICE_GAMEPAD },
{ NULL, 0 },
};
static constexpr struct retro_controller_description pads4[] = {
{ "Auto", DEVICE_AUTO },
{ "Standard Controller", DEVICE_GAMEPAD },
{ NULL, 0 },
};
static constexpr struct retro_controller_description pads5[] = {
{ "Auto", RETRO_DEVICE_JOYPAD },
{ "Arkanoid", DEVICE_ARKANOID },
{ "Ascii Turbo File", DEVICE_ASCIITURBOFILE },
{ "Bandai Hypershot", DEVICE_BANDAIHYPERSHOT },
{ "Battle Box", DEVICE_BATTLEBOX },
{ "Exciting Boxing", DEVICE_EXCITINGBOXING },
{ "Family Trainer", DEVICE_FAMILYTRAINER },
{ "Four Player Adapter", DEVICE_FOURPLAYERADAPTER },
{ "Hori Track", DEVICE_HORITRACK },
{ "Konami Hypershot", DEVICE_KONAMIHYPERSHOT },
{ "Pachinko", DEVICE_PACHINKO },
{ "Partytap", DEVICE_PARTYTAP },
{ "Oeka Kids Tablet", DEVICE_OEKAKIDS },
{ NULL, 0 },
};
static constexpr struct retro_controller_info ports[] = {
{ pads1, 7 },
{ pads2, 7 },
{ pads3, 2 },
{ pads4, 2 },
{ pads5, 13 },
{ 0 },
};
static const struct retro_system_content_info_override content_overrides[] = {
{
"nes|fds|unf|unif|sfc|smc|gb|gbc|gba|pce|sgx|sms|gg|ws|wsc", /* extensions */
false, /* need_fullpath */
false /* persistent_data */
},
{ NULL, false, false }
};
env_cb(RETRO_ENVIRONMENT_SET_CONTROLLER_INFO, (void*)ports);
env_cb(RETRO_ENVIRONMENT_SET_CONTENT_INFO_OVERRIDE, (void*)content_overrides);
static const struct retro_subsystem_rom_info sgbSubsystemRoms[] = {
{ "Game Boy ROM", "gb|gbc|gbx", false, false, true },
{ "Super Game Boy ROM", "sfc|smc", false, false, true },
{ NULL, NULL, false, false, false }
};
static const struct retro_subsystem_info subsystem_infos[] = {
{ "Super Game Boy", "sgb", sgbSubsystemRoms, 2, 2 },
{ NULL, NULL, NULL, 0, 0 }
};
env_cb(RETRO_ENVIRONMENT_SET_SUBSYSTEM_INFO, (void*)subsystem_infos);
//Ask the frontend for its VFS interface - required to load content the
//core cannot open itself (Android SAF content:// URIs in particular).
//v3 is requested so the directory calls (stat/mkdir/opendir) are usable too.
static struct retro_vfs_interface_info vfs_iface_info;
vfs_iface_info.required_interface_version = 3;
vfs_iface_info.iface = nullptr;
if(env_cb(RETRO_ENVIRONMENT_GET_VFS_INTERFACE, &vfs_iface_info) && vfs_iface_info.iface) {
VfsIo::SetInterface(vfs_iface_info.iface, vfs_iface_info.required_interface_version);
} else {
//Fall back to v2 (file I/O only, no directory calls)
vfs_iface_info.required_interface_version = 2;
vfs_iface_info.iface = nullptr;
if(env_cb(RETRO_ENVIRONMENT_GET_VFS_INTERFACE, &vfs_iface_info) && vfs_iface_info.iface) {
VfsIo::SetInterface(vfs_iface_info.iface, vfs_iface_info.required_interface_version);
}
}
}
RETRO_API void retro_set_video_refresh(retro_video_refresh_t sendFrame)
{
// VideoRenderer no longer exposes SetVideoCallback — keep the libretro callback here.
_videoRefresh = sendFrame;
}
RETRO_API void retro_set_audio_sample(retro_audio_sample_t sendAudioSample)
{
}
RETRO_API void retro_set_audio_sample_batch(retro_audio_sample_batch_t audioSampleBatch)
{
// Mixer API changed; keep the libretro callback for later use by audio path
_audioSampleBatch = audioSampleBatch;
}
RETRO_API void retro_set_input_poll(retro_input_poll_t pollInput)
{
// store the callback for later use and forward to key manager if it's active
_savedPollInput = pollInput;
if(_keyManager) _keyManager->SetPollInput(pollInput);
// Probe input callbacks immediately from the thread that set them to
// help debug frontend timing/order issues. This is noisy by default so
// gate it behind an environment variable (MESEN_LIBRETRO_VERBOSE_INPUT).
if((pollInput || _savedGetInputState) && getenv("MESEN_LIBRETRO_VERBOSE_INPUT")) {
extern void libretro_probe_inputs(const char*);
libretro_probe_inputs("setter_poll");
}
}
RETRO_API void retro_set_input_state(retro_input_state_t getInputState)
{
_savedGetInputState = getInputState;
if(_keyManager) _keyManager->SetGetInputState(getInputState);
if((getInputState || _savedPollInput) && getenv("MESEN_LIBRETRO_VERBOSE_INPUT")) {
extern void libretro_probe_inputs(const char*);
libretro_probe_inputs("setter_getstate");
}
}
// Shared diagnostic probe called from multiple places to exercise the saved
// input callbacks and print their results. The argument is a short tag
// describing the caller (for log clarity).
void libretro_probe_inputs(const char* tag)
{
if(!env_cb) return;
if(_savedPollInput) {
try { _savedPollInput(); } catch(...) { }
}
// Query bitmask capability but avoid calling the frontend get_state callback here.
// Some libretro frontends crash if get_state is invoked outside their expected
// input polling context (we observed a segmentation fault). To be safe, only
// log availability and defer actual get_state calls to the normal per-frame
// RefreshState path which runs on the emulator/main thread.
bool bitmasks = false;
if (env_cb(RETRO_ENVIRONMENT_GET_INPUT_BITMASKS, NULL)) bitmasks = true;
}
RETRO_API void retro_reset()
{
// Reset signature changed — call parameterless Reset if available
_console->Reset();
}
bool readVariable(const char* key, retro_variable &var)
{
var.key = key;
var.value = nullptr;
if(env_cb(RETRO_ENVIRONMENT_GET_VARIABLE, &var) && var.value != nullptr)
return true;
return false;
}
uint8_t readOverscanValue(const char* key)
{
retro_variable var = {};
if(readVariable(key, var)) {
string value = string(var.value);
if(value == "4px") {
return 4;
} else if(value == "8px") {
return 8;
} else if(value == "12px") {
return 12;
} else if(value == "16px") {
return 16;
}
}
return 0;
}
void set_flag(const char* flagName, uint64_t flagValue)
{
struct retro_variable var = {};
if(readVariable(flagName, var)) {
string value = string(var.value);
if(value == "disabled") {
_emu->GetSettings()->ClearFlag((EmulationFlags)flagValue);
} else {
_emu->GetSettings()->SetFlag((EmulationFlags)flagValue);
}
}
}
void load_custom_palette()
{
//Setup default palette in case we can't load the custom one
// Ensure video config is accessed so types are instantiated (no-op)
_emu->GetSettings()->GetVideoConfig();
// Store default palette locally; renderer wiring to use this will be added later.
_userRgbPalette.assign(std::begin(defaultPalette), std::end(defaultPalette));
//Try to load the custom palette from the MesenPalette.pal file
string palettePath = FolderUtilities::CombinePath(FolderUtilities::GetHomeFolder(), "MesenPalette.pal");
uint8_t fileData[512 * 3] = {};
utf8::ifstream palette(palettePath, std::ios::binary);
if(palette) {
palette.seekg(0, std::ios::end);
std::streamoff fileSize = palette.tellg();
palette.seekg(0, std::ios::beg);
if((fileSize == 64 * 3) || (fileSize == 512 * 3)) {
palette.read((char*)fileData, fileSize);
uint32_t customPalette[512];
int paletteCount = (int)(fileSize / 3);
for(int i = 0; i < paletteCount; i++) {
customPalette[i] = 0xFF000000 | fileData[i * 3 + 2] | (fileData[i * 3 + 1] << 8) | (fileData[i * 3] << 16);
}
_userRgbPalette.assign(customPalette, customPalette + paletteCount);
}
}
}
void update_settings()
{
struct retro_variable var = { };
NesConfig nesCfg = _emu->GetSettings()->GetNesConfig();
VideoConfig videoCfg = _emu->GetSettings()->GetVideoConfig();
AudioConfig audioCfg = _emu->GetSettings()->GetAudioConfig();
// ===== SYSTEM SETTINGS =====
// Region
if(readVariable(MesenRegion, var)) {
string value = string(var.value);
if(value == "NTSC") {
nesCfg.Region = ConsoleRegion::Ntsc;
} else if(value == "PAL") {
nesCfg.Region = ConsoleRegion::Pal;
} else if(value == "Dendy") {
nesCfg.Region = ConsoleRegion::Dendy;
} else {
nesCfg.Region = ConsoleRegion::Auto;
}
}
// RAM Power-On State
if(readVariable(MesenRamState, var)) {
string value = string(var.value);
if(value == "All 1s") {
nesCfg.RamPowerOnState = RamState::AllOnes;
} else if(value == "Random Values") {
nesCfg.RamPowerOnState = RamState::Random;
} else {
nesCfg.RamPowerOnState = RamState::AllZeros;
}
}
// Overclock
int lineCountBefore = 0;
int lineCountAfter = 0;
bool beforeNmi = true;
if(readVariable(MesenOverclockType, var)) {
string value = string(var.value);
beforeNmi = (value != "After NMI");
}
if(readVariable(MesenOverclock, var)) {
string value = string(var.value);
int lineCount = 0;
if(value == "Low") {
lineCount = 100;
} else if(value == "Medium") {
lineCount = 250;
} else if(value == "High") {
lineCount = 500;
} else if(value == "Very High") {
lineCount = 1000;
}
if(beforeNmi) {
lineCountBefore = lineCount;
} else {
lineCountAfter = lineCount;
}
}
nesCfg.PpuExtraScanlinesBeforeNmi = lineCountBefore;
nesCfg.PpuExtraScanlinesAfterNmi = lineCountAfter;
// FDS options
if(readVariable(MesenFdsAutoSelectDisk, var)) {
nesCfg.FdsAutoInsertDisk = (string(var.value) == "enabled");
}
if(readVariable(MesenFdsFastForwardLoad, var)) {
nesCfg.FdsFastForwardOnLoad = (string(var.value) == "enabled");
}
// ===== VIDEO SETTINGS =====
// Palette
if(readVariable(MesenPalette, var)) {
string value = string(var.value);
if(value == "Default") {
_userRgbPalette.assign(std::begin(defaultPalette), std::end(defaultPalette));
} else if(value == "Composite Direct (by FirebrandX)") {
_userRgbPalette.assign(std::begin(compositeDirectPalette), std::end(compositeDirectPalette));
} else if(value == "Nes Classic") {
_userRgbPalette.assign(std::begin(nesClassicPalette), std::end(nesClassicPalette));
} else if(value == "Nestopia (RGB)") {
_userRgbPalette.assign(std::begin(nestopiaRgbPalette), std::end(nestopiaRgbPalette));
} else if(value == "Original Hardware (by FirebrandX)") {
_userRgbPalette.assign(std::begin(originalHardwarePalette), std::end(originalHardwarePalette));
} else if(value == "PVM Style (by FirebrandX)") {
_userRgbPalette.assign(std::begin(pvmStylePalette), std::end(pvmStylePalette));
} else if(value == "Sony CXA2025AS") {
_userRgbPalette.assign(std::begin(sonyCxa2025AsPalette), std::end(sonyCxa2025AsPalette));
} else if(value == "Unsaturated v6 (by FirebrandX)") {
_userRgbPalette.assign(std::begin(unsaturatedPalette), std::end(unsaturatedPalette));
} else if(value == "YUV v3 (by FirebrandX)") {
_userRgbPalette.assign(std::begin(yuvPalette), std::end(yuvPalette));
} else if(value == "Wavebeam (by nakedarthur)") {
_userRgbPalette.assign(std::begin(wavebeamPalette), std::end(wavebeamPalette));
} else if(value == "Custom") {
load_custom_palette();
} else if(value == "Raw") {
_videoFilterRaw = true;
// For raw mode, use the default palette
_userRgbPalette.assign(std::begin(defaultPalette), std::end(defaultPalette));
}
}
// Copy palette into NesConfig
if(_userRgbPalette.size() >= 512) {
for(size_t i = 0; i < 512; ++i) nesCfg.UserPalette[i] = (i < _userRgbPalette.size()) ? _userRgbPalette[i] : 0xFF000000;
nesCfg.IsFullColorPalette = true;
} else {
for(size_t i = 0; i < 64; ++i) nesCfg.UserPalette[i] = (i < _userRgbPalette.size()) ? _userRgbPalette[i] : 0xFF000000;
nesCfg.IsFullColorPalette = false;
}
// NTSC Filter - map string selection to VideoFilterType enum and apply settings
if(readVariable(MesenNtscFilter, var)) {
string filterValue = string(var.value);
if(filterValue == "Disabled") {
videoCfg.VideoFilter = VideoFilterType::None;
} else if(filterValue == "Composite (Blargg)") {
videoCfg.VideoFilter = VideoFilterType::NtscBlargg;
videoCfg.NtscBlarggPreset_Value = NtscBlarggPreset::Composite;
}/* else if(filterValue == "S-Video (Blargg)") {
videoCfg.VideoFilter = VideoFilterType::NtscBlargg;
videoCfg.NtscBlarggPreset_Value = NtscBlarggPreset::Svideo;
} else if(filterValue == "RGB (Blargg)") {
videoCfg.VideoFilter = VideoFilterType::NtscBlargg;
videoCfg.NtscBlarggPreset_Value = NtscBlarggPreset::Rgb;
} else if(filterValue == "Monochrome (Blargg)") {
videoCfg.VideoFilter = VideoFilterType::NtscBlargg;
videoCfg.NtscBlarggPreset_Value = NtscBlarggPreset::Monochrome;
} else if(filterValue == "Bisqwit 2x") {
videoCfg.VideoFilter = VideoFilterType::NtscBisqwit;
videoCfg.NtscScale = NtscBisqwitFilterScale::_2x;
} else if(filterValue == "Bisqwit 4x") {
videoCfg.VideoFilter = VideoFilterType::NtscBisqwit;
videoCfg.NtscScale = NtscBisqwitFilterScale::_4x;
} else if(filterValue == "Bisqwit 8x") {
videoCfg.VideoFilter = VideoFilterType::NtscBisqwit;
videoCfg.NtscScale = NtscBisqwitFilterScale::_8x;
}*/
}
/*
// Overscan
nesCfg.NtscOverscan.Left = readOverscanValue(MesenOverscanLeft);
nesCfg.NtscOverscan.Right = readOverscanValue(MesenOverscanRight);
nesCfg.NtscOverscan.Top = readOverscanValue(MesenOverscanTop);
nesCfg.NtscOverscan.Bottom = readOverscanValue(MesenOverscanBottom);
// Use same overscan for PAL
nesCfg.PalOverscan = nesCfg.NtscOverscan;
// Aspect Ratio
if(readVariable(MesenAspectRatio, var)) {
_selectedAspectRatio = std::string(var.value ? var.value : "");
}
// Screen Rotation
if(readVariable(MesenScreenRotation, var)) {
string value = string(var.value);
if(value == "90 degrees") {
videoCfg.ScreenRotation = 90;
} else if(value == "180 degrees") {
videoCfg.ScreenRotation = 180;
} else if(value == "270 degrees") {
videoCfg.ScreenRotation = 270;
} else {
videoCfg.ScreenRotation = 0;
}
}
*/
// PAL Borders
if(readVariable(MesenEnablePalBorders, var)) {
nesCfg.EnablePalBorders = (string(var.value) == "enabled");
}
// ===== AUDIO SETTINGS =====
// Fake Stereo
if(readVariable(MesenFakeStereo, var)) {
nesCfg.StereoFilter = (string(var.value) == "enabled") ? StereoFilterType::Delay : StereoFilterType::None;
}
// Reduce Triangle Popping
if(readVariable(MesenMuteTriangleUltrasonic, var)) {
nesCfg.SilenceTriangleHighFreq = (string(var.value) == "enabled");
}
// Reduce DMC Popping
if(readVariable(MesenReduceDmcPopping, var)) {
nesCfg.ReduceDmcPopping = (string(var.value) == "enabled");
}
// Swap Duty Cycles
if(readVariable(MesenSwapDutyCycle, var)) {
nesCfg.SwapDutyCycles = (string(var.value) == "enabled");
}
// Disable Noise Mode Flag
if(readVariable(MesenDisableNoiseModeFlag, var)) {
nesCfg.DisableNoiseModeFlag = (string(var.value) == "enabled");
}
// Audio Sample Rate
if(readVariable(MesenAudioSampleRate, var)) {
int old_value = audioCfg.SampleRate;
audioCfg.SampleRate = atoi(var.value);
audioCfg.SampleRate = (audioCfg.SampleRate > 96000) ? 96000 : audioCfg.SampleRate;
if(old_value != audioCfg.SampleRate) {
// If core is running, notify frontend of geometry change
if(_saveStateSize != -1) {
struct retro_system_av_info system_av_info;
retro_get_system_av_info(&system_av_info);
env_cb(RETRO_ENVIRONMENT_SET_SYSTEM_AV_INFO, &system_av_info);
}
}
}
// ===== INPUT SETTINGS =====
// Controller Turbo Speed
int turboSpeed = 1; // default to Normal
bool turboEnabled = true;
if(readVariable(MesenControllerTurboSpeed, var)) {
string value = string(var.value);
if(value == "Slow") {
turboSpeed = 0;
} else if(value == "Normal") {
turboSpeed = 1;
} else if(value == "Fast") {
turboSpeed = 2;
} else if(value == "Very Fast") {
turboSpeed = 3;
} else if(value == "Disabled") {
turboEnabled = false;
}
}
/*
// Shift Buttons Clockwise
_shiftButtonsClockwise = false;
if(readVariable(MesenShiftButtonsClockwise, var)) {
_shiftButtonsClockwise = (string(var.value) == "enabled");
}
*/
auto getKeyCode = [](int port, int retroKey) {
return (port << 8) | (retroKey + 1);
};
auto getKeyBindings = [=](int port) {
KeyMappingSet keyMappings;
keyMappings.TurboSpeed = turboSpeed;
// Default NES-style mapping with optional clockwise shift
keyMappings.Mapping1.A = getKeyCode(port, _shiftButtonsClockwise ? RETRO_DEVICE_ID_JOYPAD_B : RETRO_DEVICE_ID_JOYPAD_A);
keyMappings.Mapping1.B = getKeyCode(port, _shiftButtonsClockwise ? RETRO_DEVICE_ID_JOYPAD_Y : RETRO_DEVICE_ID_JOYPAD_B);
if(turboEnabled) {
keyMappings.Mapping1.TurboA = getKeyCode(port, _shiftButtonsClockwise ? RETRO_DEVICE_ID_JOYPAD_A : RETRO_DEVICE_ID_JOYPAD_X);
keyMappings.Mapping1.TurboB = getKeyCode(port, _shiftButtonsClockwise ? RETRO_DEVICE_ID_JOYPAD_X : RETRO_DEVICE_ID_JOYPAD_Y);
}
keyMappings.Mapping1.Start = getKeyCode(port, RETRO_DEVICE_ID_JOYPAD_START);
keyMappings.Mapping1.Select = getKeyCode(port, RETRO_DEVICE_ID_JOYPAD_SELECT);
keyMappings.Mapping1.Up = getKeyCode(port, RETRO_DEVICE_ID_JOYPAD_UP);
keyMappings.Mapping1.Down = getKeyCode(port, RETRO_DEVICE_ID_JOYPAD_DOWN);
keyMappings.Mapping1.Left = getKeyCode(port, RETRO_DEVICE_ID_JOYPAD_LEFT);
keyMappings.Mapping1.Right = getKeyCode(port, RETRO_DEVICE_ID_JOYPAD_RIGHT);
return keyMappings;
};
nesCfg.Port1.Keys = getKeyBindings(0);
nesCfg.Port2.Keys = getKeyBindings(1);
nesCfg.Port1SubPorts[0].Keys = getKeyBindings(0);
nesCfg.Port1SubPorts[1].Keys = getKeyBindings(1);
nesCfg.Port1SubPorts[2].Keys = getKeyBindings(2);
nesCfg.Port1SubPorts[3].Keys = getKeyBindings(3);
nesCfg.ExpPort.Keys = getKeyBindings(4);
// ===== ENHANCEMENTS =====
/*
// HD Packs
_hdPacksEnabled = true;
if(readVariable(MesenHdPacks, var)) {
_hdPacksEnabled = (string(var.value) != "disabled");
}
nesCfg.EnableHdPacks = _hdPacksEnabled;
*/
// HD packs disabled - not working properly
_hdPacksEnabled = false;
nesCfg.EnableHdPacks = _hdPacksEnabled;
// Sprite Limit (3-choice: normal, adaptive, off)
nesCfg.RemoveSpriteLimit = false;
nesCfg.AdaptiveSpriteLimit = false;
if(readVariable(MesenSpriteLimit, var)) {
string value = string(var.value);
if(value == "adaptive") {
nesCfg.AdaptiveSpriteLimit = true;
} else if(value == "off") {
nesCfg.RemoveSpriteLimit = true;
}
}
// Sprites Enabled
if(readVariable(MesenSpritesEnabled, var)) {
nesCfg.SpritesEnabled = (string(var.value) == "enabled");
}
// Background Enabled
if(readVariable(MesenBackgroundEnabled, var)) {
nesCfg.BackgroundEnabled = (string(var.value) == "enabled");
}
// Disable Game Genie Bus Conflicts
if(readVariable(MesenDisableGameGenieBusConflicts, var)) {
nesCfg.DisableGameGenieBusConflicts = (string(var.value) == "enabled");
}
// ===== SYSTEM OPTIONS =====
// Allow Invalid Input
if(readVariable(MesenAllowInvalidInput, var)) {
nesCfg.AllowInvalidInput = (string(var.value) == "enabled");
}
// Randomize Mapper Power-On State
if(readVariable(MesenRandomizeMapperPowerOnState, var)) {
nesCfg.RandomizeMapperPowerOnState = (string(var.value) == "enabled");
}
// Randomize CPU/PPU Alignment
if(readVariable(MesenRandomizeCpuPpuAlignment, var)) {
nesCfg.RandomizeCpuPpuAlignment = (string(var.value) == "enabled");
}
// ===== APPLY ALL SETTINGS =====
_emu->GetSettings()->SetNesConfig(nesCfg);
_emu->GetSettings()->SetVideoConfig(videoCfg);
_emu->GetSettings()->SetAudioConfig(audioCfg);
// Check if geometry-related settings changed
bool videoFilterChanged = (_lastVideoConfig.VideoFilter != videoCfg.VideoFilter) ||
(_lastVideoConfig.NtscScale != videoCfg.NtscScale) ||
(_lastVideoConfig.ScreenRotation != videoCfg.ScreenRotation);
bool overscanChanged = (nesCfg.NtscOverscan.Left != _lastNesConfig.NtscOverscan.Left) ||
(nesCfg.NtscOverscan.Right != _lastNesConfig.NtscOverscan.Right) ||
(nesCfg.NtscOverscan.Top != _lastNesConfig.NtscOverscan.Top) ||
(nesCfg.NtscOverscan.Bottom != _lastNesConfig.NtscOverscan.Bottom) ||
(nesCfg.PalOverscan.Left != _lastNesConfig.PalOverscan.Left) ||
(nesCfg.PalOverscan.Right != _lastNesConfig.PalOverscan.Right) ||
(nesCfg.PalOverscan.Top != _lastNesConfig.PalOverscan.Top) ||
(nesCfg.PalOverscan.Bottom != _lastNesConfig.PalOverscan.Bottom);
if(videoFilterChanged || overscanChanged) {
_geometryDirty = true;
if(_emu && _emu->GetVideoDecoder()) {
_emu->GetVideoDecoder()->ForceFilterUpdate();
}
}
// Save current settings for next comparison
_lastVideoConfig = videoCfg;
_lastNesConfig = nesCfg;
}
RETRO_API void retro_run()
{
// ForceMaxSpeed flag API changed / unavailable here — skip fast-forward behavior for now.
if(false) {
#if 0
//Skip frames to speed up emulation while still outputting at 50/60 fps (needed for FDS fast forward while loading)
_console->GetVideoRenderer()->SetSkipMode(true);
_console->GetSoundMixer()->SetSkipMode(true);
for(int i = 0; i < 9; i++) {
//Attempt to speed up to 1000% speed
_console->RunSingleFrame();
}
_console->GetVideoRenderer()->SetSkipMode(false);
_console->GetSoundMixer()->SetSkipMode(false);
#endif
}
bool updated = false;
if(env_cb(RETRO_ENVIRONMENT_GET_VARIABLE_UPDATE, &updated) && updated) {
update_settings();
// Settings API moved; read flag from Emulator settings if available, otherwise skip.
bool hdPacksEnabled = false;
if(hdPacksEnabled != _hdPacksEnabled) {
// Defer HD pack update to emulator API (call removed here) — just track the change
_hdPacksEnabled = hdPacksEnabled;
}
}
// Frame stepping: run a single emulated frame and submit video/audio to libretro callbacks.
if(_emu && _emu->GetConsole()) {
// Refresh input state before running the frame
auto consoleIf = _emu->GetConsole();
if(_keyManager) {
consoleIf->GetControlManager()->UpdateInputState();
}
consoleIf->RunFrame();
// Allow emulator to run pre-frame hooks (UI, stats, etc.)
_emu->OnBeforeSendFrame();
// Get the PPU frame (core provides a 16-bit PPU buffer containing
// palette indices/intensity bits). Use the emulator's video filter
// to convert that buffer to a 32-bit ARGB frame so color/palette
// handling (including emphasis, user palettes, and filters) is
// consistent with the rest of the emulator.
PpuFrameInfo frame = _emu->GetPpuFrame();
// Check that we have a valid buffer with meaningful size (each system allocates differently)
if(_videoRefresh && frame.FrameBuffer && frame.FrameBufferSize > 0) {
// Create a temporary video filter (same pattern used by LuaApi)
std::unique_ptr<BaseVideoFilter> filter(_emu->GetVideoFilter());
FrameInfo baseSize = { frame.Width, frame.Height };
filter->SetBaseFrameInfo(baseSize);
FrameInfo outInfo = filter->SendFrame((uint16_t*)frame.FrameBuffer, _emu->GetFrameCount(), _emu->GetFrameCount() & 0x01, nullptr, false);
uint32_t* src = filter->GetOutputBuffer();
// Ensure we have valid output before displaying
if(src) {
size_t pixels = (size_t)outInfo.Width * (size_t)outInfo.Height;
static std::vector<uint32_t> rotBuffer;
if(_screenRotation == 0) {
_videoRefresh(src, outInfo.Width, outInfo.Height, outInfo.Width * 4);
} else {
int outW = (_screenRotation == 180) ? outInfo.Width : outInfo.Height;
int outH = (_screenRotation == 180) ? outInfo.Height : outInfo.Width;
rotBuffer.resize((size_t)outW * (size_t)outH);
if(_screenRotation == 180) {
for(size_t i = 0; i < pixels; ++i) rotBuffer[pixels - 1 - i] = src[i];
_videoRefresh(rotBuffer.data(), outInfo.Width, outInfo.Height, outInfo.Width * 4);
} else if(_screenRotation == 90) {
for(int y = 0; y < outInfo.Height; ++y) {
for(int x = 0; x < outInfo.Width; ++x) {
size_t srcIdx = (size_t)y * outInfo.Width + x;
int dstX = outInfo.Height - 1 - y;
int dstY = x;
size_t dstIdx = (size_t)dstY * outW + (size_t)dstX;
rotBuffer[dstIdx] = src[srcIdx];
}
}
_videoRefresh(rotBuffer.data(), outW, outH, outW * 4);
} else if(_screenRotation == 270) {
for(int y = 0; y < outInfo.Height; ++y) {
for(int x = 0; x < outInfo.Width; ++x) {
size_t srcIdx = (size_t)y * outInfo.Width + x;
int dstX = y;
int dstY = outInfo.Width - 1 - x;
size_t dstIdx = (size_t)dstY * outW + (size_t)dstX;
rotBuffer[dstIdx] = src[srcIdx];
}
}
_videoRefresh(rotBuffer.data(), outW, outH, outW * 4);
} else {
// Unknown rotation: fallback to non-rotated output
_videoRefresh(src, outInfo.Width, outInfo.Height, outInfo.Width * 4);
}
}
}
}
}
if(updated) {
// Only update geometry if something changed or if flag is set
if(_geometryDirty) {
retro_system_av_info avInfo = {};
retro_get_system_av_info(&avInfo);
uint32_t newWidth = avInfo.geometry.base_width;
uint32_t newHeight = avInfo.geometry.base_height;
// Only call SET_GEOMETRY if dimensions actually changed
if(newWidth != _lastReportedWidth || newHeight != _lastReportedHeight) {
_lastReportedWidth = newWidth;
_lastReportedHeight = newHeight;
env_cb(RETRO_ENVIRONMENT_SET_GEOMETRY, &avInfo);
}
_geometryDirty = false;
}
}
// Audio upload handled by emulator/sound subsystem; no-op here for now.
}
RETRO_API size_t retro_serialize_size()
{
return _saveStateSize;
}
RETRO_API bool retro_serialize(void *data, size_t size)
{
if(!_emu) return false;
try {
std::stringstream ss;
_emu->Serialize(ss, true, 1);
std::string out = ss.str();
if(out.size() > size) return false;
memcpy(data, out.data(), out.size());
return true;
} catch(...) {
return false;
}
}
RETRO_API bool retro_unserialize(const void *data, size_t size)
{
if(!_emu) return false;
try {
std::string in((const char*)data, size);
std::stringstream ss(in);
auto res = _emu->Deserialize(ss, SaveStateManager::FileFormatVersion, true);
return (res == DeserializeResult::Success);
} catch(...) {
return false;
}
}
RETRO_API void retro_cheat_reset()
{
if(_emu) {
// Cheat manager API moved; no-op for now.
}
}
RETRO_API void retro_cheat_set(unsigned index, bool enabled, const char *codeStr)
{
static const string validGgLetters = "APZLGITYEOXUKSVN";
static const string validParLetters = "0123456789ABCDEF";
int chl = 0;
string code = codeStr;
std::transform(code.begin(), code.end(), code.begin(), ::toupper);
if(code[4] == ':') {
for(;;) {
string address = code.substr((0 + chl), 4);
string value = code.substr((5 + chl), 2);
// Cheat API moved — ignore for now
if(code[(7 + chl)] != '+') {
return;
}
chl = (chl + 8);
}
}
else if(code[4] == '?' && code[7] == ':') {
for(;;) {
string address = code.substr((0 + chl), 4);
string comparison = code.substr((5 + chl), 2);
string value = code.substr((8 + chl), 2);
// Cheat API moved; ignore custom cheat add here for now.
if(code[(10 + chl)] != '+') {
return;
}
chl = (chl + 11);
}
}
else {
//This is either a GG or PAR code
bool isValidGgCode = true;
bool isValidParCode = true;
for(size_t i = 0; i < 6; i++) {
if(validGgLetters.find(code[i]) == string::npos) {
isValidGgCode = false;
}
}
for(size_t i = 0; i < 8; i++) {
if(validParLetters.find(code[i]) == string::npos) {
isValidParCode = false;
}
}
if(isValidGgCode && code[6] == '+') {
for(;;) {
string code1 = code.substr((0 + chl), 6);
// Cheat API moved; ignore Game Genie add here for now.
if(code[(6 + chl)] != '+') {
return;
}
chl = (chl + 7);
}
}
else if(isValidGgCode && code[8] == '+') {
for(;;) {
string code1 = code.substr((0 + chl), 8);
// Cheat API moved; ignore Game Genie add here for now.
if(code[(8 + chl)] != '+') {
return;
}
chl = (chl + 9);
}
}
else if(isValidGgCode) {
// Cheat API moved; ignore Game Genie add here for now.
}
else if(isValidParCode && code[8] == '+') {
for(;;) {
string code1 = code.substr((0 + chl), 8);
// Cheat API moved; ignore Pro Action Rocky code add here for now.
if(code[(8 + chl)] != '+') {
return;
}
chl = (chl + 9);
}
}
else if(isValidParCode) {
// Cheat API moved; ignore Pro Action Rocky code add here for now.
}
}
}
void update_input_descriptors()
{
if(!_emu || !_emu->GetConsole()) return;
vector<retro_input_descriptor> desc;
auto addDesc = [&desc](unsigned port, unsigned button, const char* name) {
retro_input_descriptor d = { port, RETRO_DEVICE_JOYPAD, 0, button, name };
desc.push_back(d);
};
// Detect the current system type
ConsoleType consoleType = _emu->GetConsole()->GetConsoleType();
// Generic SNES button layout (works for SNES, GBA, etc.)
auto setupSnesButtons = [&addDesc](int port) {
addDesc(port, RETRO_DEVICE_ID_JOYPAD_LEFT, "D-Pad Left");
addDesc(port, RETRO_DEVICE_ID_JOYPAD_UP, "D-Pad Up");
addDesc(port, RETRO_DEVICE_ID_JOYPAD_DOWN, "D-Pad Down");
addDesc(port, RETRO_DEVICE_ID_JOYPAD_RIGHT, "D-Pad Right");
addDesc(port, RETRO_DEVICE_ID_JOYPAD_A, "A");
addDesc(port, RETRO_DEVICE_ID_JOYPAD_B, "B");
addDesc(port, RETRO_DEVICE_ID_JOYPAD_X, "X");
addDesc(port, RETRO_DEVICE_ID_JOYPAD_Y, "Y");
addDesc(port, RETRO_DEVICE_ID_JOYPAD_L, "L");
addDesc(port, RETRO_DEVICE_ID_JOYPAD_R, "R");
addDesc(port, RETRO_DEVICE_ID_JOYPAD_START, "Start");
addDesc(port, RETRO_DEVICE_ID_JOYPAD_SELECT, "Select");
};
// Gameboy button layout
auto setupGameboyButtons = [&addDesc](int port) {
addDesc(port, RETRO_DEVICE_ID_JOYPAD_LEFT, "D-Pad Left");
addDesc(port, RETRO_DEVICE_ID_JOYPAD_UP, "D-Pad Up");
addDesc(port, RETRO_DEVICE_ID_JOYPAD_DOWN, "D-Pad Down");
addDesc(port, RETRO_DEVICE_ID_JOYPAD_RIGHT, "D-Pad Right");
addDesc(port, RETRO_DEVICE_ID_JOYPAD_A, "A");
addDesc(port, RETRO_DEVICE_ID_JOYPAD_B, "B");
addDesc(port, RETRO_DEVICE_ID_JOYPAD_START, "Start");
addDesc(port, RETRO_DEVICE_ID_JOYPAD_SELECT, "Select");
};
// NES button layout (with turbo support)
auto setupNesButtons = [&addDesc](int port) {
addDesc(port, RETRO_DEVICE_ID_JOYPAD_LEFT, "D-Pad Left");
addDesc(port, RETRO_DEVICE_ID_JOYPAD_UP, "D-Pad Up");
addDesc(port, RETRO_DEVICE_ID_JOYPAD_DOWN, "D-Pad Down");
addDesc(port, RETRO_DEVICE_ID_JOYPAD_RIGHT, "D-Pad Right");
addDesc(port, RETRO_DEVICE_ID_JOYPAD_A, "A");
addDesc(port, RETRO_DEVICE_ID_JOYPAD_B, "B");
addDesc(port, RETRO_DEVICE_ID_JOYPAD_X, "Turbo A");
addDesc(port, RETRO_DEVICE_ID_JOYPAD_Y, "Turbo B");
addDesc(port, RETRO_DEVICE_ID_JOYPAD_START, "Start");
addDesc(port, RETRO_DEVICE_ID_JOYPAD_SELECT, "Select");
if(port == 0) {
addDesc(port, RETRO_DEVICE_ID_JOYPAD_L, "(FDS) Insert Next Disk");
addDesc(port, RETRO_DEVICE_ID_JOYPAD_R, "(FDS) Switch Disk Side");
addDesc(port, RETRO_DEVICE_ID_JOYPAD_L2, "(VS) Insert Coin 1");
addDesc(port, RETRO_DEVICE_ID_JOYPAD_R2, "(VS) Insert Coin 2");
addDesc(port, RETRO_DEVICE_ID_JOYPAD_L3, "(Famicom) Microphone (P2)");
}
};
// SMS/GG button layout
auto setupSmsButtons = [&addDesc](int port) {
addDesc(port, RETRO_DEVICE_ID_JOYPAD_LEFT, "D-Pad Left");
addDesc(port, RETRO_DEVICE_ID_JOYPAD_UP, "D-Pad Up");
addDesc(port, RETRO_DEVICE_ID_JOYPAD_DOWN, "D-Pad Down");
addDesc(port, RETRO_DEVICE_ID_JOYPAD_RIGHT, "D-Pad Right");
addDesc(port, RETRO_DEVICE_ID_JOYPAD_A, "Button 1");
addDesc(port, RETRO_DEVICE_ID_JOYPAD_B, "Button 2");
addDesc(port, RETRO_DEVICE_ID_JOYPAD_START, "Start");
addDesc(port, RETRO_DEVICE_ID_JOYPAD_SELECT, "Pause");
};
// PCE/TG16 button layout
auto setupPceButtons = [&addDesc](int port) {
addDesc(port, RETRO_DEVICE_ID_JOYPAD_LEFT, "D-Pad Left");
addDesc(port, RETRO_DEVICE_ID_JOYPAD_UP, "D-Pad Up");
addDesc(port, RETRO_DEVICE_ID_JOYPAD_DOWN, "D-Pad Down");
addDesc(port, RETRO_DEVICE_ID_JOYPAD_RIGHT, "D-Pad Right");
addDesc(port, RETRO_DEVICE_ID_JOYPAD_B, "Button 1");
addDesc(port, RETRO_DEVICE_ID_JOYPAD_A, "Button 2");
addDesc(port, RETRO_DEVICE_ID_JOYPAD_Y, "Button 3");
addDesc(port, RETRO_DEVICE_ID_JOYPAD_X, "Button 4");
addDesc(port, RETRO_DEVICE_ID_JOYPAD_L, "Button 5");
addDesc(port, RETRO_DEVICE_ID_JOYPAD_R, "Button 6");
addDesc(port, RETRO_DEVICE_ID_JOYPAD_SELECT, "Select");
addDesc(port, RETRO_DEVICE_ID_JOYPAD_START, "Run");
};
// Wonderswan button layout
auto setupWsButtons = [&addDesc](int port) {
addDesc(port, RETRO_DEVICE_ID_JOYPAD_LEFT, "D-Pad Left");
addDesc(port, RETRO_DEVICE_ID_JOYPAD_UP, "D-Pad Up");
addDesc(port, RETRO_DEVICE_ID_JOYPAD_DOWN, "D-Pad Down");
addDesc(port, RETRO_DEVICE_ID_JOYPAD_RIGHT, "D-Pad Right");
addDesc(port, RETRO_DEVICE_ID_JOYPAD_A, "A");
addDesc(port, RETRO_DEVICE_ID_JOYPAD_B, "B");
addDesc(port, RETRO_DEVICE_ID_JOYPAD_START, "Start");
};
// GBA button layout
auto setupGbaButtons = [&addDesc](int port) {
addDesc(port, RETRO_DEVICE_ID_JOYPAD_LEFT, "D-Pad Left");
addDesc(port, RETRO_DEVICE_ID_JOYPAD_UP, "D-Pad Up");
addDesc(port, RETRO_DEVICE_ID_JOYPAD_DOWN, "D-Pad Down");
addDesc(port, RETRO_DEVICE_ID_JOYPAD_RIGHT, "D-Pad Right");
addDesc(port, RETRO_DEVICE_ID_JOYPAD_A, "A");
addDesc(port, RETRO_DEVICE_ID_JOYPAD_B, "B");
addDesc(port, RETRO_DEVICE_ID_JOYPAD_L, "L");
addDesc(port, RETRO_DEVICE_ID_JOYPAD_R, "R");
addDesc(port, RETRO_DEVICE_ID_JOYPAD_START, "Start");
addDesc(port, RETRO_DEVICE_ID_JOYPAD_SELECT, "Select");
};
// Set up descriptors based on system type
switch(consoleType) {
case ConsoleType::Snes:
setupSnesButtons(0);
setupSnesButtons(1);
setupSnesButtons(2);
setupSnesButtons(3);
break;
case ConsoleType::Gameboy:
setupGameboyButtons(0);
setupGameboyButtons(1);
break;
case ConsoleType::Nes:
setupNesButtons(0);
setupNesButtons(1);
break;
case ConsoleType::PcEngine:
setupPceButtons(0);
setupPceButtons(1);
setupPceButtons(2);
setupPceButtons(3);
setupPceButtons(4);
break;
case ConsoleType::Sms:
setupSmsButtons(0);
setupSmsButtons(1);
break;
case ConsoleType::Gba:
setupGbaButtons(0);
break;
case ConsoleType::Ws:
setupWsButtons(0);
break;
default:
setupNesButtons(0);
break;
}
retro_input_descriptor end = { 0 };
desc.push_back(end);
// Avoid sending identical input descriptors repeatedly (RetroArch logs each SET_INPUT_DESCRIPTORS call).
// Build a lightweight representation we can compare to the last one and skip the env_cb if unchanged.
struct SimpleDesc { unsigned port; unsigned device; unsigned index; unsigned id; std::string name; };
static std::vector<SimpleDesc> lastDesc;
std::vector<SimpleDesc> curDesc;
curDesc.reserve(desc.size());
for(size_t i = 0; i < desc.size(); ++i) {
const retro_input_descriptor &d = desc[i];
if(d.description == nullptr) break; // end sentinel
curDesc.push_back({ d.port, d.device, d.index, d.id, std::string(d.description) });
}
bool same = (curDesc.size() == lastDesc.size());
if(same) {
for(size_t i = 0; i < curDesc.size(); ++i) {
const SimpleDesc &a = curDesc[i];
const SimpleDesc &b = lastDesc[i];
if(a.port != b.port || a.device != b.device || a.index != b.index || a.id != b.id || a.name != b.name) { same = false; break; }
}
}
if(!same) {
env_cb(RETRO_ENVIRONMENT_SET_INPUT_DESCRIPTORS, desc.data());
lastDesc.swap(curDesc);
}
}
void update_core_controllers()
{
// Map libretro-selected devices into the emulator's settings.
// Guard against being called before a console/emulator exists.
if(!_emu || !_emu->GetConsole()) return;
// Ensure ports 0/1 default to gamepads when still "auto"
if(_inputDevices[0] == DEVICE_AUTO) _inputDevices[0] = DEVICE_GAMEPAD;
if(_inputDevices[1] == DEVICE_AUTO) _inputDevices[1] = DEVICE_GAMEPAD;
// make sure other ports have a sane default
for(int port = 2; port < 5; ++port) {
if(_inputDevices[port] == DEVICE_AUTO) _inputDevices[port] = RETRO_DEVICE_NONE;
}
ConsoleType consoleType = _emu->GetConsole()->GetConsoleType();
// Map port 0/1 controller types based on the system
switch(consoleType) {
case ConsoleType::Snes: {
SnesConfig snesCfg = _emu->GetSettings()->GetSnesConfig();
// Always set controller types based on frontend selection or default to gamepad
snesCfg.Port1.Type = (_inputDevices[0] == DEVICE_GAMEPAD) ? ControllerType::SnesController : ControllerType::None;
snesCfg.Port2.Type = (_inputDevices[1] == DEVICE_GAMEPAD) ? ControllerType::SnesController : ControllerType::None;
_emu->GetSettings()->SetSnesConfig(snesCfg);
break;
}
case ConsoleType::Gameboy: {
GameboyConfig gbCfg = _emu->GetSettings()->GetGameboyConfig();
gbCfg.Controller.Type = (_inputDevices[0] == DEVICE_GAMEPAD) ? ControllerType::GameboyController : ControllerType::None;
_emu->GetSettings()->SetGameboyConfig(gbCfg);
break;
}
case ConsoleType::Gba: {
GbaConfig gbaCfg = _emu->GetSettings()->GetGbaConfig();
gbaCfg.Controller.Type = (_inputDevices[0] == DEVICE_GAMEPAD) ? ControllerType::GbaController : ControllerType::None;
_emu->GetSettings()->SetGbaConfig(gbaCfg);
break;
}
case ConsoleType::PcEngine: {
PcEngineConfig pceCfg = _emu->GetSettings()->GetPcEngineConfig();
pceCfg.Port1.Type = (_inputDevices[0] == DEVICE_GAMEPAD) ? ControllerType::PceController : ControllerType::None;
// Note: PCE has only Port1 but we still support multi-port in libretro
_emu->GetSettings()->SetPcEngineConfig(pceCfg);
break;
}
case ConsoleType::Sms: {
SmsConfig smsCfg = _emu->GetSettings()->GetSmsConfig();
smsCfg.Port1.Type = (_inputDevices[0] == DEVICE_GAMEPAD) ? ControllerType::SmsController : ControllerType::None;
smsCfg.Port2.Type = (_inputDevices[1] == DEVICE_GAMEPAD) ? ControllerType::SmsController : ControllerType::None;
for(int i = 0; i < 4; i++) {
smsCfg.ChannelVolumes[i] = 100;
}
_emu->GetSettings()->SetSmsConfig(smsCfg);
break;
}
case ConsoleType::Ws: {
WsConfig wsCfg = _emu->GetSettings()->GetWsConfig();
wsCfg.ControllerHorizontal.Type = (_inputDevices[0] == DEVICE_GAMEPAD) ? ControllerType::WsController : ControllerType::None;
_emu->GetSettings()->SetWsConfig(wsCfg);
break;
}
case ConsoleType::Nes:
default: {
// Default to NES handling for backward compatibility
NesConfig nesCfg = _emu->GetSettings()->GetNesConfig();
for(int port = 0; port <= 1; ++port) {
ControllerType type = ControllerType::NesController;
switch(_inputDevices[port]) {
case RETRO_DEVICE_NONE: type = ControllerType::None; break;
case DEVICE_GAMEPAD: type = ControllerType::NesController; break;
case DEVICE_ZAPPER: type = ControllerType::NesZapper; break;
case DEVICE_POWERPAD: type = ControllerType::PowerPadSideA; break;
case DEVICE_ARKANOID: type = ControllerType::NesArkanoidController; break;
default: break;
}
if(port == 0) nesCfg.Port1.Type = type;
else if(port == 1) nesCfg.Port2.Type = type;
}
_emu->GetSettings()->SetNesConfig(nesCfg);
break;
}
}
}
void setup_default_key_mappings()
{
// Set up default libretro button mappings for all systems
// Keycode format: (port << 8) | (retroKey + 1)
// This enables input even when no custom key mappings have been configured
if(!_emu || !_emu->GetConsole()) return;
ConsoleType consoleType = _emu->GetConsole()->GetConsoleType();
// Helper lambda to set a KeyMapping button
auto setButton = [](uint16_t& dest, int port, int retroButton) {
dest = (port << 8) | (retroButton + 1);
};
// Helper lambda to set up a full KeyMappingSet with default buttons
auto setupDefaultMapping = [&](KeyMappingSet& keys, int port) {
// Only set up Mapping1 if it doesn't already have keys
if(!keys.Mapping1.HasKeySet()) {
// D-Pad
setButton(keys.Mapping1.Up, port, RETRO_DEVICE_ID_JOYPAD_UP);
setButton(keys.Mapping1.Down, port, RETRO_DEVICE_ID_JOYPAD_DOWN);
setButton(keys.Mapping1.Left, port, RETRO_DEVICE_ID_JOYPAD_LEFT);
setButton(keys.Mapping1.Right, port, RETRO_DEVICE_ID_JOYPAD_RIGHT);
// Action buttons
setButton(keys.Mapping1.A, port, RETRO_DEVICE_ID_JOYPAD_A);
setButton(keys.Mapping1.B, port, RETRO_DEVICE_ID_JOYPAD_B);
setButton(keys.Mapping1.Start, port, RETRO_DEVICE_ID_JOYPAD_START);
setButton(keys.Mapping1.Select, port, RETRO_DEVICE_ID_JOYPAD_SELECT);
// Additional buttons (X, Y, L, R for systems that have them)
setButton(keys.Mapping1.X, port, RETRO_DEVICE_ID_JOYPAD_X);
setButton(keys.Mapping1.Y, port, RETRO_DEVICE_ID_JOYPAD_Y);
setButton(keys.Mapping1.L, port, RETRO_DEVICE_ID_JOYPAD_L);
setButton(keys.Mapping1.R, port, RETRO_DEVICE_ID_JOYPAD_R);
}
};
switch(consoleType) {
case ConsoleType::Snes: {
SnesConfig snesCfg = _emu->GetSettings()->GetSnesConfig();
setupDefaultMapping(snesCfg.Port1.Keys, 0);
setupDefaultMapping(snesCfg.Port2.Keys, 1);
_emu->GetSettings()->SetSnesConfig(snesCfg);
break;
}
case ConsoleType::Gameboy: {
GameboyConfig gbCfg = _emu->GetSettings()->GetGameboyConfig();
setupDefaultMapping(gbCfg.Controller.Keys, 0);
_emu->GetSettings()->SetGameboyConfig(gbCfg);
break;
}
case ConsoleType::Gba: {
GbaConfig gbaCfg = _emu->GetSettings()->GetGbaConfig();
setupDefaultMapping(gbaCfg.Controller.Keys, 0);
_emu->GetSettings()->SetGbaConfig(gbaCfg);
break;
}
case ConsoleType::PcEngine: {
PcEngineConfig pceCfg = _emu->GetSettings()->GetPcEngineConfig();
setupDefaultMapping(pceCfg.Port1.Keys, 0);
setupDefaultMapping(pceCfg.Port1.Keys, 1); // Note: PcEngine only has Port1, treating as multi-port
_emu->GetSettings()->SetPcEngineConfig(pceCfg);
break;
}
case ConsoleType::Sms: {
SmsConfig smsCfg = _emu->GetSettings()->GetSmsConfig();
setupDefaultMapping(smsCfg.Port1.Keys, 0);
setupDefaultMapping(smsCfg.Port2.Keys, 1);
_emu->GetSettings()->SetSmsConfig(smsCfg);
break;
}
case ConsoleType::Ws: {
WsConfig wsCfg = _emu->GetSettings()->GetWsConfig();
setupDefaultMapping(wsCfg.ControllerHorizontal.Keys, 0);
_emu->GetSettings()->SetWsConfig(wsCfg);
break;
}
case ConsoleType::Nes:
default: {
// For NES, set up default keys if not already configured
NesConfig nesCfg = _emu->GetSettings()->GetNesConfig();
setupDefaultMapping(nesCfg.Port1.Keys, 0);
setupDefaultMapping(nesCfg.Port2.Keys, 1);
_emu->GetSettings()->SetNesConfig(nesCfg);
break;
}
}
}
void retro_set_memory_maps()
{
// The console/Memory APIs were refactored. Provide an empty memory map for now.
retro_memory_map memoryMap = {};
memoryMap.descriptors = nullptr;
memoryMap.num_descriptors = 0;
env_cb(RETRO_ENVIRONMENT_SET_MEMORY_MAPS, &memoryMap);
/* //Expose internal RAM and work/save RAM for retroachievements
retro_memory_descriptor descriptors[256] = {};
retro_memory_map memoryMap = {};
int count = 0;
for(int i = 0; i <= 0xFFFF; i += 0x100) {
uint8_t* ram = _console->GetRamBuffer(i);
if(ram) {
descriptors[count].ptr = ram;
descriptors[count].start = i;
descriptors[count].len = 0x100;
count++;
}
}
memoryMap.descriptors = descriptors;
memoryMap.num_descriptors = count;
env_cb(RETRO_ENVIRONMENT_SET_MEMORY_MAPS, &memoryMap);
*/ }
RETRO_API void retro_set_controller_port_device(unsigned port, unsigned device)
{
if(port < 5 && _inputDevices[port] != device) {
_inputDevices[port] = device;
update_core_controllers();
update_input_descriptors();
}
}
RETRO_API bool retro_load_game(const struct retro_game_info *game)
{
logSgbDebugf("retro_load_game called: path=%s", game && game->path ? game->path : "(null)");
char *saveFolder;
char *systemFolder;
if(!env_cb(RETRO_ENVIRONMENT_GET_SYSTEM_DIRECTORY, &systemFolder) || !systemFolder)
return false;
if(!env_cb(RETRO_ENVIRONMENT_GET_SAVE_DIRECTORY, &saveFolder)) {
logMessage(RETRO_LOG_ERROR, "Could not find save directory.\n");
}
enum retro_pixel_format fmt = RETRO_PIXEL_FORMAT_XRGB8888;
if(!env_cb(RETRO_ENVIRONMENT_SET_PIXEL_FORMAT, &fmt)) {
logMessage(RETRO_LOG_ERROR, "XRGB8888 is not supported.\n");
return false;
}
//Expect the following structure:
// /system/disksys.rom
// /system/HdPacks/*
// /system/<BIOS files>
// /saves/*.sav
FolderUtilities::SetHomeFolder(systemFolder);
// SetFolderOverrides signature expects 4 strings (save, savestate, screenshot, firmware).
// Point firmware lookups at the system directory root.
FolderUtilities::SetFolderOverrides(saveFolder, std::string(""), std::string(""), string(systemFolder));
update_settings();
// Controller/Settings API changed; skip initial controller setup here
//Plug in 2 standard controllers by default, game database will switch the controller types for recognized games
/* _console->GetSettings()->SetMasterVolume(10.0);
_console->GetSettings()->SetControllerType(0, ControllerType::StandardController);
_console->GetSettings()->SetControllerType(1, ControllerType::StandardController);
_console->GetSettings()->SetControllerType(2, ControllerType::None);
_console->GetSettings()->SetControllerType(3, ControllerType::None);
*/
// Attempt to fetch extended game info
const struct retro_game_info_ext *gameExt = NULL;
const void *gameData = NULL;
size_t gameSize = 0;
string gamePath("");
if (env_cb(RETRO_ENVIRONMENT_GET_GAME_INFO_EXT, &gameExt)) {
gameData = gameExt->data;
gameSize = gameExt->size;
if (gameExt->file_in_archive) {
// We don't have a 'physical' file in this
// case, but the core still needs a filename
// in order to detect associated content
// (i.e. HdPacks). We therefore fake it, using
// the content directory, canonical content
// name, and content file extension
#if defined(_WIN32)
char slash = '\\';
#else
char slash = '/';
#endif
gamePath = string(gameExt->dir) +
string(1, slash) +
string(gameExt->name) +
"." +
string(gameExt->ext);
} else {
gamePath = gameExt->full_path;
}
} else {
// No extended game info; all we have is the
// content fullpath from the retro_game_info
// struct
gamePath = game->path;
}
/* // Load content
VirtualFile romData(gameData, gameSize, gamePath);
bool result = _console->Initialize(romData);
if(result) {
//Set default dipswitches for some VS System games
switch(_console->GetRomInfo().Hash.PrgCrc32) {
case 0x8850924B: _console->GetSettings()->SetDipSwitches(32); break; //VS Tetris
case 0xE1AA8214: _console->GetSettings()->SetDipSwitches(32); break; //StarLuster
default: _console->GetSettings()->SetDipSwitches(0); break;
}
update_core_controllers();
update_input_descriptors();
//Savestates in Mesen may change size over time
//Retroarch doesn't like this for netplay or rewinding - it requires the states to always be the exact same size
//So we need to send a large enough size to Retroarch to ensure Mesen's state will always fit within that buffer.
std::stringstream ss;
_console->GetSaveStateManager()->SaveState(ss);
//Round up to the next 1kb multiple
_saveStateSize = ((ss.str().size() * 2) + 0x400) & ~0x3FF;
retro_set_memory_maps();
}
return result;
*/
// Build a VirtualFile for the ROM (either from memory or from a path)
VirtualFile romData;
if(gameData && gameSize > 0) {
romData = VirtualFile(gameData, gameSize, gamePath);
} else {
romData = VirtualFile(gamePath);
}
// Set HD pack configuration BEFORE loading ROM (LoadHdPack checks this during ROM load)
{
NesConfig nesCfg = _emu->GetSettings()->GetNesConfig();
nesCfg.EnableHdPacks = _hdPacksEnabled;
_emu->GetSettings()->SetNesConfig(nesCfg);
}
// Attempt to load the ROM via the Emulator API
bool result = false;
string tempPceFirmwarePath;
string tempPceFirmwareBackup;
if(romData.GetFileExtension() == ".cue") {
char *systemFolder;
if(env_cb(RETRO_ENVIRONMENT_GET_SYSTEM_DIRECTORY, &systemFolder) && systemFolder) {
if(CreatePceFirmwareStub(string(systemFolder), tempPceFirmwarePath, tempPceFirmwareBackup)) {
fprintf(stderr, "[libretro] Created temporary PCE firmware stub: %s\n", tempPceFirmwarePath.c_str());
fflush(stderr);
}
}
}
try {
// Do not instruct the emulator to stop any existing ROM here - letting it avoid
// the Stop() path which can trigger complex shutdown behavior inside a libretro host.
fprintf(stderr, "[libretro] Attempting to load ROM: %s\n", gamePath.c_str());
fprintf(stderr, "[libretro] Path: %s\n", romData.GetFilePath().c_str());
fprintf(stderr, "[libretro] Folder: %s\n", romData.GetFolderPath().c_str());
fprintf(stderr, "[libretro] Extension: %s\n", romData.GetFileExtension().c_str());
fprintf(stderr, "[libretro] From memory: %s\n", (gameData && gameSize > 0) ? "yes" : "no");
fflush(stderr);
result = _emu->LoadRom(romData, VirtualFile(), false, false);
fprintf(stderr, "[libretro] LoadRom returned: %s\n", result ? "success" : "failure");
fflush(stderr);
} catch(const std::exception& e) {
fprintf(stderr, "[libretro] LoadRom threw exception: %s\n", e.what());
fflush(stderr);
result = false;
} catch(...) {
fprintf(stderr, "[libretro] LoadRom threw unknown exception\n");
fflush(stderr);
result = false;
}
if(!tempPceFirmwarePath.empty()) {
RestorePceFirmwareStub(tempPceFirmwarePath, tempPceFirmwareBackup);
fprintf(stderr, "[libretro] Restored temporary PCE firmware stub: %s\n", tempPceFirmwarePath.c_str());
fflush(stderr);
}
if(result) {
// Update the console shared_ptr now that a ROM is loaded
// Use the generic IConsole interface to support all system types
auto consoleIf = _emu->GetConsole();
_console = consoleIf;
// Disable frame blending for libretro - we want raw frames
// Post-processing should happen in the frontend
ConsoleType type = _console->GetConsoleType();
switch(type) {
case ConsoleType::Snes: {
SnesConfig cfg = _emu->GetSettings()->GetSnesConfig();
cfg.HighResBlendMode = SnesHighResBlendMode::None;
_emu->GetSettings()->SetSnesConfig(cfg);
break;
}
case ConsoleType::Gameboy: {
GameboyConfig cfg = _emu->GetSettings()->GetGameboyConfig();
cfg.BlendFrames = false;
_emu->GetSettings()->SetGameboyConfig(cfg);
break;
}
case ConsoleType::Gba: {
GbaConfig cfg = _emu->GetSettings()->GetGbaConfig();
cfg.BlendFrames = false;
_emu->GetSettings()->SetGbaConfig(cfg);
break;
}
case ConsoleType::Sms: {
SmsConfig cfg = _emu->GetSettings()->GetSmsConfig();
cfg.GgBlendFrames = false;
_emu->GetSettings()->SetSmsConfig(cfg);
break;
}
case ConsoleType::PcEngine: {
// Initialize PCE config with default palette (RGB333)
// PCE uses a 9-bit color space (RGB333 - 3 bits each for R, G, B)
PcEngineConfig cfg = _emu->GetSettings()->GetPcEngineConfig();
// Generate default RGB333 palette if not already set
if(cfg.Palette[0] == 0) { // If palette is all zeros, initialize it
for(int rgb333 = 0; rgb333 < 512; rgb333++) {
// Extract 3-bit R, G, B components and scale to 8-bit
// Values for red and green channels are swapped, but it
// works, so whatever. TODO/FIXME
uint8_t r = ((rgb333 >> 3) & 0x7) * 255 / 7; // bits 8,7,6
uint8_t g = ((rgb333 >> 6) & 0x7) * 255 / 7; // bits 5,4,3
uint8_t b = ((rgb333 >> 0) & 0x7) * 255 / 7; // bits 2,1,0
cfg.Palette[rgb333] = 0xFF000000 | (r << 16) | (g << 8) | b;
}
}
_emu->GetSettings()->SetPcEngineConfig(cfg);
break;
}
default:
break;
}
// Inform the LibretroKeyManager of the concrete console/emulator so it can
// safely mark itself ready to be polled and access emulator data (mouse pos, etc.).
if(_keyManager) {
_keyManager->SetConsole(consoleIf, _emu.get());
}
// Initialize audio settings to enable sound output
// Ensure audio is enabled and channel volumes are set
{
AudioConfig audioCfg = _emu->GetSettings()->GetAudioConfig();
audioCfg.EnableAudio = true;
audioCfg.MasterVolume = 100;
_emu->GetSettings()->SetAudioConfig(audioCfg);
NesConfig nesCfg = _emu->GetSettings()->GetNesConfig();
// Initialize all channel volumes to 100 (full volume) if they're zero
for(size_t i = 0; i < 11; ++i) {
if(nesCfg.ChannelVolumes[i] == 0) {
nesCfg.ChannelVolumes[i] = 100;
}
// Initialize panning to center (50) if zero
if(nesCfg.ChannelPanning[i] == 0) {
nesCfg.ChannelPanning[i] = 50;
}
}
_emu->GetSettings()->SetNesConfig(nesCfg);
}
// Allow the game/db-specific controller initialization to run
update_core_controllers();
// Set up default libretro button mappings for systems that don't have custom key configs
setup_default_key_mappings();
// Re-run controller initialization with the new key mappings
update_core_controllers();
update_input_descriptors();
// Compute a safe save state size to report to the frontend
std::stringstream ss;
_emu->GetSaveStateManager()->SaveState(ss);
_saveStateSize = ((ss.str().size() * 2) + 0x400) & ~0x3FF;
// Update memory maps (still a stubbed implementation for now)
retro_set_memory_maps();
// Register the libretro audio device now that the emulator is initialized and consoles are ready
if(_audioDevice && _emu && _emu->GetSoundMixer()) {
_emu->GetSoundMixer()->RegisterAudioDevice(_audioDevice.get());
}
// Update geometry if HD packs are loaded (they may change the resolution)
// HD packs are NES-specific, so only check for NES consoles
if(_console && _console->GetConsoleType() == ConsoleType::Nes) {
auto nesConsole = std::dynamic_pointer_cast<NesConsole>(_console);
if(nesConsole && nesConsole->GetHdData()) {
retro_system_av_info avInfo = {};
retro_get_system_av_info(&avInfo);
env_cb(RETRO_ENVIRONMENT_SET_GEOMETRY, &avInfo);
}
}
// Forward any saved input callbacks into the key manager now that console/key manager are initialized.
if(_keyManager) {
if(_savedGetInputState) _keyManager->SetGetInputState(_savedGetInputState);
if(_savedPollInput) _keyManager->SetPollInput(_savedPollInput);
// Re-check bitmask support
if (env_cb(RETRO_ENVIRONMENT_GET_INPUT_BITMASKS, NULL))
_keyManager->SetSupportsInputBitmasks(true);
}
// Diagnostic probe: call saved callbacks once from this thread and log their values.
// This uses the shared probe helper so we don't duplicate the implementation.
if(_savedPollInput || _savedGetInputState) {
// forward-declare the shared probe helper (defined later in this file)
if(getenv("MESEN_LIBRETRO_VERBOSE_INPUT")) {
void libretro_probe_inputs(const char* tag);
libretro_probe_inputs("retro_load_game");
}
}
} else {
logMessage(RETRO_LOG_ERROR, "retro_load_game: Failed to load ROM via Emulator::LoadRom.\n");
_saveStateSize = 0;
}
return result;
}
static constexpr unsigned SubsystemId_Sgb = 2;
static bool isSupportedSubsystem(unsigned game_type)
{
return game_type == SubsystemId_Sgb; // Super Game Boy subsystem
}
static bool isGameboyRom(const struct retro_game_info* info)
{
if(!info) {
return false;
}
if(info->path) {
string path = info->path;
transform(path.begin(), path.end(), path.begin(), ::tolower);
if(path.find(".gb") != string::npos || path.find(".gbc") != string::npos || path.find(".gbx") != string::npos) {
return true;
}
}
return false;
}
static bool isSgbFirmwareRom(const struct retro_game_info* info, bool& useSgb2)
{
if(!info) {
return false;
}
logSgbDebugf("isSgbFirmwareRom: info=%p data=%p size=%zu path=%s", (const void*)info, info->data, info->size, info->path ? info->path : "(null)");
auto checkSize = [&](size_t size) {
if(size == 0x40000) {
useSgb2 = false;
return true;
}
if(size == 0x80000) {
useSgb2 = true;
return true;
}
return false;
};
if(info->data && info->size > 0) {
return checkSize(info->size);
}
if(info->path) {
string path = info->path;
transform(path.begin(), path.end(), path.begin(), ::tolower);
if(path.find(".sfc") != string::npos || path.find(".smc") != string::npos) {
if(info->size > 0) {
return checkSize(info->size);
}
VirtualFile firmwareFile(info->path);
if(firmwareFile.IsValid()) {
return checkSize(firmwareFile.GetSize());
}
}
}
return false;
}
static bool writeGameInfoToFile(const struct retro_game_info* info, const string& outputPath)
{
if(!info || outputPath.empty()) {
return false;
}
vector<uint8_t> sourceData;
if(info->data && info->size > 0) {
sourceData.assign((const uint8_t*)info->data, (const uint8_t*)info->data + info->size);
} else if(info->path) {
VirtualFile sourceFile(info->path);
if(!sourceFile.IsValid()) {
return false;
}
if(!sourceFile.ReadFile(sourceData)) {
return false;
}
} else {
return false;
}
utf8::ofstream output(outputPath, std::ios::binary | std::ios::trunc);
if(!output) {
return false;
}
output.write((const char*)sourceData.data(), sourceData.size());
return output.good();
}
static bool copySgbFirmwareToSystem(const struct retro_game_info* info, string& createdFirmwarePath, string& backupFirmwarePath)
{
if(!info) {
return false;
}
bool useSgb2 = false;
if(!isSgbFirmwareRom(info, useSgb2)) {
logSgbDebugf("copySgbFirmwareToSystem: info is not recognized as SGB firmware");
return false;
}
string firmwareFilename = useSgb2 ? "SGB2.sfc" : "SGB1.sfc";
char *systemFolder;
if(!env_cb(RETRO_ENVIRONMENT_GET_SYSTEM_DIRECTORY, &systemFolder) || !systemFolder) {
logSgbDebugf("copySgbFirmwareToSystem: RETRO_ENVIRONMENT_GET_SYSTEM_DIRECTORY failed");
return false;
}
string firmwarePath = FolderUtilities::CombinePath(string(systemFolder), firmwareFilename);
logSgbDebugf("copySgbFirmwareToSystem: system folder=%s firmware=%s", systemFolder, firmwarePath.c_str());
createdFirmwarePath.clear();
backupFirmwarePath.clear();
{
utf8::ifstream existing(firmwarePath, std::ios::binary);
if(existing.good()) {
backupFirmwarePath = firmwarePath + ".libretro.bak";
int backupIndex = 1;
while(utf8::ifstream(backupFirmwarePath, std::ios::binary).good()) {
backupFirmwarePath = firmwarePath + ".libretro.bak" + std::to_string(backupIndex);
backupIndex++;
}
if(!VfsIo::Rename(firmwarePath, backupFirmwarePath)) {
return false;
}
}
}
if(!writeGameInfoToFile(info, firmwarePath)) {
logSgbDebugf("copySgbFirmwareToSystem: failed to write custom firmware to %s", firmwarePath.c_str());
if(!backupFirmwarePath.empty()) {
VfsIo::Rename(backupFirmwarePath, firmwarePath);
}
return false;
}
createdFirmwarePath = firmwarePath;
logSgbDebugf("copySgbFirmwareToSystem: wrote custom firmware to %s", firmwarePath.c_str());
return true;
}
static void restoreSgbFirmware(const string& firmwarePath, const string& backupFirmwarePath)
{
if(firmwarePath.empty()) {
return;
}
if(!backupFirmwarePath.empty()) {
VfsIo::Rename(backupFirmwarePath, firmwarePath);
} else {
VfsIo::Remove(firmwarePath);
}
}
static bool loadSubsystemGame(unsigned game_type, const struct retro_game_info *info, size_t num_info)
{
logSgbDebugf("loadSubsystemGame called: game_type=%u num_info=%zu", game_type, num_info);
if(!isSupportedSubsystem(game_type) || !info || num_info == 0) {
logSgbDebugf("loadSubsystemGame: unsupported subsystem or invalid info");
return false;
}
if(game_type == SubsystemId_Sgb) {
logSgbDebugf("retro_load_game_special: starting SGB subsystem load");
logSgbDebugf("loadSubsystemGame: game_type=%u num_info=%zu", game_type, num_info);
if(info[0].path) logSgbDebugf(" gbInfo.path=%s size=%zu", info[0].path, info[0].size);
if(num_info > 1 && info[1].path) logSgbDebugf(" sgbInfo.path=%s size=%zu", info[1].path, info[1].size);
const struct retro_game_info* gbInfo = &info[0];
const struct retro_game_info* sgbInfo = (num_info > 1 ? &info[1] : nullptr);
if(!gbInfo || !isGameboyRom(gbInfo)) {
logMessage(RETRO_LOG_ERROR, "retro_load_game_special: Super Game Boy load requires a Game Boy ROM as the first entry.");
return false;
}
string firmwarePath;
string backupPath;
bool customFirmwareInstalled = false;
if(sgbInfo) {
bool useSgb2 = false;
if(isSgbFirmwareRom(sgbInfo, useSgb2)) {
customFirmwareInstalled = copySgbFirmwareToSystem(sgbInfo, firmwarePath, backupPath);
if(customFirmwareInstalled) {
logSgbDebugf("Installed custom SGB firmware: %s", firmwarePath.c_str());
} else {
logSgbDebugf("copySgbFirmwareToSystem returned false for firmware path %s", sgbInfo->path ? sgbInfo->path : "(null)");
}
} else {
logMessage(RETRO_LOG_INFO, "retro_load_game_special: Second entry is not valid SGB firmware; falling back to existing system firmware if available.");
}
}
// Tell the emulator to allow SGB for the next Gameboy console that is created
if(_emu) _emu->SetAllowSgbForNextLoad(true);
// Temporarily prefer SGB model when selecting the Gameboy model so SGB will be chosen
GameboyConfig _libretro_prevGbCfg;
bool _libretro_havePrevGbCfg = false;
if(_emu) {
_libretro_prevGbCfg = _emu->GetSettings()->GetGameboyConfig();
_libretro_havePrevGbCfg = true;
GameboyConfig tmpGbCfg = _libretro_prevGbCfg;
tmpGbCfg.Model = GameboyModel::AutoFavorSgb;
_emu->GetSettings()->SetGameboyConfig(tmpGbCfg);
}
bool result = retro_load_game(gbInfo);
logSgbDebugf("retro_load_game returned %s for GB ROM %s", result ? "success" : "failure", gbInfo->path ? gbInfo->path : "(null)");
// Restore previous Gameboy config
if(_emu && _libretro_havePrevGbCfg) {
_emu->GetSettings()->SetGameboyConfig(_libretro_prevGbCfg);
}
if(customFirmwareInstalled) {
restoreSgbFirmware(firmwarePath, backupPath);
logSgbDebugf("Restored SGB firmware %s", firmwarePath.c_str());
}
return result;
}
return false;
}
RETRO_API bool retro_load_game_special(unsigned game_type, const struct retro_game_info *info, size_t num_info)
{
return loadSubsystemGame(game_type, info, num_info);
}
RETRO_API void retro_unload_game()
{
}
RETRO_API unsigned retro_get_region()
{
/* NesModel model = _console->GetModel();
return model == NesModel::NTSC ? RETRO_REGION_NTSC : RETRO_REGION_PAL;
*/
// The NesConsole / Emulator APIs were refactored. Return NTSC for now.
return RETRO_REGION_NTSC;
}
RETRO_API void retro_get_system_info(struct retro_system_info *info)
{
// _mesenVersion = EmuSettings::GetVersionString();
/*
// Set library name based on loaded console. This pushes configs into
// separate folders for each sub-core
static std::string libraryName = "Mesen2";
if(_console) {
ConsoleType type = _console->GetConsoleType();
switch(type) {
case ConsoleType::Nes: libraryName = "Mesen2-NES"; break;
case ConsoleType::Snes: libraryName = "Mesen2-SNES"; break;
case ConsoleType::Gameboy: libraryName = "Mesen2-Gameboy"; break;
case ConsoleType::Gba: libraryName = "Mesen2-GBA"; break;
case ConsoleType::PcEngine: libraryName = "Mesen2-PCEngine"; break;
case ConsoleType::Sms: libraryName = "Mesen2-SMS"; break;
case ConsoleType::Ws: libraryName = "Mesen2-Wonderswan"; break;
default: libraryName = "Mesen2"; break;
}
}
*/
info->library_name = "Mesen2";
info->library_version = "2.0.0";
info->need_fullpath = true;
// Set valid extensions based on loaded console
static std::string validExtensions;
if(_console) {
ConsoleType type = _console->GetConsoleType();
switch(type) {
case ConsoleType::Nes:
validExtensions = "nes|fds|unf|unif";
break;
case ConsoleType::Snes:
validExtensions = "sfc|smc";
break;
case ConsoleType::Gameboy:
validExtensions = "gb|gbc";
break;
case ConsoleType::Gba:
validExtensions = "gba";
break;
case ConsoleType::PcEngine:
validExtensions = "pce|sgx|cue";
break;
case ConsoleType::Sms:
validExtensions = "sms|gg";
break;
case ConsoleType::Ws:
validExtensions = "ws|wsc";
break;
default:
validExtensions = "nes|fds|unf|unif|sfc|smc|gb|gbc|gba|pce|sgx|sms|gg|ws|wsc";
break;
}
} else {
// No console loaded yet, use all supported extensions
validExtensions = "nes|fds|unf|unif|sfc|smc|gb|gbc|gba|pce|sgx|cue|sms|gg|ws|wsc";
}
info->valid_extensions = validExtensions.c_str();
info->block_extract = false;
}
RETRO_API void retro_get_system_av_info(struct retro_system_av_info *info)
{
memset(info, 0, sizeof(*info));
uint32_t width = 256;
uint32_t height = 240;
// Get actual filtered frame size if available
if(_emu && _emu->GetVideoDecoder()) {
FrameInfo frameSize = _emu->GetVideoDecoder()->GetFrameInfo();
width = frameSize.Width;
height = frameSize.Height;
}
// Check if HD packs are loaded and apply additional scaling
// HD packs are NES-specific
uint32_t hscale = 1;
uint32_t vscale = 1;
if(_console && _console->GetConsoleType() == ConsoleType::Nes) {
auto nesConsole = std::dynamic_pointer_cast<NesConsole>(_console);
if(nesConsole) {
auto hdData = nesConsole->GetHdData().lock();
if(hdData) {
hscale = hdData->Scale;
vscale = hdData->Scale;
}
}
}
// Apply HD scale to final dimensions
width *= hscale;
height *= vscale;
info->geometry.base_width = width;
info->geometry.base_height = height;
// TODO/FIXME: set these to something bigger when HD packs are implemented
info->geometry.max_width = 512;//256 * 8 * 4; // generous max (8x scale + 4x HD)
info->geometry.max_height = 480;//240 * 8 * 4;
float system_ar;
if(_console) {
ConsoleType type = _console->GetConsoleType();
switch(type) {
case ConsoleType::Nes: system_ar = 1.306; break;
case ConsoleType::Snes: system_ar = 64.0f / 49.0f; break;
case ConsoleType::Gameboy: system_ar = 10.0f / 9.0f; break;
case ConsoleType::Gba: system_ar = 3.0f / 2.0f; break;
case ConsoleType::PcEngine: system_ar = 4.0f / 3.0f; break;
case ConsoleType::Sms: system_ar = 4.0f / 3.0f; break;
case ConsoleType::Ws: system_ar = 14.0f / 9.0f; break;
default: system_ar = 4.0f / 3.0f; break;
}
}
info->geometry.aspect_ratio = system_ar;
// Get FPS from console, or use default
double fps = 60.0988; // NES NTSC default
if(_console) {
fps = _console->GetFps();
}
info->timing.fps = fps;
info->timing.sample_rate = 44100.0;
}
RETRO_API void *retro_get_memory_data(unsigned id)
{
// Memory access is NES-specific for now
if(!_console || _console->GetConsoleType() != ConsoleType::Nes) {
return nullptr;
}
auto nesConsole = std::dynamic_pointer_cast<NesConsole>(_console);
if(!nesConsole) return nullptr;
BaseMapper* mapper = nesConsole->GetMapper();
switch(id) {
case RETRO_MEMORY_SAVE_RAM:
// Save-ram accessor moved/hidden in BaseMapper; return nullptr until mapped to new API.
(void)mapper;
return nullptr;
case RETRO_MEMORY_SYSTEM_RAM:
// Use the renamed GetInternalRam() if available on NesMemoryManager.
if(nesConsole->GetMemoryManager()) {
return nesConsole->GetMemoryManager()->GetInternalRam();
}
return nullptr;
}
return nullptr;
}
RETRO_API size_t retro_get_memory_size(unsigned id)
{
switch(id) {
case RETRO_MEMORY_SAVE_RAM: //return mapper->GetMemorySize(DebugMemoryType::SaveRam);
// Mapper API changed; save-RAM access moved. Return 0 for now.
// TODO: replace with mapper->GetSaveRam() equivalent when API is available.
return 0;
case RETRO_MEMORY_SYSTEM_RAM: //return MemoryManager::InternalRAMSize;
// Memory manager API renamed to GetInternalRam()
// Use the new method if available; otherwise return 0.
return 0;
}
return 0;
}
}
Reference in new issue View Git Blame Copy Permalink