SDL_libretro/_s_d_l__libretro_8h_source.html

#ifndef SDL_LIBRETRO_H

#define SDL_LIBRETRO_H


#include <SDL3/SDL.h>

#include "libretro.h"


#define SDL_LIBRETRO_MAJOR_VERSION 0


#define SDL_LIBRETRO_MINOR_VERSION 1


#define SDL_LIBRETRO_MICRO_VERSION 0


#define SDL_LIBRETRO_VERSION SDL_VERSIONNUM(SDL_LIBRETRO_MAJOR_VERSION, SDL_LIBRETRO_MINOR_VERSION, SDL_LIBRETRO_MICRO_VERSION)


#define SDL_LIBRETRO_VERSION_ATLEAST(X, Y, Z) (SDL_LIBRETRO_VERSION >= SDL_VERSIONNUM(X, Y, Z))


typedef struct SDL_Libretro SDL_Libretro;


typedef enum SDL_LibretroFitMode {

    SDL_LIBRETRO_FIT_FIRST = 0,

    SDL_LIBRETRO_FIT_ASPECT = 0,

    SDL_LIBRETRO_FIT_INTEGER = 1,

    SDL_LIBRETRO_FIT_STRETCH = 2,

    SDL_LIBRETRO_FIT_COUNT = 3

} SDL_LibretroFitMode;


typedef enum SDL_LibretroAnalogToDigital {

    SDL_LIBRETRO_ANALOG_TO_DIGITAL_NONE = 0,

    SDL_LIBRETRO_ANALOG_TO_DIGITAL_LEFT = 1,

    SDL_LIBRETRO_ANALOG_TO_DIGITAL_RIGHT = 2,

    SDL_LIBRETRO_ANALOG_TO_DIGITAL_COUNT = 3

} SDL_LibretroAnalogToDigital;


#ifdef __cplusplus

extern "C" {

#endif


// Libretro Instance


SDL_Libretro* SDL_Libretro_Create(void);

void SDL_Libretro_Destroy(SDL_Libretro* lr);

int SDL_Libretro_GetVersion(void);


// Directories


bool SDL_Libretro_SetCoreDirectory(SDL_Libretro* lr, const char* path);

bool SDL_Libretro_SetSaveDirectory(SDL_Libretro* lr, const char* path);

bool SDL_Libretro_SetSystemDirectory(SDL_Libretro* lr, const char* path);

bool SDL_Libretro_SetCoreAssetsDirectory(SDL_Libretro* lr, const char* path);

const char* SDL_Libretro_GetCoreDirectory(SDL_Libretro* lr);

const char* SDL_Libretro_GetSaveDirectory(SDL_Libretro* lr);

const char* SDL_Libretro_GetSystemDirectory(SDL_Libretro* lr);

const char* SDL_Libretro_GetCoreAssetsDirectory(SDL_Libretro* lr);

bool SDL_Libretro_SetUsername(SDL_Libretro* lr, const char* username);

const char* SDL_Libretro_GetUsername(SDL_Libretro* lr);


void SDL_Libretro_SetLanguage(SDL_Libretro* lr, int language);


int SDL_Libretro_GetLanguage(const SDL_Libretro* lr);


// Config


bool SDL_Libretro_InitConfig(SDL_Libretro* lr, const char* org, const char* app);

bool SDL_Libretro_InitConfigFile(SDL_Libretro* lr, const char* file);


// Core


bool SDL_Libretro_LoadCore(SDL_Libretro* lr, const char* core);

void SDL_Libretro_UnloadCore(SDL_Libretro* lr);

bool SDL_Libretro_IsCoreReady(const SDL_Libretro* lr);

bool SDL_Libretro_ShouldQuit(const SDL_Libretro* lr);


// Game


bool SDL_Libretro_LoadGame(SDL_Libretro* lr, const char* gamePath);

bool SDL_Libretro_LoadGame_IO(SDL_Libretro* lr, SDL_IOStream* src, const char* path, bool closeio);

void SDL_Libretro_UnloadGame(SDL_Libretro* lr);

bool SDL_Libretro_IsGameReady(const SDL_Libretro* lr);

bool SDL_Libretro_IsGameRequired(const SDL_Libretro* lr);

bool SDL_Libretro_Reset(SDL_Libretro* lr);

void SDL_Libretro_Update(SDL_Libretro* lr);


// Video


bool SDL_Libretro_SetRenderer(SDL_Libretro* lr, SDL_Renderer* renderer);

SDL_Renderer* SDL_Libretro_GetRenderer(const SDL_Libretro* lr);

SDL_Texture* SDL_Libretro_GetTexture(const SDL_Libretro* lr);

SDL_Surface* SDL_Libretro_CreateSurface(const SDL_Libretro* lr);

bool SDL_Libretro_SaveScreenshot(const SDL_Libretro* lr, const char* path);

bool SDL_Libretro_Render(SDL_Libretro* lr, SDL_Renderer* renderer, const SDL_FRect* dstRect);

void SDL_Libretro_GetSize(const SDL_Libretro* lr, int* w, int* h);

float SDL_Libretro_GetAspectRatio(const SDL_Libretro* lr);

double SDL_Libretro_GetFPS(const SDL_Libretro* lr);

int SDL_Libretro_GetRotation(const SDL_Libretro* lr);

bool SDL_Libretro_SetFitMode(SDL_Libretro* lr, SDL_LibretroFitMode mode);

SDL_LibretroFitMode SDL_Libretro_GetFitMode(const SDL_Libretro* lr);

bool SDL_Libretro_SetScaleMode(SDL_Libretro* lr, SDL_ScaleMode mode);

SDL_ScaleMode SDL_Libretro_GetScaleMode(const SDL_Libretro* lr);


// Audio


void SDL_Libretro_SetVolume(SDL_Libretro* lr, float volume);

float SDL_Libretro_GetVolume(const SDL_Libretro* lr);

void SDL_Libretro_SetSpeed(SDL_Libretro* lr, float speed);

float SDL_Libretro_GetSpeed(const SDL_Libretro* lr);

bool SDL_Libretro_IsFastforwardOverrideActive(const SDL_Libretro* lr);

void SDL_Libretro_SetAudioLatency(SDL_Libretro* lr, unsigned latencyMs);

unsigned SDL_Libretro_GetAudioLatency(const SDL_Libretro* lr);

double SDL_Libretro_GetSampleRate(const SDL_Libretro* lr);


// Input


void SDL_Libretro_HandleEvent(SDL_Libretro* lr, const SDL_Event* event);

bool SDL_Libretro_SetPortDevice(SDL_Libretro* lr, unsigned port, unsigned device);

unsigned SDL_Libretro_GetPortDevice(const SDL_Libretro* lr, unsigned port);

void SDL_Libretro_SetKeyboardMapping(SDL_Libretro* lr, int retroButton, SDL_Scancode scancode);

void SDL_Libretro_SetGamepadMapping(SDL_Libretro* lr, unsigned port, int retroButton, SDL_GamepadButton button);

void SDL_Libretro_SetAnalogToDigital(SDL_Libretro* lr, unsigned port, SDL_LibretroAnalogToDigital stick);

SDL_LibretroAnalogToDigital SDL_Libretro_GetAnalogToDigital(const SDL_Libretro* lr, unsigned port);

void SDL_Libretro_SetMousePort(SDL_Libretro* lr, unsigned port);

unsigned SDL_Libretro_GetMousePort(const SDL_Libretro* lr);

void SDL_Libretro_SetVirtualButton(SDL_Libretro* lr, unsigned port, int button, bool pressed);

unsigned SDL_Libretro_GetInputDescriptorCount(const SDL_Libretro* lr);

bool SDL_Libretro_GetInputDescriptor(const SDL_Libretro* lr, unsigned index, unsigned* port, unsigned* device, unsigned* id, const char** description);


// Events


#define SDL_EVENT_LIBRETRO (SDL_EVENT_USER + 0x1000)


#define SDL_EVENT_LIBRETRO_LAST (SDL_EVENT_LIBRETRO | 0xFFF)


#define SDL_EVENT_LIBRETRO_ENVIRONMENT(cmd) (SDL_EVENT_LIBRETRO | ((cmd) & 0x3FF) | (((cmd) >> 6) & 0xC00))


#define SDL_EVENT_LIBRETRO_ENVIRONMENT_LAST (SDL_EVENT_LIBRETRO | 0xBFF)


#define SDL_LIBRETRO_ENVIRONMENT_COMMAND(type) ((((type) - SDL_EVENT_LIBRETRO) & 0x3FF) | ((((type) - SDL_EVENT_LIBRETRO) & 0xC00) << 6))


#define SDL_EVENT_LIBRETRO_CORE_LOADED (SDL_EVENT_LIBRETRO | 0xF00)

#define SDL_EVENT_LIBRETRO_GAME_LOADED (SDL_EVENT_LIBRETRO | 0xF01)

#define SDL_EVENT_LIBRETRO_MENU_OPENED (SDL_EVENT_LIBRETRO | 0xF02)

#define SDL_EVENT_LIBRETRO_MENU_CLOSED (SDL_EVENT_LIBRETRO | 0xF03)

#define SDL_EVENT_LIBRETRO_CORE_UNLOADED (SDL_EVENT_LIBRETRO | 0xF04)

#define SDL_EVENT_LIBRETRO_GAME_UNLOADED (SDL_EVENT_LIBRETRO | 0xF05)

#define SDL_EVENT_LIBRETRO_SHUTDOWN (SDL_EVENT_LIBRETRO | 0xF06)

#define SDL_EVENT_LIBRETRO_GEOMETRY_CHANGED (SDL_EVENT_LIBRETRO | 0xF07)

// Save States


size_t SDL_Libretro_GetStateSize(const SDL_Libretro* lr);

bool SDL_Libretro_SaveState(SDL_Libretro* lr, const char* file);

bool SDL_Libretro_SaveState_IO(SDL_Libretro* lr, SDL_IOStream* dst, bool closeio);

bool SDL_Libretro_LoadState(SDL_Libretro* lr, const char* file);

bool SDL_Libretro_LoadState_IO(SDL_Libretro* lr, SDL_IOStream* src, bool closeio);


// Memory


bool SDL_Libretro_SaveMemory(SDL_Libretro* lr, unsigned memoryType, const char* file);

bool SDL_Libretro_SaveMemory_IO(SDL_Libretro* lr, unsigned memoryType, SDL_IOStream* dst, bool closeio);

bool SDL_Libretro_LoadMemory(SDL_Libretro* lr, unsigned memoryType, const char* file);

bool SDL_Libretro_LoadMemory_IO(SDL_Libretro* lr, unsigned memoryType, SDL_IOStream* src, bool closeio);

void* SDL_Libretro_GetMemoryData(const SDL_Libretro* lr, unsigned memoryType, size_t* size);

bool SDL_Libretro_SetMemoryData(SDL_Libretro* lr, unsigned memoryType, const void* data, size_t size);

bool SDL_Libretro_SaveSRAM(SDL_Libretro* lr, const char* file);

bool SDL_Libretro_SaveSRAM_IO(SDL_Libretro* lr, SDL_IOStream* dst, bool closeio);

bool SDL_Libretro_LoadSRAM(SDL_Libretro* lr, const char* file);

bool SDL_Libretro_LoadSRAM_IO(SDL_Libretro* lr, SDL_IOStream* src, bool closeio);

void SDL_Libretro_SetSRAMAutoSave(SDL_Libretro* lr, bool enabled);

bool SDL_Libretro_GetSRAMAutoSave(const SDL_Libretro* lr);

unsigned SDL_Libretro_GetMemoryMapCount(const SDL_Libretro* lr);

bool SDL_Libretro_GetMemoryMapDescriptor(const SDL_Libretro* lr, unsigned index, Uint64* flags, void** ptr, size_t* offset, size_t* start, size_t* select, size_t* disconnect, size_t* len, const char** addrspace);

void* SDL_Libretro_GetMapAddress(const SDL_Libretro* lr, size_t address, size_t* regionRemaining);


// Core Options


typedef struct SDL_LibretroOptionValue {

    const char* value;

    const char* label;

} SDL_LibretroOptionValue;


typedef struct SDL_LibretroOption {

    const char* key;

    const char* desc;

    const char* info;

    const char* value;

    const char* defaultValue;

    const char* category;

    bool visible;

    unsigned valuesCount;

    SDL_LibretroOptionValue* values;

    unsigned valuesCapacity;

} SDL_LibretroOption;


typedef struct SDL_LibretroCategory {

    const char* key;

    const char* desc;

    const char* info;

} SDL_LibretroCategory;


unsigned SDL_Libretro_GetOptionCount(const SDL_Libretro* lr);

const SDL_LibretroOption* SDL_Libretro_GetOption(const SDL_Libretro* lr, const char* key);

const SDL_LibretroOption* SDL_Libretro_GetOptionByIndex(const SDL_Libretro* lr, unsigned index);

bool SDL_Libretro_SetOptionValue(SDL_Libretro* lr, const char* key, const char* value);

const char* SDL_Libretro_GetOptionValue(SDL_Libretro* lr, const char* key);

const char* SDL_Libretro_GetOptionValueLabel(SDL_Libretro* lr, const char* key);

bool SDL_Libretro_CycleOptionValue(SDL_Libretro* lr, const char* key, int direction);

bool SDL_Libretro_ResetOption(SDL_Libretro* lr, const char* key);

void SDL_Libretro_ResetAllOptions(SDL_Libretro* lr);

bool SDL_Libretro_AreOptionsDirty(SDL_Libretro* lr);

bool SDL_Libretro_UpdateOptionVisibility(SDL_Libretro* lr);

unsigned SDL_Libretro_GetCategoryCount(const SDL_Libretro* lr);

const SDL_LibretroCategory* SDL_Libretro_GetCategory(const SDL_Libretro* lr, const char* key);

const SDL_LibretroCategory* SDL_Libretro_GetCategoryByIndex(const SDL_Libretro* lr, unsigned index);


// Subsystems


bool SDL_Libretro_LoadGameSpecial(SDL_Libretro* lr, const char* subsystem, const char** paths, unsigned numPaths);

bool SDL_Libretro_LoadGameSpecialById(SDL_Libretro* lr, unsigned subsystemId, const char** paths, unsigned numPaths);


// Disk Control


unsigned SDL_Libretro_GetDiskCount(const SDL_Libretro* lr);

unsigned SDL_Libretro_GetDiskIndex(const SDL_Libretro* lr);

bool SDL_Libretro_SetDiskIndex(SDL_Libretro* lr, unsigned index);

bool SDL_Libretro_EjectDisk(SDL_Libretro* lr);

bool SDL_Libretro_InsertDisk(SDL_Libretro* lr);

bool SDL_Libretro_AddDiskImage(SDL_Libretro* lr, const char* path);

bool SDL_Libretro_AddDiskImage_IO(SDL_Libretro* lr, SDL_IOStream* src, const char* path, bool closeio);

bool SDL_Libretro_GetDiskLabel(const SDL_Libretro* lr, unsigned index, char* label, size_t len);

bool SDL_Libretro_SetInitialDisk(SDL_Libretro* lr, unsigned index, const char* path);


// Cheats


bool SDL_Libretro_SetCheat(SDL_Libretro* lr, unsigned index, bool enabled, const char* code);

void SDL_Libretro_ResetCheats(SDL_Libretro* lr);


// Meta Data


const char* SDL_Libretro_GetCoreName(const SDL_Libretro* lr);

const char* SDL_Libretro_GetGameName(const SDL_Libretro* lr);

const char* SDL_Libretro_GetCoreVersion(const SDL_Libretro* lr);

const char* SDL_Libretro_GetValidExtensions(const SDL_Libretro* lr);

const char* SDL_Libretro_GetContentExtension(const SDL_Libretro* lr);

bool SDL_Libretro_GetBlockExtract(const SDL_Libretro* lr);

unsigned SDL_Libretro_GetPerformanceLevel(const SDL_Libretro* lr);

enum retro_savestate_context SDL_Libretro_GetSavestateContext(const SDL_Libretro* lr);

void SDL_Libretro_SetSavestateContext(SDL_Libretro* lr, enum retro_savestate_context context);


// Utilities


size_t SDL_Libretro_GetFileName(char* dst, size_t dstSize, const char* path, bool withExtension);

size_t SDL_Libretro_GetSavePath(const SDL_Libretro* lr, const char* extension, char* dst, size_t dstSize);


// Rewind


bool SDL_Libretro_SetRewindEnabled(SDL_Libretro* lr, bool enabled, unsigned bufferFrames, unsigned captureInterval);

bool SDL_Libretro_GetRewindEnabled(const SDL_Libretro* lr);

double SDL_Libretro_GetRewindRemaining(const SDL_Libretro* lr);

size_t SDL_Libretro_GetRewindMemoryUsage(const SDL_Libretro* lr);

void SDL_Libretro_SetRewindMemoryLimit(SDL_Libretro* lr, size_t maxBytes);

size_t SDL_Libretro_GetRewindMemoryLimit(const SDL_Libretro* lr);

bool SDL_Libretro_SetRewindMemoryDuration(SDL_Libretro* lr, double seconds);


// VFS


void SDL_Libretro_SetVFS(SDL_Libretro* lr, void* vfs);


// Logging


void SDL_Libretro_SetLogLevel(SDL_Libretro* lr, SDL_LogPriority level);

SDL_LogPriority SDL_Libretro_GetLogLevel(const SDL_Libretro* lr);


// On-Screen Display


void SDL_Libretro_SetMessage(SDL_Libretro* lr, const char* msg, double duration);

const char* SDL_Libretro_GetMessage(SDL_Libretro* lr);

int SDL_Libretro_GetMessageProgress(SDL_Libretro* lr);

int SDL_Libretro_GetMessageType(SDL_Libretro* lr);

unsigned SDL_Libretro_GetMessageCount(SDL_Libretro* lr);

bool SDL_Libretro_GetMessageByIndex(SDL_Libretro* lr, int index, const char** msg, int* progress, int* type);


// PhysFS


bool SDL_Libretro_PhysFS_Init(SDL_Libretro* lr);

void SDL_Libretro_PhysFS_Quit(SDL_Libretro* lr);

bool SDL_Libretro_PhysFS_LoadGame(SDL_Libretro* lr, const char* gamePath);


// Menu


typedef struct SDL_LibretroMenu SDL_LibretroMenu;


typedef enum SDL_LibretroMenuStyle {

    SDL_LIBRETRO_MENU_STYLE_CATPPUCCIN_MOCHA = 0,

    SDL_LIBRETRO_MENU_STYLE_CATPPUCCIN_LATTE,

    SDL_LIBRETRO_MENU_STYLE_CATPPUCCIN_FRAPPE,

    SDL_LIBRETRO_MENU_STYLE_CATPPUCCIN_MACCHIATO,

    SDL_LIBRETRO_MENU_STYLE_DRACULA,

    SDL_LIBRETRO_MENU_STYLE_DARK,

    SDL_LIBRETRO_MENU_STYLE_COUNT

} SDL_LibretroMenuStyle;


SDL_LibretroMenu* SDL_Libretro_CreateMenu(SDL_Libretro* lr);

void SDL_Libretro_DestroyMenu(SDL_LibretroMenu* menu);

void SDL_Libretro_UpdateMenu(SDL_LibretroMenu* menu);

void SDL_Libretro_RenderMenu(SDL_LibretroMenu* menu);


bool SDL_Libretro_HandleMenuEvent(SDL_LibretroMenu* menu, const SDL_Event* event);


void SDL_Libretro_SetMenuOpen(SDL_LibretroMenu* menu, bool open);

void SDL_Libretro_ToggleMenu(SDL_LibretroMenu* menu);

bool SDL_Libretro_IsMenuOpen(const SDL_LibretroMenu* menu);


bool SDL_Libretro_OpenMenuPath(SDL_LibretroMenu* menu, const char* path);

bool SDL_Libretro_SetMenuStyle(SDL_LibretroMenu* menu, SDL_LibretroMenuStyle style);

SDL_LibretroMenuStyle SDL_Libretro_GetMenuStyle(const SDL_LibretroMenu* menu);


typedef void (*SDL_LibretroMenuCallback)(SDL_LibretroMenu* menu, void* userdata);


bool SDL_Libretro_AddMenuButton(SDL_LibretroMenu* menu, const char* label, SDL_LibretroMenuCallback callback, void* userdata);


bool SDL_Libretro_AddMenuCheckbox(SDL_LibretroMenu* menu, const char* label, bool* value, SDL_LibretroMenuCallback callback, void* userdata);


void SDL_Libretro_MenuScreenshotClicked(SDL_LibretroMenu* menu, void* userdata);


SDL_Libretro* SDL_Libretro_GetMenuLibretro(const SDL_LibretroMenu* menu);


void SDL_Libretro_SetMenuUserData(SDL_LibretroMenu* menu, void* userData);


void* SDL_Libretro_GetMenuUserData(const SDL_LibretroMenu* menu);


#ifdef __cplusplus

}

#endif


/* ===================================================================== */

/*  Implementation                                                       */

/* ===================================================================== */

#ifdef SDL_LIBRETRO_IMPLEMENTATION

#ifndef SDL_LIBRETRO_IMPLEMENTATION_ONCE

#define SDL_LIBRETRO_IMPLEMENTATION_ONCE


#ifndef SDL_LIBRETRO_NO_INI_IMPLEMENTATION

#define SDL_INI_IMPLEMENTATION

#include "SDL_ini.h"

#endif


#ifndef SDL_LIBRETRO_MAX_PATH

#define SDL_LIBRETRO_MAX_PATH 4096

#endif

#define SDL_LIBRETRO_AUDIO_SINGLE_SAMPLE_BUFFER_SIZE 512


#define SDL_LIBRETRO_OSD_INITIAL_CAPACITY 4


#ifndef SDL_LIBRETRO_MAX_USERS

#define SDL_LIBRETRO_MAX_USERS 4

#endif


#define SDL_LIBRETRO_MAX_JOYPAD_BUTTONS 16


// clang-format off

static const char* SDL_Libretro_JoypadButtonNames[SDL_LIBRETRO_MAX_JOYPAD_BUTTONS] = {

    "B", "Y", "Select", "Start", "Up", "Down", "Left", "Right",

    "A", "X", "L", "R", "L2", "R2", "L3", "R3",

};

// clang-format on


// clang-format off

static const char* SDL_Libretro_AnalogToDigitalNames[SDL_LIBRETRO_ANALOG_TO_DIGITAL_COUNT] = {

    "None", "Left", "Right",

};

// clang-format on


typedef struct SDL_Libretro_CoreInfo {

    char* corename;

    char* supported_extensions;

    char* path;

    bool needs_fullpath;

    bool supports_no_game;

    bool block_extract;

} SDL_Libretro_CoreInfo;


typedef struct SDL_LibretroOsdEntry {

    char* msg;

    Uint64 endTimeMs;

    unsigned priority;

    enum retro_message_type type;

    int8_t progress;

} SDL_LibretroOsdEntry;


typedef struct SDL_LibretroCoreSymbols {

    SDL_SharedObject* handle;

    void (*retro_init)(void);

    void (*retro_deinit)(void);

    unsigned (*retro_api_version)(void);

    void (*retro_set_environment)(retro_environment_t);

    void (*retro_set_video_refresh)(retro_video_refresh_t);

    void (*retro_set_audio_sample)(retro_audio_sample_t);

    void (*retro_set_audio_sample_batch)(retro_audio_sample_batch_t);

    void (*retro_set_input_poll)(retro_input_poll_t);

    void (*retro_set_input_state)(retro_input_state_t);

    void (*retro_get_system_info)(struct retro_system_info*);

    void (*retro_get_system_av_info)(struct retro_system_av_info*);

    void (*retro_set_controller_port_device)(unsigned port, unsigned device);

    void (*retro_reset)(void);

    void (*retro_run)(void);

    size_t (*retro_serialize_size)(void);

    bool (*retro_serialize)(void*, size_t);

    bool (*retro_unserialize)(const void*, size_t);

    void (*retro_cheat_reset)(void);

    void (*retro_cheat_set)(unsigned index, bool enabled, const char* code);

    bool (*retro_load_game)(const struct retro_game_info*);

    bool (*retro_load_game_special)(unsigned, const struct retro_game_info*, size_t);

    void (*retro_unload_game)(void);

    unsigned (*retro_get_region)(void);

    void* (*retro_get_memory_data)(unsigned);

    size_t (*retro_get_memory_size)(unsigned);

} SDL_LibretroCoreSymbols;


typedef struct SDL_LibretroMicrophone {

    SDL_AudioStream* stream;

    unsigned rate;

    bool active;

    SDL_Libretro* lr;

} SDL_LibretroMicrophone;


typedef struct SDL_LibretroDiskImage {

    char* path;

    void* data;

    bool temp;

} SDL_LibretroDiskImage;


typedef struct SDL_LibretroCoreData {

    SDL_LibretroCoreSymbols symbols;


    bool gameLoaded;

    bool shutdown;

    float speed;

    double speedAccumulator;

    Uint64 lastTickNS;

    unsigned width, height;

    double fps;

    double sampleRate;

    float aspectRatio;

    char corePath[SDL_LIBRETRO_MAX_PATH];

    char libraryName[128];

    char libraryVersion[128];

    char validExtensions[128];

    bool needFullpath;

    bool blockExtract;

    bool usedVFS;

    bool supportNoGame;

    unsigned apiVersion;

    enum retro_pixel_format pixelFormat;

    unsigned performanceLevel;

    uint64_t serializationQuirks;

    enum retro_savestate_context savestateContext;

    int rotation;


    // Video

    SDL_Texture* texture;

    SDL_FRect renderDstRect;

    bool videoReinitPending;

    void* softwareFramebufferPixels;


    // Audio

    SDL_AudioStream* audioStream;

    int audioQueueThresholdBytes;

    unsigned minimumAudioLatencyMs;

    int16_t singleSampleBuffer[SDL_LIBRETRO_AUDIO_SINGLE_SAMPLE_BUFFER_SIZE * 2];

    size_t singleSampleCount;

    int audioDropWarnCount;

    bool audioReinitPending;

    struct retro_audio_callback audio_callback;

    struct retro_audio_buffer_status_callback audio_buffer_status;

    // Input

    float inputMouseX, inputMouseY;

    float inputMotionAccumX, inputMotionAccumY;

    float inputMotionX, inputMotionY;

    float inputWheelAccumX, inputWheelAccumY;

    float inputWheelX, inputWheelY;

    unsigned portDeviceMap[SDL_LIBRETRO_MAX_USERS];

    bool virtualJoypadState[SDL_LIBRETRO_MAX_USERS][SDL_LIBRETRO_MAX_JOYPAD_BUTTONS];

    retro_keyboard_event_t keyboard_event;


    // Timing

    struct retro_frame_time_callback runloop_frame_time;

    Uint64 runloop_frame_time_last;

    // Fast-forward override

    struct retro_fastforwarding_override fastforwardOverride;

    bool fastforwardOverrideActive;


    // Core Options

    SDL_LibretroOption* options;

    unsigned optionCount;

    unsigned optionCapacity;

    bool optionsDirtyCore;

    bool optionsDirtyApp;

    retro_core_options_update_display_callback_t optionsUpdateDisplayCallback;

    SDL_LibretroCategory* optionCategories;

    unsigned optionCategoriesCount;

    unsigned optionCategoriesCapacity;


    // Input Descriptors

    struct retro_input_descriptor* inputDescriptors;

    unsigned inputDescriptorsCount;


    // Controller Information

    struct retro_controller_info* controllerInfo;

    unsigned controllerInfoCount;


    // Game Content

    char contentPath[SDL_LIBRETRO_MAX_PATH];

    char contentName[SDL_LIBRETRO_MAX_PATH];

    char contentDir[SDL_LIBRETRO_MAX_PATH];

    char contentExt[32];

    char contentTempPath[SDL_LIBRETRO_MAX_PATH];

    char contentTempDir[SDL_LIBRETRO_MAX_PATH];

    struct retro_game_info_ext gameInfoExt;

    struct retro_game_info_ext* gameInfoExtArray;

    unsigned gameInfoExtCount;

    // Content Info Overrides

    struct retro_system_content_info_override* contentInfoOverrides;

    unsigned contentInfoOverrideCount;

    // Subsystems

    struct retro_subsystem_info* subsystems;

    unsigned subsystemCount;


    // Rumble

    float rumbleStrong[SDL_LIBRETRO_MAX_USERS];

    float rumbleWeak[SDL_LIBRETRO_MAX_USERS];


    // Sensors

    SDL_Sensor* sensorAccel[SDL_LIBRETRO_MAX_USERS];

    SDL_Sensor* sensorGyro[SDL_LIBRETRO_MAX_USERS];

    float sensorAccelData[SDL_LIBRETRO_MAX_USERS][3];

    float sensorGyroData[SDL_LIBRETRO_MAX_USERS][3];


    // Microphone

    SDL_LibretroMicrophone* microphone;


    // Disk control

    struct retro_disk_control_ext_callback disk_control;

    SDL_LibretroDiskImage* diskImages;

    unsigned diskImageCount;


    // Memory Maps

    struct retro_memory_descriptor* memoryMapDescriptors;

    unsigned memoryMapDescriptorCount;


    // Dynamic Rate Control

    bool drcEnabled;

    float drcAdjustment;

    double drcDriftAvg;


    // Performance Counter

    struct retro_perf_counter* perfCounters[64];

    unsigned perfCounterCount;

    retro_perf_tick_t gameTimeNSEC;

} SDL_LibretroCoreData;


typedef struct SDL_LibretroRewindDelta {

    unsigned char* data;

    size_t length; /* used bytes of the encoded delta */

    size_t capacity; /* allocated bytes of data (>= length); enables in-place reuse */

} SDL_LibretroRewindDelta;


struct SDL_Libretro {

    // Persistent Settings Across Cores

    float volume;

    unsigned audioLatencyMs;

    SDL_LibretroFitMode fitMode;

    SDL_ScaleMode scaleMode;

    SDL_Scancode keyboardPlayer1[SDL_LIBRETRO_MAX_JOYPAD_BUTTONS];

    SDL_GamepadButton gamepadButtons[SDL_LIBRETRO_MAX_USERS][SDL_LIBRETRO_MAX_JOYPAD_BUTTONS];

    SDL_LibretroAnalogToDigital analogToDigital[SDL_LIBRETRO_MAX_USERS];

    unsigned mousePort;

    bool sramAutoSave;

    char coreDirectory[SDL_LIBRETRO_MAX_PATH];

    char saveDirectory[SDL_LIBRETRO_MAX_PATH];

    char systemDirectory[SDL_LIBRETRO_MAX_PATH];

    char coreAssetsDirectory[SDL_LIBRETRO_MAX_PATH];

    char playlistDirectory[SDL_LIBRETRO_MAX_PATH];

    char fileBrowserStartDirectory[SDL_LIBRETRO_MAX_PATH];

    char username[64];

    int language;

    // Video

    SDL_Renderer* renderer;

    SDL_Window* window;

    // Logging

    enum retro_log_level logLevel;


    // On-Screen Display Message Queue

    SDL_LibretroOsdEntry* osdQueue;

    int osdQueueCount;

    int osdQueueCapacity;


    // Virtual File System

    struct retro_vfs_interface vfs_interface;


    // Rewind (delta-compressed circular buffer)

    unsigned char* rewindReference;

    unsigned char* rewindScratch;

    unsigned char* rewindEncodeScratch; /* reusable worst-case-sized buffer for one-pass delta encoding */

    SDL_LibretroRewindDelta* rewindEntries;

    size_t rewindSlotSize;

    size_t rewindBytes; /* live encoded delta bytes currently stored */

    size_t rewindMaxBytes; /* memory budget for delta data; 0 = unbounded */

    unsigned rewindCapacity;

    unsigned rewindHead;

    unsigned rewindCount;

    unsigned rewindCaptureInterval;

    unsigned rewindFrameCounter;

    bool rewindEnabled;

    bool rewindHasReference;

    bool rewindActive;

    // Input

    SDL_Gamepad* gamepads[SDL_LIBRETRO_MAX_USERS];

    unsigned gamepadCount;


    SDL_LibretroCoreData core;

    unsigned coreGeneration;

    // Configuration

    char* iniFile;

    SDL_ini* ini;


    // Core Library

    SDL_Libretro_CoreInfo* coreLibrary;

    unsigned coreLibraryCount;

    void* userData;

#if defined(SDL_LIBRETRO_ENABLE_PHYSFS) && !defined(SDL_LIBRETRO_DISABLE_PHYSFS)

    bool physfsReady;

    char physfsMountSource[SDL_LIBRETRO_MAX_PATH];

#endif

};


static SDL_Libretro* SDL_Libretro_active = NULL;


/*

 * @internal

 * Forward declarations of the implementation's static helpers, shared between

 * the implementation fragments included below. None of them are part of the

 * public API.

 */

static bool SDL_Libretro_InitVideo(SDL_Libretro* lr);

static void SDL_Libretro_CloseVideo(SDL_Libretro* lr);

static void SDL_Libretro_VideoRefresh(const void* data, unsigned width, unsigned height, size_t pitch);

static void SDL_Libretro_ReleaseSoftwareFramebuffer(SDL_Libretro* lr);


static void SDL_Libretro_AudioSample(int16_t left, int16_t right);

static size_t SDL_Libretro_AudioSampleBatch(const int16_t* data, size_t frames);

static void SDL_Libretro_FlushSingleSamples(SDL_Libretro* lr);

static void SDL_Libretro_UpdateDRC(SDL_Libretro* lr, float speed);

static unsigned SDL_Libretro_UpdateAudioThreshold(SDL_Libretro* lr);

static void SDL_Libretro_ReportAudioBufferStatus(SDL_Libretro* lr);


static bool SDL_Libretro_InitAudio(SDL_Libretro* lr);

static void SDL_Libretro_CloseAudio(SDL_Libretro* lr);

static void SDL_Libretro_InputPoll(void);

static int16_t SDL_Libretro_InputState(unsigned port, unsigned device, unsigned index, unsigned id);

static bool SDL_Libretro_RewindStep(SDL_Libretro* lr);

static void SDL_Libretro_OsdPush(SDL_Libretro* lr, const char* msg, double durationSec, unsigned priority, enum retro_message_type type, int8_t progress);

static void SDL_Libretro_FreeMessages(SDL_Libretro* lr);

static bool SDL_Libretro_EnvironmentCallback(unsigned cmd, void* data);

static void SDL_Libretro_PushEvent(SDL_Libretro* lr, Uint32 type, void* data);

static bool SDL_Libretro_PushEnvEvent(SDL_Libretro* lr, unsigned cmd, void* data);

static void SDL_Libretro_ClearRewind(SDL_Libretro* lr);


static SDL_Scancode SDL_Libretro_RetroKeyToScancode(unsigned key);

static unsigned SDL_Libretro_ScancodeToRetroKey(SDL_Scancode scancode);

static uint16_t SDL_Libretro_KeymodToRetroMod(SDL_Keymod mod);

static SDL_GamepadButton SDL_Libretro_RetroJoypadToGamepadButton(const SDL_Libretro* lr, unsigned port, unsigned button);


// Sensors


static bool SDL_Libretro_SetSensorState(unsigned port, enum retro_sensor_action action, unsigned rate);

static float SDL_Libretro_GetSensorInput(unsigned port, unsigned id);

static void SDL_Libretro_CloseSensors(SDL_Libretro* lr);


// Microphone


static retro_microphone_t* SDL_Libretro_MicOpen(const retro_microphone_params_t* params);

static void SDL_Libretro_MicClose(retro_microphone_t* microphone);

static bool SDL_Libretro_MicGetParams(const retro_microphone_t* microphone, retro_microphone_params_t* params);

static bool SDL_Libretro_MicSetState(retro_microphone_t* microphone, bool state);

static bool SDL_Libretro_MicGetState(const retro_microphone_t* microphone);

static int SDL_Libretro_MicRead(retro_microphone_t* microphone, int16_t* samples, size_t num_samples);

static void SDL_Libretro_CloseMicrophone(SDL_Libretro* lr);


// Rewind


#ifdef SDL_LIBRETRO_ENABLE_REWIND_DELTA

static size_t SDL_Libretro_RewindEncodeDelta(const unsigned char* cur, const unsigned char* ref, size_t len, unsigned char* out, size_t outCap);

static bool SDL_Libretro_RewindDecodeDelta(const unsigned char* delta, size_t deltaLen, unsigned char* state, size_t stateLen);

#endif

static void SDL_Libretro_RewindCapture(SDL_Libretro* lr);

static bool SDL_Libretro_RewindStepState(SDL_Libretro* lr);

static void SDL_Libretro_RewindFreeEntry(SDL_Libretro* lr, SDL_LibretroRewindDelta* entry);

static void SDL_Libretro_RewindEvictToBudget(SDL_Libretro* lr);

static void SDL_Libretro_RewindFree(SDL_Libretro* lr);


static bool SDL_Libretro_ExtensionInList(const char* ext, const char* pipeList);


static void SDL_Libretro_InitCoreOption(SDL_Libretro* lr, const char* key, const char* defaultValue, const char* desc, const struct retro_core_option_value* values, unsigned valuesMax, const char* info, const char* categoryKey);

static void SDL_Libretro_InitCoreOptionCategory(SDL_Libretro* lr, const char* key, const char* desc, const char* info);

static void SDL_Libretro_FreeCoreOptions(SDL_Libretro* lr);


static void SDL_Libretro_FreeMemoryMap(SDL_Libretro* lr);

static void SDL_Libretro_FreeContentInfoOverrides(SDL_Libretro* lr);

static void SDL_Libretro_FreeSubsystems(SDL_Libretro* lr);

static void SDL_Libretro_FreeInputDescriptors(SDL_Libretro* lr);

static void SDL_Libretro_FreeControllerInfo(SDL_Libretro* lr);

static const struct retro_subsystem_info* SDL_Libretro_GetSubsystemById(const SDL_Libretro* lr, unsigned subsystemId);

static const struct retro_subsystem_info* SDL_Libretro_GetSubsystemByName(const SDL_Libretro* lr, const char* name);


// Content


static bool SDL_Libretro_GetPrefDirectory(char* dst, size_t dstSize);

static void SDL_Libretro_FreeDiskImages(SDL_Libretro* lr);

static const char* SDL_Libretro_GetExtension(const char* path);

static bool SDL_Libretro_ContentNeedsFullpath(const SDL_Libretro* lr, const char* ext);

static bool SDL_Libretro_SpillToTempFile(SDL_Libretro* lr, SDL_IOStream* src, const char* path, bool closeio, char* tempPath, size_t tempPathSize);

static bool SDL_Libretro_GetTempDirectory(SDL_Libretro* lr, char* dir, size_t dirSize);

static void SDL_Libretro_RemoveTree(const char* path);


// Directory


static void SDL_Libretro_FreeCoreLibrary(SDL_Libretro* lr);


// Config


static bool SDL_Libretro_LoadCoreConfig(SDL_Libretro* lr);

static bool SDL_Libretro_SaveCoreConfig(SDL_Libretro* lr);

static const char* SDL_Libretro_GetSavedCoreOption(const SDL_Libretro* lr, const char* key);

static bool SDL_Libretro_CloseConfig(SDL_Libretro* lr);


// PhysFS


static void SDL_Libretro_PhysFS_ClearMount(SDL_Libretro* lr);


// Implementation fragments are included in dependency order.

// clang-format off

#include "SDL_libretro_video.h"

#include "SDL_libretro_audio.h"

#include "SDL_libretro_input.h"

#include "SDL_libretro_options.h"

#include "SDL_libretro_serialize.h"

#include "SDL_libretro_vfs.h"

#include "SDL_libretro_messages.h"

#include "SDL_libretro_env.h"

#include "SDL_libretro_core.h"

#include "SDL_libretro_config.h"

#include "SDL_libretro_physfs.h"

#include "SDL_libretro_menu.h"

// clang-format on


#endif /* SDL_LIBRETRO_IMPLEMENTATION_ONCE */

#endif /* SDL_LIBRETRO_IMPLEMENTATION */


#endif /* SDL_LIBRETRO_H */

SDL_LIBRETRO_MAX_USERS
#define SDL_LIBRETRO_MAX_USERS
The number of controller ports (gamepads) the frontend tracks.
Definition SDL_libretro.h:571

SDL_libretro_audio.h
SDL_libretro - audio subsystem.

SDL_libretro_config.h
SDL_libretro config saving/loading.

SDL_libretro_core.h
SDL_libretro - core lifecycle implementation.

SDL_libretro_env.h
SDL_libretro environment callback dispatch.

SDL_libretro_input.h
SDL_libretro - input subsystem.

SDL_libretro_menu.h
SDL_libretro - menu system built on nuklear_console.

SDL_libretro_messages.h
SDL_libretro - on-screen display message queue.

SDL_libretro_options.h
SDL_libretro - core options management.

SDL_libretro_physfs.h
SDL_libretro - zip loading with PhysFS.

SDL_libretro_serialize.h
SDL_libretro - save states, core memory (SRAM/RTC/...), and rewind.

SDL_libretro_vfs.h
SDL_libretro - SDL3 Virtual File System interface for libretro.

SDL_libretro_video.h
SDL_libretro - Video System.

SDL_Libretro_SetMessage
void SDL_Libretro_SetMessage(SDL_Libretro *lr, const char *msg, double duration)
Add a message to be displayed within the libretro context.
Definition SDL_libretro_messages.h:129

SDL_Libretro_SaveState_IO
bool SDL_Libretro_SaveState_IO(SDL_Libretro *lr, SDL_IOStream *dst, bool closeio)
Save the current libretro state to the given SDL_IOStream.
Definition SDL_libretro_serialize.h:447

SDL_Libretro_IsMenuOpen
bool SDL_Libretro_IsMenuOpen(const SDL_LibretroMenu *menu)
Checks whether the menu is currently shown.
Definition SDL_libretro_menu.h:2470

SDL_Libretro_CycleOptionValue
bool SDL_Libretro_CycleOptionValue(SDL_Libretro *lr, const char *key, int direction)
Advance a core option to the next (+1) or previous (-1) value.
Definition SDL_libretro_options.h:388

SDL_Libretro_Render
bool SDL_Libretro_Render(SDL_Libretro *lr, SDL_Renderer *renderer, const SDL_FRect *dstRect)
Render the libretro context in the given renderer.
Definition SDL_libretro_video.h:304

SDL_Libretro_IsCoreReady
bool SDL_Libretro_IsCoreReady(const SDL_Libretro *lr)
Indicates whether a core is loaded.
Definition SDL_libretro_core.h:373

SDL_Libretro_SetCoreAssetsDirectory
bool SDL_Libretro_SetCoreAssetsDirectory(SDL_Libretro *lr, const char *path)
Sets where cores look for their assets, reported through RETRO_ENVIRONMENT_GET_CORE_ASSETS_DIRECTORY.
Definition SDL_libretro_core.h:1968

SDL_Libretro_SetSystemDirectory
bool SDL_Libretro_SetSystemDirectory(SDL_Libretro *lr, const char *path)
Sets where cores look for system files (BIOS, firmware, etc).
Definition SDL_libretro_core.h:1940

SDL_LibretroMenu
struct SDL_LibretroMenu SDL_LibretroMenu
An in-app menu built on nuklear_console.
Definition SDL_libretro.h:468

SDL_Libretro_GetSavePath
size_t SDL_Libretro_GetSavePath(const SDL_Libretro *lr, const char *extension, char *dst, size_t dstSize)
Build a path in the save directory for the currently loaded content.
Definition SDL_libretro_core.h:428

SDL_Libretro_SetCoreDirectory
bool SDL_Libretro_SetCoreDirectory(SDL_Libretro *lr, const char *path)
Sets the associated libretro core directory, where the default set of cores will be loaded from.
Definition SDL_libretro_core.h:1844

SDL_Libretro_SetRewindMemoryLimit
void SDL_Libretro_SetRewindMemoryLimit(SDL_Libretro *lr, size_t maxBytes)
Set the maximum number of bytes of encoded delta history to retain.
Definition SDL_libretro_serialize.h:1310

SDL_Libretro_UpdateOptionVisibility
bool SDL_Libretro_UpdateOptionVisibility(SDL_Libretro *lr)
Ask the core to refresh which of its options should be displayed.
Definition SDL_libretro_options.h:489

SDL_LibretroMenuCallback
void(* SDL_LibretroMenuCallback)(SDL_LibretroMenu *menu, void *userdata)
A callback for menu entries added by the application.
Definition SDL_libretro.h:506

SDL_Libretro_SaveSRAM
bool SDL_Libretro_SaveSRAM(SDL_Libretro *lr, const char *file)
Saves the current SRAM to the given file.
Definition SDL_libretro_serialize.h:960

SDL_Libretro_GetUsername
const char * SDL_Libretro_GetUsername(SDL_Libretro *lr)
Get the username reported to cores.
Definition SDL_libretro_core.h:2051

SDL_Libretro_GetScaleMode
SDL_ScaleMode SDL_Libretro_GetScaleMode(const SDL_Libretro *lr)
Gets the texture scale mode used when the libretro frame is scaled.
Definition SDL_libretro_video.h:462

SDL_Libretro_GetFitMode
SDL_LibretroFitMode SDL_Libretro_GetFitMode(const SDL_Libretro *lr)
Gets how the frame is fit into the destination rectangle when rendered.
Definition SDL_libretro_video.h:424

SDL_Libretro_SetCheat
bool SDL_Libretro_SetCheat(SDL_Libretro *lr, unsigned index, bool enabled, const char *code)
Set a cheat code either enabled or disabled within the libretro context.
Definition SDL_libretro_serialize.h:400

SDL_Libretro_SaveScreenshot
bool SDL_Libretro_SaveScreenshot(const SDL_Libretro *lr, const char *path)
Saves a PNG screenshot of the current frame.
Definition SDL_libretro_video.h:236

SDL_Libretro_CreateSurface
SDL_Surface * SDL_Libretro_CreateSurface(const SDL_Libretro *lr)
Creates a new surface from the current libretro context.
Definition SDL_libretro_video.h:201

SDL_Libretro_GetContentExtension
const char * SDL_Libretro_GetContentExtension(const SDL_Libretro *lr)
Get the extension of the loaded content, as it appears in the path.
Definition SDL_libretro_core.h:2304

SDL_Libretro_GetInputDescriptorCount
unsigned SDL_Libretro_GetInputDescriptorCount(const SDL_Libretro *lr)
Retrieve the number of input descriptors provided by a Libretro core.
Definition SDL_libretro_input.h:916

SDL_Libretro_GetRotation
int SDL_Libretro_GetRotation(const SDL_Libretro *lr)
Gets the screen rotation requested by the core.
Definition SDL_libretro_video.h:393

SDL_Libretro_GetMessageByIndex
bool SDL_Libretro_GetMessageByIndex(SDL_Libretro *lr, int index, const char **msg, int *progress, int *type)
Retrieves all message details for the given message index.
Definition SDL_libretro_messages.h:221

SDL_Libretro_GetSRAMAutoSave
bool SDL_Libretro_GetSRAMAutoSave(const SDL_Libretro *lr)
Check whether SRAM is loaded and saved along with the game.
Definition SDL_libretro_serialize.h:905

SDL_Libretro_UpdateMenu
void SDL_Libretro_UpdateMenu(SDL_LibretroMenu *menu)
Processes input and lays out the menu for this frame.
Definition SDL_libretro_menu.h:2758

SDL_Libretro_UnloadCore
void SDL_Libretro_UnloadCore(SDL_Libretro *lr)
Unloads the actively loaded core.
Definition SDL_libretro_core.h:326

SDL_Libretro_AddDiskImage
bool SDL_Libretro_AddDiskImage(SDL_Libretro *lr, const char *path)
Appends a new disk image from a file path.
Definition SDL_libretro_serialize.h:237

SDL_Libretro_GetMessageProgress
int SDL_Libretro_GetMessageProgress(SDL_Libretro *lr)
Gets the progress of the message returned by SDL_Libretro_GetMessage().
Definition SDL_libretro_messages.h:169

SDL_Libretro_GetMemoryMapDescriptor
bool SDL_Libretro_GetMemoryMapDescriptor(const SDL_Libretro *lr, unsigned index, Uint64 *flags, void **ptr, size_t *offset, size_t *start, size_t *select, size_t *disconnect, size_t *len, const char **addrspace)
Retrieve one memory-map descriptor by index.
Definition SDL_libretro_serialize.h:666

SDL_Libretro_EjectDisk
bool SDL_Libretro_EjectDisk(SDL_Libretro *lr)
Ejects the disk tray, allowing the disk image to be changed.
Definition SDL_libretro_serialize.h:134

SDL_Libretro_LoadGameSpecial
bool SDL_Libretro_LoadGameSpecial(SDL_Libretro *lr, const char *subsystem, const char **paths, unsigned numPaths)
Loads multi-ROM subsystem content (e.g.
Definition SDL_libretro_core.h:1330

SDL_Libretro_SetLogLevel
void SDL_Libretro_SetLogLevel(SDL_Libretro *lr, SDL_LogPriority level)
Sets the threshold for logs to be posted.
Definition SDL_libretro_core.h:2170

SDL_Libretro_GetSampleRate
double SDL_Libretro_GetSampleRate(const SDL_Libretro *lr)
Get the audio sample rate the loaded core outputs at.
Definition SDL_libretro_audio.h:346

SDL_LibretroFitMode
SDL_LibretroFitMode
When rendering the libretro context, determine how to display within the destination.
Definition SDL_libretro.h:98

SDL_Libretro_SetPortDevice
bool SDL_Libretro_SetPortDevice(SDL_Libretro *lr, unsigned port, unsigned device)
Assign a device type to a controller port.
Definition SDL_libretro_input.h:762

SDL_Libretro_LoadSRAM
bool SDL_Libretro_LoadSRAM(SDL_Libretro *lr, const char *file)
Loads the SRAM from the given file.
Definition SDL_libretro_serialize.h:991

SDL_Libretro_Reset
bool SDL_Libretro_Reset(SDL_Libretro *lr)
Resets the loaded game, like pressing the console's reset button.
Definition SDL_libretro_core.h:1412

SDL_Libretro_GetFileName
size_t SDL_Libretro_GetFileName(char *dst, size_t dstSize, const char *path, bool withExtension)
Copy the file name portion of a path into a caller-provided buffer.
Definition SDL_libretro_core.h:388

SDL_Libretro_ResetCheats
void SDL_Libretro_ResetCheats(SDL_Libretro *lr)
Clears all cheats that were set on the core.
Definition SDL_libretro_serialize.h:418

SDL_Libretro_AreOptionsDirty
bool SDL_Libretro_AreOptionsDirty(SDL_Libretro *lr)
Retrieves whether the options have been changed since the last time they were checked.
Definition SDL_libretro_options.h:469

SDL_Libretro_PhysFS_LoadGame
bool SDL_Libretro_PhysFS_LoadGame(SDL_Libretro *lr, const char *gamePath)
Archive-aware replacement for SDL_Libretro_LoadGame().
Definition SDL_libretro_physfs.h:470

SDL_Libretro_GetMemoryData
void * SDL_Libretro_GetMemoryData(const SDL_Libretro *lr, unsigned memoryType, size_t *size)
Get a pointer to a core memory region and its size.
Definition SDL_libretro_serialize.h:573

SDL_Libretro_GetGameName
const char * SDL_Libretro_GetGameName(const SDL_Libretro *lr)
Retrieve the human-readable name of the loaded game.
Definition SDL_libretro_core.h:2219

SDL_Libretro_GetPortDevice
unsigned SDL_Libretro_GetPortDevice(const SDL_Libretro *lr, unsigned port)
Get the device type assigned to a controller port.
Definition SDL_libretro_input.h:784

SDL_Libretro_GetVersion
int SDL_Libretro_GetVersion(void)
Get the version of SDL_libretro the implementation was compiled with.
Definition SDL_libretro_core.h:1647

SDL_Libretro_GetMenuUserData
void * SDL_Libretro_GetMenuUserData(const SDL_LibretroMenu *menu)
Gets the data attached with SDL_Libretro_SetMenuUserData().
Definition SDL_libretro_menu.h:2513

SDL_Libretro_GetCategoryByIndex
const SDL_LibretroCategory * SDL_Libretro_GetCategoryByIndex(const SDL_Libretro *lr, unsigned index)
Retrieve an option category by index.
Definition SDL_libretro_options.h:534

SDL_LibretroMenuStyle
SDL_LibretroMenuStyle
Color themes for the menu.
Definition SDL_libretro.h:475

SDL_Libretro_SetRewindEnabled
bool SDL_Libretro_SetRewindEnabled(SDL_Libretro *lr, bool enabled, unsigned bufferFrames, unsigned captureInterval)
Enable or disable the rewind system.
Definition SDL_libretro_serialize.h:1227

SDL_Libretro_GetCoreVersion
const char * SDL_Libretro_GetCoreVersion(const SDL_Libretro *lr)
Retrieves the version of the libretro core that's actively loaded.
Definition SDL_libretro_core.h:2229

SDL_Libretro_RenderMenu
void SDL_Libretro_RenderMenu(SDL_LibretroMenu *menu)
Draws the menu laid out by SDL_Libretro_UpdateMenu() to the renderer.
Definition SDL_libretro_menu.h:2848

SDL_Libretro_GetCategory
const SDL_LibretroCategory * SDL_Libretro_GetCategory(const SDL_Libretro *lr, const char *key)
Retrieve an option category by key.
Definition SDL_libretro_options.h:515

SDL_Libretro_SetRewindMemoryDuration
bool SDL_Libretro_SetRewindMemoryDuration(SDL_Libretro *lr, double seconds)
Set the rewind memory budget by target duration instead of raw bytes.
Definition SDL_libretro_serialize.h:1342

SDL_Libretro_GetPerformanceLevel
unsigned SDL_Libretro_GetPerformanceLevel(const SDL_Libretro *lr)
Get the performance level the core requested via SET_PERFORMANCE_LEVEL.
Definition SDL_libretro_core.h:2251

SDL_Libretro_DestroyMenu
void SDL_Libretro_DestroyMenu(SDL_LibretroMenu *menu)
Destroys a menu created with SDL_Libretro_CreateMenu().
Definition SDL_libretro_menu.h:2431

SDL_Libretro_Update
void SDL_Libretro_Update(SDL_Libretro *lr)
Runs the loaded game; call it once per frame of the application's loop.
Definition SDL_libretro_core.h:1501

SDL_Libretro_GetInputDescriptor
bool SDL_Libretro_GetInputDescriptor(const SDL_Libretro *lr, unsigned index, unsigned *port, unsigned *device, unsigned *id, const char **description)
Retrieve an input descriptor by index.
Definition SDL_libretro_input.h:941

SDL_Libretro_GetRewindMemoryUsage
size_t SDL_Libretro_GetRewindMemoryUsage(const SDL_Libretro *lr)
Get the approximate memory currently held by the rewind buffer, in bytes.
Definition SDL_libretro_serialize.h:1290

SDL_Libretro_GetValidExtensions
const char * SDL_Libretro_GetValidExtensions(const SDL_Libretro *lr)
Gets the default set of valid extensions associated with the core, seperated by a "|".
Definition SDL_libretro_core.h:2239

SDL_Libretro_SetMenuOpen
void SDL_Libretro_SetMenuOpen(SDL_LibretroMenu *menu, bool open)
Opens or closes the menu.
Definition SDL_libretro_menu.h:2532

SDL_Libretro_GetCategoryCount
unsigned SDL_Libretro_GetCategoryCount(const SDL_Libretro *lr)
Get the number of option categories registered by the core.
Definition SDL_libretro_options.h:502

SDL_Libretro_InitConfig
bool SDL_Libretro_InitConfig(SDL_Libretro *lr, const char *org, const char *app)
Sets up the config file to be the default path, accoring to the organization and app name.
Definition SDL_libretro_config.h:168

SDL_Libretro_SaveSRAM_IO
bool SDL_Libretro_SaveSRAM_IO(SDL_Libretro *lr, SDL_IOStream *dst, bool closeio)
Write the core's battery-backed save RAM to a stream.
Definition SDL_libretro_serialize.h:945

SDL_Libretro_InitConfigFile
bool SDL_Libretro_InitConfigFile(SDL_Libretro *lr, const char *file)
Initializes the config system based on the given file.
Definition SDL_libretro_config.h:39

SDL_Libretro_GetMemoryMapCount
unsigned SDL_Libretro_GetMemoryMapCount(const SDL_Libretro *lr)
Get the number of memory-map descriptors the core has published.
Definition SDL_libretro_serialize.h:641

SDL_Libretro_PhysFS_Init
bool SDL_Libretro_PhysFS_Init(SDL_Libretro *lr)
Initialize PhysFS and route the libretro VFS through it.
Definition SDL_libretro_physfs.h:178

SDL_Libretro_AddMenuCheckbox
bool SDL_Libretro_AddMenuCheckbox(SDL_LibretroMenu *menu, const char *label, bool *value, SDL_LibretroMenuCallback callback, void *userdata)
Adds a checkbox to the main menu, just above Quit.
Definition SDL_libretro_menu.h:2921

SDL_Libretro_LoadGame_IO
bool SDL_Libretro_LoadGame_IO(SDL_Libretro *lr, SDL_IOStream *src, const char *path, bool closeio)
Loads a game from an SDL_IOStream.
Definition SDL_libretro_core.h:1131

SDL_Libretro_SetInitialDisk
bool SDL_Libretro_SetInitialDisk(SDL_Libretro *lr, unsigned index, const char *path)
Sets the disk image to insert once content is loaded.
Definition SDL_libretro_serialize.h:373

SDL_Libretro_GetBlockExtract
bool SDL_Libretro_GetBlockExtract(const SDL_Libretro *lr)
Retrieves whether the core expects archives to be loaded directly.
Definition SDL_libretro_core.h:2292

SDL_Libretro_LoadSRAM_IO
bool SDL_Libretro_LoadSRAM_IO(SDL_Libretro *lr, SDL_IOStream *src, bool closeio)
Load the core's battery-backed save RAM from a stream.
Definition SDL_libretro_serialize.h:976

SDL_Libretro_GetMessageType
int SDL_Libretro_GetMessageType(SDL_Libretro *lr)
Gets the type of the message returned by SDL_Libretro_GetMessage().
Definition SDL_libretro_messages.h:186

SDL_Libretro_GetDiskIndex
unsigned SDL_Libretro_GetDiskIndex(const SDL_Libretro *lr)
Returns the index of the currently inserted disk image.
Definition SDL_libretro_serialize.h:102

SDL_Libretro_SetDiskIndex
bool SDL_Libretro_SetDiskIndex(SDL_Libretro *lr, unsigned index)
Sets the disk image index to insert into the emulated drive.
Definition SDL_libretro_serialize.h:116

SDL_Libretro_GetMessage
const char * SDL_Libretro_GetMessage(SDL_Libretro *lr)
Gets the most relevant libretro message to display from the queue.
Definition SDL_libretro_messages.h:153

SDL_Libretro_SetVFS
void SDL_Libretro_SetVFS(SDL_Libretro *lr, void *vfs)
Set the Virtual File System the core uses for file access.
Definition SDL_libretro_vfs.h:562

SDL_Libretro_GetFPS
double SDL_Libretro_GetFPS(const SDL_Libretro *lr)
Gets the frame rate the core expects to run at.
Definition SDL_libretro_video.h:381

SDL_Libretro_GetOptionValueLabel
const char * SDL_Libretro_GetOptionValueLabel(SDL_Libretro *lr, const char *key)
Get the human-readable label for a core option's current value.
Definition SDL_libretro_options.h:365

SDL_Libretro_GetLogLevel
SDL_LogPriority SDL_Libretro_GetLogLevel(const SDL_Libretro *lr)
Retrieve the threshold for logs that will be posted.
Definition SDL_libretro_core.h:2189

SDL_Libretro_GetSpeed
float SDL_Libretro_GetSpeed(const SDL_Libretro *lr)
Get how fast the game runs, as a multiple of its normal speed.
Definition SDL_libretro_core.h:2142

SDL_Libretro_PhysFS_Quit
void SDL_Libretro_PhysFS_Quit(SDL_Libretro *lr)
Tear down PhysFS, unmounting any active archive and restoring the plain SDL VFS on the given context.
Definition SDL_libretro_physfs.h:208

SDL_Libretro_LoadState
bool SDL_Libretro_LoadState(SDL_Libretro *lr, const char *file)
Loads the libretro state from the given file.
Definition SDL_libretro_serialize.h:549

SDL_Libretro_SetFitMode
bool SDL_Libretro_SetFitMode(SDL_Libretro *lr, SDL_LibretroFitMode mode)
Sets how the frame is fit into the destination rectangle when rendered.
Definition SDL_libretro_video.h:407

SDL_Libretro_GetSavestateContext
enum retro_savestate_context SDL_Libretro_GetSavestateContext(const SDL_Libretro *lr)
Get the savestate context reported to cores through RETRO_ENVIRONMENT_GET_SAVESTATE_CONTEXT.
Definition SDL_libretro_core.h:2263

SDL_Libretro_AddDiskImage_IO
bool SDL_Libretro_AddDiskImage_IO(SDL_Libretro *lr, SDL_IOStream *src, const char *path, bool closeio)
Appends a new disk image from an SDL_IOStream.
Definition SDL_libretro_serialize.h:280

SDL_Libretro_GetOptionByIndex
const SDL_LibretroOption * SDL_Libretro_GetOptionByIndex(const SDL_Libretro *lr, unsigned index)
Retrieve a core option by its registration index.
Definition SDL_libretro_options.h:287

SDL_Libretro_GetMessageCount
unsigned SDL_Libretro_GetMessageCount(SDL_Libretro *lr)
Gets the number of messages currently in the queue.
Definition SDL_libretro_messages.h:203

SDL_Libretro_SetVolume
void SDL_Libretro_SetVolume(SDL_Libretro *lr, float volume)
Set the audio volume when playing sounds.
Definition SDL_libretro_core.h:2066

SDL_Libretro_GetStateSize
size_t SDL_Libretro_GetStateSize(const SDL_Libretro *lr)
Retrieves the size of serialized states.
Definition SDL_libretro_serialize.h:431

SDL_Libretro_SaveMemory
bool SDL_Libretro_SaveMemory(SDL_Libretro *lr, unsigned memoryType, const char *file)
Write a core memory region to a file.
Definition SDL_libretro_serialize.h:787

SDL_Libretro_GetCoreAssetsDirectory
const char * SDL_Libretro_GetCoreAssetsDirectory(SDL_Libretro *lr)
Get the core assets directory.
Definition SDL_libretro_core.h:2021

SDL_Libretro_LoadState_IO
bool SDL_Libretro_LoadState_IO(SDL_Libretro *lr, SDL_IOStream *src, bool closeio)
Load a libretro state from the given SDL_IOStream.
Definition SDL_libretro_serialize.h:514

SDL_Libretro_GetOptionValue
const char * SDL_Libretro_GetOptionValue(SDL_Libretro *lr, const char *key)
Get a core option's current value.
Definition SDL_libretro_options.h:347

SDL_Libretro
struct SDL_Libretro SDL_Libretro
A libretro frontend context: one loaded core, its game, and the settings that carry across cores.
Definition SDL_libretro.h:93

SDL_Libretro_GetDiskLabel
bool SDL_Libretro_GetDiskLabel(const SDL_Libretro *lr, unsigned index, char *label, size_t len)
Retrieves the human-readable label of a disk image.
Definition SDL_libretro_serialize.h:349

SDL_Libretro_LoadGame
bool SDL_Libretro_LoadGame(SDL_Libretro *lr, const char *gamePath)
Loads a game at the given path.
Definition SDL_libretro_core.h:987

SDL_Libretro_GetAspectRatio
float SDL_Libretro_GetAspectRatio(const SDL_Libretro *lr)
Gets the aspect ratio for the libretro context.
Definition SDL_libretro_video.h:371

SDL_Libretro_GetRenderer
SDL_Renderer * SDL_Libretro_GetRenderer(const SDL_Libretro *lr)
Get the renderer the context draws into.
Definition SDL_libretro_video.h:168

SDL_Libretro_SetSRAMAutoSave
void SDL_Libretro_SetSRAMAutoSave(SDL_Libretro *lr, bool enabled)
Load and save the core's battery-backed save RAM along with the game.
Definition SDL_libretro_serialize.h:893

SDL_Libretro_ShouldQuit
bool SDL_Libretro_ShouldQuit(const SDL_Libretro *lr)
Indicates whether or not the core has requested to shutdown.
Definition SDL_libretro_core.h:1636

SDL_Libretro_LoadMemory_IO
bool SDL_Libretro_LoadMemory_IO(SDL_Libretro *lr, unsigned memoryType, SDL_IOStream *src, bool closeio)
Load a core memory region from a stream.
Definition SDL_libretro_serialize.h:822

SDL_Libretro_GetMenuLibretro
SDL_Libretro * SDL_Libretro_GetMenuLibretro(const SDL_LibretroMenu *menu)
Gets the libretro context the menu was created for.
Definition SDL_libretro_menu.h:2485

SDL_Libretro_ResetOption
bool SDL_Libretro_ResetOption(SDL_Libretro *lr, const char *key)
Reset a core option to its default value.
Definition SDL_libretro_options.h:424

SDL_Libretro_SetGamepadMapping
void SDL_Libretro_SetGamepadMapping(SDL_Libretro *lr, unsigned port, int retroButton, SDL_GamepadButton button)
Maps an SDL gamepad button to a RETRO_DEVICE_ID_JOYPAD_* button on the given controller port.
Definition SDL_libretro_input.h:816

SDL_Libretro_SetAudioLatency
void SDL_Libretro_SetAudioLatency(SDL_Libretro *lr, unsigned latencyMs)
Set the desired minimum audio latency for the audio stream.
Definition SDL_libretro_audio.h:314

SDL_Libretro_GetVolume
float SDL_Libretro_GetVolume(const SDL_Libretro *lr)
Get the audio volume.
Definition SDL_libretro_core.h:2082

SDL_Libretro_Destroy
void SDL_Libretro_Destroy(SDL_Libretro *lr)
Destroys the given libretro context.
Definition SDL_libretro_core.h:150

SDL_Libretro_LoadMemory
bool SDL_Libretro_LoadMemory(SDL_Libretro *lr, unsigned memoryType, const char *file)
Load a core memory region from a file.
Definition SDL_libretro_serialize.h:862

SDL_Libretro_OpenMenuPath
bool SDL_Libretro_OpenMenuPath(SDL_LibretroMenu *menu, const char *path)
Opens the menu and navigates to a page by its slash-separated label path, e.g.
Definition SDL_libretro_menu.h:2725

SDL_Libretro_SetMousePort
void SDL_Libretro_SetMousePort(SDL_Libretro *lr, unsigned port)
Selects the one controller port that the mouse drives.
Definition SDL_libretro_input.h:868

SDL_Libretro_Create
SDL_Libretro * SDL_Libretro_Create(void)
Creates a new libretro context.
Definition SDL_libretro_core.h:95

SDL_Libretro_SetMenuStyle
bool SDL_Libretro_SetMenuStyle(SDL_LibretroMenu *menu, SDL_LibretroMenuStyle style)
Applies a color theme to the menu.
Definition SDL_libretro_menu.h:2034

SDL_Libretro_CreateMenu
SDL_LibretroMenu * SDL_Libretro_CreateMenu(SDL_Libretro *lr)
Creates the in-app menu for a libretro context.
Definition SDL_libretro_menu.h:2369

SDL_Libretro_GetRewindEnabled
bool SDL_Libretro_GetRewindEnabled(const SDL_Libretro *lr)
Check whether the rewind system is enabled (independent of current direction).
Definition SDL_libretro_serialize.h:1265

SDL_Libretro_GetSystemDirectory
const char * SDL_Libretro_GetSystemDirectory(SDL_Libretro *lr)
Get the system directory.
Definition SDL_libretro_core.h:2008

SDL_Libretro_UnloadGame
void SDL_Libretro_UnloadGame(SDL_Libretro *lr)
Unloads the actively loaded game.
Definition SDL_libretro_core.h:1349

SDL_Libretro_SetOptionValue
bool SDL_Libretro_SetOptionValue(SDL_Libretro *lr, const char *key, const char *value)
Set a core option's value; fails if the value isn't one the core declared.
Definition SDL_libretro_options.h:306

SDL_Libretro_ResetAllOptions
void SDL_Libretro_ResetAllOptions(SDL_Libretro *lr)
Reset every core option to its default value.
Definition SDL_libretro_options.h:447

SDL_Libretro_GetAnalogToDigital
SDL_LibretroAnalogToDigital SDL_Libretro_GetAnalogToDigital(const SDL_Libretro *lr, unsigned port)
Get the analog stick that also registers D-Pad presses on a controller port.
Definition SDL_libretro_input.h:853

SDL_Libretro_SetSaveDirectory
bool SDL_Libretro_SetSaveDirectory(SDL_Libretro *lr, const char *path)
Sets where content will be saved.
Definition SDL_libretro_core.h:1910

SDL_Libretro_GetDiskCount
unsigned SDL_Libretro_GetDiskCount(const SDL_Libretro *lr)
Returns the number of disk images available to the loaded core.
Definition SDL_libretro_serialize.h:91

SDL_Libretro_SaveState
bool SDL_Libretro_SaveState(SDL_Libretro *lr, const char *file)
Saves the current libretro state to a file.
Definition SDL_libretro_serialize.h:488

SDL_Libretro_GetRewindMemoryLimit
size_t SDL_Libretro_GetRewindMemoryLimit(const SDL_Libretro *lr)
Get the current rewind memory budget in bytes (0 if unbounded).
Definition SDL_libretro_serialize.h:1322

SDL_Libretro_GetSize
void SDL_Libretro_GetSize(const SDL_Libretro *lr, int *w, int *h)
Gets the width and height of the core's current video frame.
Definition SDL_libretro_video.h:358

SDL_Libretro_LoadGameSpecialById
bool SDL_Libretro_LoadGameSpecialById(SDL_Libretro *lr, unsigned subsystemId, const char **paths, unsigned numPaths)
Load multi-ROM subsystem content by its numeric subsystem id.
Definition SDL_libretro_core.h:1189

SDL_Libretro_SetMemoryData
bool SDL_Libretro_SetMemoryData(SDL_Libretro *lr, unsigned memoryType, const void *data, size_t size)
Overwrite a core memory region with caller-provided bytes.
Definition SDL_libretro_serialize.h:596

SDL_Libretro_GetRewindRemaining
double SDL_Libretro_GetRewindRemaining(const SDL_Libretro *lr)
Calculates the amount of rewind time remaining in the buffer.
Definition SDL_libretro_serialize.h:1275

SDL_Libretro_GetLanguage
int SDL_Libretro_GetLanguage(const SDL_Libretro *lr)
Get the language reported to cores through RETRO_ENVIRONMENT_GET_LANGUAGE.
Definition SDL_libretro_env.h:323

SDL_Libretro_GetOptionCount
unsigned SDL_Libretro_GetOptionCount(const SDL_Libretro *lr)
Get the number of core options that have been set.
Definition SDL_libretro_options.h:248

SDL_Libretro_SetMenuUserData
void SDL_Libretro_SetMenuUserData(SDL_LibretroMenu *menu, void *userData)
Attaches generic application data to the menu.
Definition SDL_libretro_menu.h:2499

SDL_Libretro_IsGameReady
bool SDL_Libretro_IsGameReady(const SDL_Libretro *lr)
Indicates whether a game is loaded and running.
Definition SDL_libretro_core.h:1383

SDL_Libretro_InsertDisk
bool SDL_Libretro_InsertDisk(SDL_Libretro *lr)
Closes the disk tray after a disk change.
Definition SDL_libretro_serialize.h:148

SDL_Libretro_LoadCore
bool SDL_Libretro_LoadCore(SDL_Libretro *lr, const char *core)
Loads a libretro core.
Definition SDL_libretro_core.h:210

SDL_Libretro_SetUsername
bool SDL_Libretro_SetUsername(SDL_Libretro *lr, const char *username)
Sets the username reported to cores through RETRO_ENVIRONMENT_GET_USERNAME.
Definition SDL_libretro_core.h:2037

SDL_Libretro_AddMenuButton
bool SDL_Libretro_AddMenuButton(SDL_LibretroMenu *menu, const char *label, SDL_LibretroMenuCallback callback, void *userdata)
Adds a button to the main menu, just above Quit.
Definition SDL_libretro_menu.h:2894

SDL_Libretro_SetVirtualButton
void SDL_Libretro_SetVirtualButton(SDL_Libretro *lr, unsigned port, int button, bool pressed)
Press or release a joypad button from code, such as from an on-screen touch control.
Definition SDL_libretro_input.h:898

SDL_Libretro_GetMapAddress
void * SDL_Libretro_GetMapAddress(const SDL_Libretro *lr, size_t address, size_t *regionRemaining)
Translate an emulated (guest) address to a live host pointer via the memory map.
Definition SDL_libretro_serialize.h:704

SDL_Libretro_SetRenderer
bool SDL_Libretro_SetRenderer(SDL_Libretro *lr, SDL_Renderer *renderer)
Set the renderer the libretro context draws into.
Definition SDL_libretro_video.h:141

SDL_Libretro_IsGameRequired
bool SDL_Libretro_IsGameRequired(const SDL_Libretro *lr)
Indicates whether the loaded core needs content to run.
Definition SDL_libretro_core.h:1400

SDL_Libretro_GetMenuStyle
SDL_LibretroMenuStyle SDL_Libretro_GetMenuStyle(const SDL_LibretroMenu *menu)
Gets the menu's active color theme.
Definition SDL_libretro_menu.h:2061

SDL_Libretro_HandleEvent
void SDL_Libretro_HandleEvent(SDL_Libretro *lr, const SDL_Event *event)
Call this function within the SDL_PollEvent() loop to ensure libretro knows of important events.
Definition SDL_libretro_input.h:663

SDL_Libretro_MenuScreenshotClicked
void SDL_Libretro_MenuScreenshotClicked(SDL_LibretroMenu *menu, void *userdata)
A ready-made menu callback that saves a PNG screenshot of the current frame, reporting the result in ...
Definition SDL_libretro_menu.h:462

SDL_Libretro_GetTexture
SDL_Texture * SDL_Libretro_GetTexture(const SDL_Libretro *lr)
Get the streaming texture that holds the core's most recent video frame.
Definition SDL_libretro_video.h:185

SDL_Libretro_SetScaleMode
bool SDL_Libretro_SetScaleMode(SDL_Libretro *lr, SDL_ScaleMode mode)
Sets the texture scale mode used when the libretro frame is scaled.
Definition SDL_libretro_video.h:438

SDL_Libretro_GetAudioLatency
unsigned SDL_Libretro_GetAudioLatency(const SDL_Libretro *lr)
Get the minimum audio latency for the audio stream.
Definition SDL_libretro_audio.h:332

SDL_Libretro_SetAnalogToDigital
void SDL_Libretro_SetAnalogToDigital(SDL_Libretro *lr, unsigned port, SDL_LibretroAnalogToDigital stick)
Selects which analog stick, if any, also registers D-Pad presses on the given controller port,...
Definition SDL_libretro_input.h:835

SDL_Libretro_GetCoreDirectory
const char * SDL_Libretro_GetCoreDirectory(SDL_Libretro *lr)
Get the core directory.
Definition SDL_libretro_core.h:1982

SDL_Libretro_GetSaveDirectory
const char * SDL_Libretro_GetSaveDirectory(SDL_Libretro *lr)
Get the save directory.
Definition SDL_libretro_core.h:1995

SDL_Libretro_HandleMenuEvent
bool SDL_Libretro_HandleMenuEvent(SDL_LibretroMenu *menu, const SDL_Event *event)
Routes an event to the menu; call this for every event, before SDL_Libretro_HandleEvent().
Definition SDL_libretro_menu.h:2598

SDL_Libretro_SetSavestateContext
void SDL_Libretro_SetSavestateContext(SDL_Libretro *lr, enum retro_savestate_context context)
Sets the savestate context reported to cores through RETRO_ENVIRONMENT_GET_SAVESTATE_CONTEXT.
Definition SDL_libretro_core.h:2282

SDL_Libretro_ToggleMenu
void SDL_Libretro_ToggleMenu(SDL_LibretroMenu *menu)
Opens the menu when it is closed, or closes it when it is open.
Definition SDL_libretro_menu.h:2569

SDL_Libretro_IsFastforwardOverrideActive
bool SDL_Libretro_IsFastforwardOverrideActive(const SDL_Libretro *lr)
Indicates whether the core is forcing fast-forward through RETRO_ENVIRONMENT_SET_FASTFORWARDING_OVERR...
Definition SDL_libretro_core.h:2157

SDL_Libretro_SaveMemory_IO
bool SDL_Libretro_SaveMemory_IO(SDL_Libretro *lr, unsigned memoryType, SDL_IOStream *dst, bool closeio)
Write a core memory region to a stream.
Definition SDL_libretro_serialize.h:757

SDL_LibretroAnalogToDigital
SDL_LibretroAnalogToDigital
Which analog stick, if any, also registers D-Pad presses for a controller port.
Definition SDL_libretro.h:111

SDL_Libretro_GetMousePort
unsigned SDL_Libretro_GetMousePort(const SDL_Libretro *lr)
Get the controller port that the mouse drives.
Definition SDL_libretro_input.h:881

SDL_Libretro_GetOption
const SDL_LibretroOption * SDL_Libretro_GetOption(const SDL_Libretro *lr, const char *key)
Retrieve details about a given core option.
Definition SDL_libretro_options.h:265

SDL_Libretro_SetLanguage
void SDL_Libretro_SetLanguage(SDL_Libretro *lr, int language)
Override the language reported to cores through RETRO_ENVIRONMENT_GET_LANGUAGE.
Definition SDL_libretro_env.h:318

SDL_Libretro_GetCoreName
const char * SDL_Libretro_GetCoreName(const SDL_Libretro *lr)
Retrieve the name of the libretro core that's actively loaded.
Definition SDL_libretro_core.h:2206

SDL_Libretro_SetKeyboardMapping
void SDL_Libretro_SetKeyboardMapping(SDL_Libretro *lr, int retroButton, SDL_Scancode scancode)
Maps a keyboard key to a RETRO_DEVICE_ID_JOYPAD_* button for Player 1 (controller port 0).
Definition SDL_libretro_input.h:801

SDL_Libretro_SetSpeed
void SDL_Libretro_SetSpeed(SDL_Libretro *lr, float speed)
Sets how fast the game runs, as a multiple of its normal speed.
Definition SDL_libretro_core.h:2105

SDL_LIBRETRO_FIT_STRETCH
@ SDL_LIBRETRO_FIT_STRETCH
Ignore the aspect ratio, and stretch the image to match the destination rectangle.
Definition SDL_libretro.h:102

SDL_LIBRETRO_FIT_FIRST
@ SDL_LIBRETRO_FIT_FIRST
The default fit mode to fit within the destination.
Definition SDL_libretro.h:99

SDL_LIBRETRO_FIT_INTEGER
@ SDL_LIBRETRO_FIT_INTEGER
Keep the same aspect ratio, while keeping integer scaling within the confines of the destination.
Definition SDL_libretro.h:101

SDL_LIBRETRO_FIT_COUNT
@ SDL_LIBRETRO_FIT_COUNT
The number of possible fit modes.
Definition SDL_libretro.h:103

SDL_LIBRETRO_FIT_ASPECT
@ SDL_LIBRETRO_FIT_ASPECT
Keep the same aspect ratio, and fit within the confines of the destination.
Definition SDL_libretro.h:100

SDL_LIBRETRO_MENU_STYLE_CATPPUCCIN_LATTE
@ SDL_LIBRETRO_MENU_STYLE_CATPPUCCIN_LATTE
Catppuccin Latte, the light Catppuccin flavor.
Definition SDL_libretro.h:477

SDL_LIBRETRO_MENU_STYLE_CATPPUCCIN_FRAPPE
@ SDL_LIBRETRO_MENU_STYLE_CATPPUCCIN_FRAPPE
Catppuccin Frappe, a muted dark Catppuccin flavor.
Definition SDL_libretro.h:478

SDL_LIBRETRO_MENU_STYLE_COUNT
@ SDL_LIBRETRO_MENU_STYLE_COUNT
The number of menu styles.
Definition SDL_libretro.h:482

SDL_LIBRETRO_MENU_STYLE_DARK
@ SDL_LIBRETRO_MENU_STYLE_DARK
Nuklear's built-in default dark style.
Definition SDL_libretro.h:481

SDL_LIBRETRO_MENU_STYLE_DRACULA
@ SDL_LIBRETRO_MENU_STYLE_DRACULA
The Dracula dark theme.
Definition SDL_libretro.h:480

SDL_LIBRETRO_MENU_STYLE_CATPPUCCIN_MOCHA
@ SDL_LIBRETRO_MENU_STYLE_CATPPUCCIN_MOCHA
Catppuccin Mocha, the darkest Catppuccin flavor.
Definition SDL_libretro.h:476

SDL_LIBRETRO_MENU_STYLE_CATPPUCCIN_MACCHIATO
@ SDL_LIBRETRO_MENU_STYLE_CATPPUCCIN_MACCHIATO
Catppuccin Macchiato, a dark Catppuccin flavor between Frappe and Mocha.
Definition SDL_libretro.h:479

SDL_LIBRETRO_ANALOG_TO_DIGITAL_NONE
@ SDL_LIBRETRO_ANALOG_TO_DIGITAL_NONE
Only the D-Pad drives the retro joypad's directions.
Definition SDL_libretro.h:112

SDL_LIBRETRO_ANALOG_TO_DIGITAL_RIGHT
@ SDL_LIBRETRO_ANALOG_TO_DIGITAL_RIGHT
The right analog stick also registers D-Pad presses.
Definition SDL_libretro.h:114

SDL_LIBRETRO_ANALOG_TO_DIGITAL_LEFT
@ SDL_LIBRETRO_ANALOG_TO_DIGITAL_LEFT
The left analog stick also registers D-Pad presses.
Definition SDL_libretro.h:113

SDL_LIBRETRO_ANALOG_TO_DIGITAL_COUNT
@ SDL_LIBRETRO_ANALOG_TO_DIGITAL_COUNT
The number of possible modes.
Definition SDL_libretro.h:115

SDL_LibretroCategory
A group of related core options.
Definition SDL_libretro.h:364

SDL_LibretroCategory::key
const char * key
Unique identifier referenced by SDL_LibretroOption::category.
Definition SDL_libretro.h:365

SDL_LibretroCategory::desc
const char * desc
Human-readable name.
Definition SDL_libretro.h:366

SDL_LibretroCategory::info
const char * info
Description / help text; may be empty.
Definition SDL_libretro.h:367

SDL_LibretroOption
A core option and its current state.
Definition SDL_libretro.h:348

SDL_LibretroOption::visible
bool visible
Whether the frontend should display it.
Definition SDL_libretro.h:355

SDL_LibretroOption::values
SDL_LibretroOptionValue * values
The selectable values; dynamically allocated.
Definition SDL_libretro.h:357

SDL_LibretroOption::valuesCapacity
unsigned valuesCapacity
Allocated capacity of the values array.
Definition SDL_libretro.h:358

SDL_LibretroOption::desc
const char * desc
Human-readable name.
Definition SDL_libretro.h:350

SDL_LibretroOption::value
const char * value
The current value.
Definition SDL_libretro.h:352

SDL_LibretroOption::category
const char * category
Key of the category it belongs to; empty if none.
Definition SDL_libretro.h:354

SDL_LibretroOption::valuesCount
unsigned valuesCount
The number of populated entries in values.
Definition SDL_libretro.h:356

SDL_LibretroOption::key
const char * key
Unique identifier the core queries.
Definition SDL_libretro.h:349

SDL_LibretroOption::defaultValue
const char * defaultValue
The default value.
Definition SDL_libretro.h:353

SDL_LibretroOption::info
const char * info
Description / help text; may be empty.
Definition SDL_libretro.h:351

SDL_LibretroOptionValue
One selectable value for a core option.
Definition SDL_libretro.h:340

SDL_LibretroOptionValue::value
const char * value
The value the core stores.
Definition SDL_libretro.h:341

SDL_LibretroOptionValue::label
const char * label
Human-readable name; may be NULL, in which case display value itself.
Definition SDL_libretro.h:342