1 /* Copyright (C) 2010-2016 The RetroArch team 2 * 3 * --------------------------------------------------------------------------------------- 4 * The following license statement only applies to this libretro API header (libretro.h). 5 * --------------------------------------------------------------------------------------- 6 * 7 * Permission is hereby granted, free of charge, 8 * to any person obtaining a copy of this software and associated documentation files (the "Software"), 9 * to deal in the Software without restriction, including without limitation the rights to 10 * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, 11 * and to permit persons to whom the Software is furnished to do so, subject to the following conditions: 12 * 13 * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. 14 * 15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, 16 * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 18 * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, 19 * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 21 */ 22 23 #ifndef LIBRETRO_H__ 24 #define LIBRETRO_H__ 25 26 #include <stdint.h> 27 #include <stddef.h> 28 #include <limits.h> 29 30 #ifdef __cplusplus 31 extern "C" { 32 #endif 33 34 #ifndef __cplusplus 35 #if defined(_MSC_VER) && !defined(SN_TARGET_PS3) 36 /* Hack applied for MSVC when compiling in C89 mode 37 * as it isn't C99-compliant. */ 38 #define bool unsigned char 39 #define true 1 40 #define false 0 41 #else 42 #include <stdbool.h> 43 #endif 44 #endif 45 46 #ifndef RETRO_CALLCONV 47 # if defined(__GNUC__) && defined(__i386__) && !defined(__x86_64__) 48 # define RETRO_CALLCONV __attribute__((cdecl)) 49 # elif defined(_MSC_VER) && defined(_M_X86) && !defined(_M_X64) 50 # define RETRO_CALLCONV __cdecl 51 # else 52 # define RETRO_CALLCONV /* all other platforms only have one calling convention each */ 53 # endif 54 #endif 55 56 #ifndef RETRO_API 57 # if defined(_WIN32) || defined(__CYGWIN__) || defined(__MINGW32__) 58 # ifdef RETRO_IMPORT_SYMBOLS 59 # ifdef __GNUC__ 60 # define RETRO_API RETRO_CALLCONV __attribute__((__dllimport__)) 61 # else 62 # define RETRO_API RETRO_CALLCONV __declspec(dllimport) 63 # endif 64 # else 65 # ifdef __GNUC__ 66 # define RETRO_API RETRO_CALLCONV __attribute__((__dllexport__)) 67 # else 68 # define RETRO_API RETRO_CALLCONV __declspec(dllexport) 69 # endif 70 # endif 71 # else 72 # if defined(__GNUC__) && __GNUC__ >= 4 73 # define RETRO_API RETRO_CALLCONV __attribute__((__visibility__("default"))) 74 # else 75 # define RETRO_API RETRO_CALLCONV 76 # endif 77 # endif 78 #endif 79 80 /* Used for checking API/ABI mismatches that can break libretro 81 * implementations. 82 * It is not incremented for compatible changes to the API. 83 */ 84 #define RETRO_API_VERSION 1 85 86 /* 87 * Libretro's fundamental device abstractions. 88 * 89 * Libretro's input system consists of some standardized device types, 90 * such as a joypad (with/without analog), mouse, keyboard, lightgun 91 * and a pointer. 92 * 93 * The functionality of these devices are fixed, and individual cores 94 * map their own concept of a controller to libretro's abstractions. 95 * This makes it possible for frontends to map the abstract types to a 96 * real input device, and not having to worry about binding input 97 * correctly to arbitrary controller layouts. 98 */ 99 100 #define RETRO_DEVICE_TYPE_SHIFT 8 101 #define RETRO_DEVICE_MASK ((1 << RETRO_DEVICE_TYPE_SHIFT) - 1) 102 #define RETRO_DEVICE_SUBCLASS(base, id) (((id + 1) << RETRO_DEVICE_TYPE_SHIFT) | base) 103 104 /* Input disabled. */ 105 #define RETRO_DEVICE_NONE 0 106 107 /* The JOYPAD is called RetroPad. It is essentially a Super Nintendo 108 * controller, but with additional L2/R2/L3/R3 buttons, similar to a 109 * PS1 DualShock. */ 110 #define RETRO_DEVICE_JOYPAD 1 111 112 /* The mouse is a simple mouse, similar to Super Nintendo's mouse. 113 * X and Y coordinates are reported relatively to last poll (poll callback). 114 * It is up to the libretro implementation to keep track of where the mouse 115 * pointer is supposed to be on the screen. 116 * The frontend must make sure not to interfere with its own hardware 117 * mouse pointer. 118 */ 119 #define RETRO_DEVICE_MOUSE 2 120 121 /* KEYBOARD device lets one poll for raw key pressed. 122 * It is poll based, so input callback will return with the current 123 * pressed state. 124 * For event/text based keyboard input, see 125 * RETRO_ENVIRONMENT_SET_KEYBOARD_CALLBACK. 126 */ 127 #define RETRO_DEVICE_KEYBOARD 3 128 129 /* Lightgun X/Y coordinates are reported relatively to last poll, 130 * similar to mouse. */ 131 #define RETRO_DEVICE_LIGHTGUN 4 132 133 /* The ANALOG device is an extension to JOYPAD (RetroPad). 134 * Similar to DualShock it adds two analog sticks. 135 * This is treated as a separate device type as it returns values in the 136 * full analog range of [-0x8000, 0x7fff]. Positive X axis is right. 137 * Positive Y axis is down. 138 * Only use ANALOG type when polling for analog values of the axes. 139 */ 140 #define RETRO_DEVICE_ANALOG 5 141 142 /* Abstracts the concept of a pointing mechanism, e.g. touch. 143 * This allows libretro to query in absolute coordinates where on the 144 * screen a mouse (or something similar) is being placed. 145 * For a touch centric device, coordinates reported are the coordinates 146 * of the press. 147 * 148 * Coordinates in X and Y are reported as: 149 * [-0x7fff, 0x7fff]: -0x7fff corresponds to the far left/top of the screen, 150 * and 0x7fff corresponds to the far right/bottom of the screen. 151 * The "screen" is here defined as area that is passed to the frontend and 152 * later displayed on the monitor. 153 * 154 * The frontend is free to scale/resize this screen as it sees fit, however, 155 * (X, Y) = (-0x7fff, -0x7fff) will correspond to the top-left pixel of the 156 * game image, etc. 157 * 158 * To check if the pointer coordinates are valid (e.g. a touch display 159 * actually being touched), PRESSED returns 1 or 0. 160 * 161 * If using a mouse on a desktop, PRESSED will usually correspond to the 162 * left mouse button, but this is a frontend decision. 163 * PRESSED will only return 1 if the pointer is inside the game screen. 164 * 165 * For multi-touch, the index variable can be used to successively query 166 * more presses. 167 * If index = 0 returns true for _PRESSED, coordinates can be extracted 168 * with _X, _Y for index = 0. One can then query _PRESSED, _X, _Y with 169 * index = 1, and so on. 170 * Eventually _PRESSED will return false for an index. No further presses 171 * are registered at this point. */ 172 #define RETRO_DEVICE_POINTER 6 173 174 /* Buttons for the RetroPad (JOYPAD). 175 * The placement of these is equivalent to placements on the 176 * Super Nintendo controller. 177 * L2/R2/L3/R3 buttons correspond to the PS1 DualShock. */ 178 #define RETRO_DEVICE_ID_JOYPAD_B 0 179 #define RETRO_DEVICE_ID_JOYPAD_Y 1 180 #define RETRO_DEVICE_ID_JOYPAD_SELECT 2 181 #define RETRO_DEVICE_ID_JOYPAD_START 3 182 #define RETRO_DEVICE_ID_JOYPAD_UP 4 183 #define RETRO_DEVICE_ID_JOYPAD_DOWN 5 184 #define RETRO_DEVICE_ID_JOYPAD_LEFT 6 185 #define RETRO_DEVICE_ID_JOYPAD_RIGHT 7 186 #define RETRO_DEVICE_ID_JOYPAD_A 8 187 #define RETRO_DEVICE_ID_JOYPAD_X 9 188 #define RETRO_DEVICE_ID_JOYPAD_L 10 189 #define RETRO_DEVICE_ID_JOYPAD_R 11 190 #define RETRO_DEVICE_ID_JOYPAD_L2 12 191 #define RETRO_DEVICE_ID_JOYPAD_R2 13 192 #define RETRO_DEVICE_ID_JOYPAD_L3 14 193 #define RETRO_DEVICE_ID_JOYPAD_R3 15 194 195 /* Index / Id values for ANALOG device. */ 196 #define RETRO_DEVICE_INDEX_ANALOG_LEFT 0 197 #define RETRO_DEVICE_INDEX_ANALOG_RIGHT 1 198 #define RETRO_DEVICE_ID_ANALOG_X 0 199 #define RETRO_DEVICE_ID_ANALOG_Y 1 200 201 /* Id values for MOUSE. */ 202 #define RETRO_DEVICE_ID_MOUSE_X 0 203 #define RETRO_DEVICE_ID_MOUSE_Y 1 204 #define RETRO_DEVICE_ID_MOUSE_LEFT 2 205 #define RETRO_DEVICE_ID_MOUSE_RIGHT 3 206 #define RETRO_DEVICE_ID_MOUSE_WHEELUP 4 207 #define RETRO_DEVICE_ID_MOUSE_WHEELDOWN 5 208 #define RETRO_DEVICE_ID_MOUSE_MIDDLE 6 209 #define RETRO_DEVICE_ID_MOUSE_HORIZ_WHEELUP 7 210 #define RETRO_DEVICE_ID_MOUSE_HORIZ_WHEELDOWN 8 211 212 /* Id values for LIGHTGUN types. */ 213 #define RETRO_DEVICE_ID_LIGHTGUN_X 0 214 #define RETRO_DEVICE_ID_LIGHTGUN_Y 1 215 #define RETRO_DEVICE_ID_LIGHTGUN_TRIGGER 2 216 #define RETRO_DEVICE_ID_LIGHTGUN_CURSOR 3 217 #define RETRO_DEVICE_ID_LIGHTGUN_TURBO 4 218 #define RETRO_DEVICE_ID_LIGHTGUN_PAUSE 5 219 #define RETRO_DEVICE_ID_LIGHTGUN_START 6 220 221 /* Id values for POINTER. */ 222 #define RETRO_DEVICE_ID_POINTER_X 0 223 #define RETRO_DEVICE_ID_POINTER_Y 1 224 #define RETRO_DEVICE_ID_POINTER_PRESSED 2 225 226 /* Returned from retro_get_region(). */ 227 #define RETRO_REGION_NTSC 0 228 #define RETRO_REGION_PAL 1 229 230 /* Id values for LANGUAGE */ 231 enum retro_language 232 { 233 RETRO_LANGUAGE_ENGLISH = 0, 234 RETRO_LANGUAGE_JAPANESE = 1, 235 RETRO_LANGUAGE_FRENCH = 2, 236 RETRO_LANGUAGE_SPANISH = 3, 237 RETRO_LANGUAGE_GERMAN = 4, 238 RETRO_LANGUAGE_ITALIAN = 5, 239 RETRO_LANGUAGE_DUTCH = 6, 240 RETRO_LANGUAGE_PORTUGUESE = 7, 241 RETRO_LANGUAGE_RUSSIAN = 8, 242 RETRO_LANGUAGE_KOREAN = 9, 243 RETRO_LANGUAGE_CHINESE_TRADITIONAL = 10, 244 RETRO_LANGUAGE_CHINESE_SIMPLIFIED = 11, 245 RETRO_LANGUAGE_ESPERANTO = 12, 246 RETRO_LANGUAGE_POLISH = 13, 247 RETRO_LANGUAGE_LAST, 248 249 /* Ensure sizeof(enum) == sizeof(int) */ 250 RETRO_LANGUAGE_DUMMY = INT_MAX 251 }; 252 253 /* Passed to retro_get_memory_data/size(). 254 * If the memory type doesn't apply to the 255 * implementation NULL/0 can be returned. 256 */ 257 #define RETRO_MEMORY_MASK 0xff 258 259 /* Regular save RAM. This RAM is usually found on a game cartridge, 260 * backed up by a battery. 261 * If save game data is too complex for a single memory buffer, 262 * the SAVE_DIRECTORY (preferably) or SYSTEM_DIRECTORY environment 263 * callback can be used. */ 264 #define RETRO_MEMORY_SAVE_RAM 0 265 266 /* Some games have a built-in clock to keep track of time. 267 * This memory is usually just a couple of bytes to keep track of time. 268 */ 269 #define RETRO_MEMORY_RTC 1 270 271 /* System ram lets a frontend peek into a game systems main RAM. */ 272 #define RETRO_MEMORY_SYSTEM_RAM 2 273 274 /* Video ram lets a frontend peek into a game systems video RAM (VRAM). */ 275 #define RETRO_MEMORY_VIDEO_RAM 3 276 277 /* Keysyms used for ID in input state callback when polling RETRO_KEYBOARD. */ 278 enum retro_key 279 { 280 RETROK_UNKNOWN = 0, 281 RETROK_FIRST = 0, 282 RETROK_BACKSPACE = 8, 283 RETROK_TAB = 9, 284 RETROK_CLEAR = 12, 285 RETROK_RETURN = 13, 286 RETROK_PAUSE = 19, 287 RETROK_ESCAPE = 27, 288 RETROK_SPACE = 32, 289 RETROK_EXCLAIM = 33, 290 RETROK_QUOTEDBL = 34, 291 RETROK_HASH = 35, 292 RETROK_DOLLAR = 36, 293 RETROK_AMPERSAND = 38, 294 RETROK_QUOTE = 39, 295 RETROK_LEFTPAREN = 40, 296 RETROK_RIGHTPAREN = 41, 297 RETROK_ASTERISK = 42, 298 RETROK_PLUS = 43, 299 RETROK_COMMA = 44, 300 RETROK_MINUS = 45, 301 RETROK_PERIOD = 46, 302 RETROK_SLASH = 47, 303 RETROK_0 = 48, 304 RETROK_1 = 49, 305 RETROK_2 = 50, 306 RETROK_3 = 51, 307 RETROK_4 = 52, 308 RETROK_5 = 53, 309 RETROK_6 = 54, 310 RETROK_7 = 55, 311 RETROK_8 = 56, 312 RETROK_9 = 57, 313 RETROK_COLON = 58, 314 RETROK_SEMICOLON = 59, 315 RETROK_LESS = 60, 316 RETROK_EQUALS = 61, 317 RETROK_GREATER = 62, 318 RETROK_QUESTION = 63, 319 RETROK_AT = 64, 320 RETROK_LEFTBRACKET = 91, 321 RETROK_BACKSLASH = 92, 322 RETROK_RIGHTBRACKET = 93, 323 RETROK_CARET = 94, 324 RETROK_UNDERSCORE = 95, 325 RETROK_BACKQUOTE = 96, 326 RETROK_a = 97, 327 RETROK_b = 98, 328 RETROK_c = 99, 329 RETROK_d = 100, 330 RETROK_e = 101, 331 RETROK_f = 102, 332 RETROK_g = 103, 333 RETROK_h = 104, 334 RETROK_i = 105, 335 RETROK_j = 106, 336 RETROK_k = 107, 337 RETROK_l = 108, 338 RETROK_m = 109, 339 RETROK_n = 110, 340 RETROK_o = 111, 341 RETROK_p = 112, 342 RETROK_q = 113, 343 RETROK_r = 114, 344 RETROK_s = 115, 345 RETROK_t = 116, 346 RETROK_u = 117, 347 RETROK_v = 118, 348 RETROK_w = 119, 349 RETROK_x = 120, 350 RETROK_y = 121, 351 RETROK_z = 122, 352 RETROK_DELETE = 127, 353 354 RETROK_KP0 = 256, 355 RETROK_KP1 = 257, 356 RETROK_KP2 = 258, 357 RETROK_KP3 = 259, 358 RETROK_KP4 = 260, 359 RETROK_KP5 = 261, 360 RETROK_KP6 = 262, 361 RETROK_KP7 = 263, 362 RETROK_KP8 = 264, 363 RETROK_KP9 = 265, 364 RETROK_KP_PERIOD = 266, 365 RETROK_KP_DIVIDE = 267, 366 RETROK_KP_MULTIPLY = 268, 367 RETROK_KP_MINUS = 269, 368 RETROK_KP_PLUS = 270, 369 RETROK_KP_ENTER = 271, 370 RETROK_KP_EQUALS = 272, 371 372 RETROK_UP = 273, 373 RETROK_DOWN = 274, 374 RETROK_RIGHT = 275, 375 RETROK_LEFT = 276, 376 RETROK_INSERT = 277, 377 RETROK_HOME = 278, 378 RETROK_END = 279, 379 RETROK_PAGEUP = 280, 380 RETROK_PAGEDOWN = 281, 381 382 RETROK_F1 = 282, 383 RETROK_F2 = 283, 384 RETROK_F3 = 284, 385 RETROK_F4 = 285, 386 RETROK_F5 = 286, 387 RETROK_F6 = 287, 388 RETROK_F7 = 288, 389 RETROK_F8 = 289, 390 RETROK_F9 = 290, 391 RETROK_F10 = 291, 392 RETROK_F11 = 292, 393 RETROK_F12 = 293, 394 RETROK_F13 = 294, 395 RETROK_F14 = 295, 396 RETROK_F15 = 296, 397 398 RETROK_NUMLOCK = 300, 399 RETROK_CAPSLOCK = 301, 400 RETROK_SCROLLOCK = 302, 401 RETROK_RSHIFT = 303, 402 RETROK_LSHIFT = 304, 403 RETROK_RCTRL = 305, 404 RETROK_LCTRL = 306, 405 RETROK_RALT = 307, 406 RETROK_LALT = 308, 407 RETROK_RMETA = 309, 408 RETROK_LMETA = 310, 409 RETROK_LSUPER = 311, 410 RETROK_RSUPER = 312, 411 RETROK_MODE = 313, 412 RETROK_COMPOSE = 314, 413 414 RETROK_HELP = 315, 415 RETROK_PRINT = 316, 416 RETROK_SYSREQ = 317, 417 RETROK_BREAK = 318, 418 RETROK_MENU = 319, 419 RETROK_POWER = 320, 420 RETROK_EURO = 321, 421 RETROK_UNDO = 322, 422 423 RETROK_LAST, 424 425 RETROK_DUMMY = INT_MAX /* Ensure sizeof(enum) == sizeof(int) */ 426 }; 427 428 enum retro_mod 429 { 430 RETROKMOD_NONE = 0x0000, 431 432 RETROKMOD_SHIFT = 0x01, 433 RETROKMOD_CTRL = 0x02, 434 RETROKMOD_ALT = 0x04, 435 RETROKMOD_META = 0x08, 436 437 RETROKMOD_NUMLOCK = 0x10, 438 RETROKMOD_CAPSLOCK = 0x20, 439 RETROKMOD_SCROLLOCK = 0x40, 440 441 RETROKMOD_DUMMY = INT_MAX /* Ensure sizeof(enum) == sizeof(int) */ 442 }; 443 444 /* If set, this call is not part of the public libretro API yet. It can 445 * change or be removed at any time. */ 446 #define RETRO_ENVIRONMENT_EXPERIMENTAL 0x10000 447 /* Environment callback to be used internally in frontend. */ 448 #define RETRO_ENVIRONMENT_PRIVATE 0x20000 449 450 /* Environment commands. */ 451 #define RETRO_ENVIRONMENT_SET_ROTATION 1 /* const unsigned * -- 452 * Sets screen rotation of graphics. 453 * Is only implemented if rotation can be accelerated by hardware. 454 * Valid values are 0, 1, 2, 3, which rotates screen by 0, 90, 180, 455 * 270 degrees counter-clockwise respectively. 456 */ 457 #define RETRO_ENVIRONMENT_GET_OVERSCAN 2 /* bool * -- 458 * Boolean value whether or not the implementation should use overscan, 459 * or crop away overscan. 460 */ 461 #define RETRO_ENVIRONMENT_GET_CAN_DUPE 3 /* bool * -- 462 * Boolean value whether or not frontend supports frame duping, 463 * passing NULL to video frame callback. 464 */ 465 466 /* Environ 4, 5 are no longer supported (GET_VARIABLE / SET_VARIABLES), 467 * and reserved to avoid possible ABI clash. 468 */ 469 470 #define RETRO_ENVIRONMENT_SET_MESSAGE 6 /* const struct retro_message * -- 471 * Sets a message to be displayed in implementation-specific manner 472 * for a certain amount of 'frames'. 473 * Should not be used for trivial messages, which should simply be 474 * logged via RETRO_ENVIRONMENT_GET_LOG_INTERFACE (or as a 475 * fallback, stderr). 476 */ 477 #define RETRO_ENVIRONMENT_SHUTDOWN 7 /* N/A (NULL) -- 478 * Requests the frontend to shutdown. 479 * Should only be used if game has a specific 480 * way to shutdown the game from a menu item or similar. 481 */ 482 #define RETRO_ENVIRONMENT_SET_PERFORMANCE_LEVEL 8 483 /* const unsigned * -- 484 * Gives a hint to the frontend how demanding this implementation 485 * is on a system. E.g. reporting a level of 2 means 486 * this implementation should run decently on all frontends 487 * of level 2 and up. 488 * 489 * It can be used by the frontend to potentially warn 490 * about too demanding implementations. 491 * 492 * The levels are "floating". 493 * 494 * This function can be called on a per-game basis, 495 * as certain games an implementation can play might be 496 * particularly demanding. 497 * If called, it should be called in retro_load_game(). 498 */ 499 #define RETRO_ENVIRONMENT_GET_SYSTEM_DIRECTORY 9 500 /* const char ** -- 501 * Returns the "system" directory of the frontend. 502 * This directory can be used to store system specific 503 * content such as BIOSes, configuration data, etc. 504 * The returned value can be NULL. 505 * If so, no such directory is defined, 506 * and it's up to the implementation to find a suitable directory. 507 * 508 * NOTE: Some cores used this folder also for "save" data such as 509 * memory cards, etc, for lack of a better place to put it. 510 * This is now discouraged, and if possible, cores should try to 511 * use the new GET_SAVE_DIRECTORY. 512 */ 513 #define RETRO_ENVIRONMENT_SET_PIXEL_FORMAT 10 514 /* const enum retro_pixel_format * -- 515 * Sets the internal pixel format used by the implementation. 516 * The default pixel format is RETRO_PIXEL_FORMAT_0RGB1555. 517 * This pixel format however, is deprecated (see enum retro_pixel_format). 518 * If the call returns false, the frontend does not support this pixel 519 * format. 520 * 521 * This function should be called inside retro_load_game() or 522 * retro_get_system_av_info(). 523 */ 524 #define RETRO_ENVIRONMENT_SET_INPUT_DESCRIPTORS 11 525 /* const struct retro_input_descriptor * -- 526 * Sets an array of retro_input_descriptors. 527 * It is up to the frontend to present this in a usable way. 528 * The array is terminated by retro_input_descriptor::description 529 * being set to NULL. 530 * This function can be called at any time, but it is recommended 531 * to call it as early as possible. 532 */ 533 #define RETRO_ENVIRONMENT_SET_KEYBOARD_CALLBACK 12 534 /* const struct retro_keyboard_callback * -- 535 * Sets a callback function used to notify core about keyboard events. 536 */ 537 #define RETRO_ENVIRONMENT_SET_DISK_CONTROL_INTERFACE 13 538 /* const struct retro_disk_control_callback * -- 539 * Sets an interface which frontend can use to eject and insert 540 * disk images. 541 * This is used for games which consist of multiple images and 542 * must be manually swapped out by the user (e.g. PSX). 543 */ 544 #define RETRO_ENVIRONMENT_SET_HW_RENDER 14 545 /* struct retro_hw_render_callback * -- 546 * Sets an interface to let a libretro core render with 547 * hardware acceleration. 548 * Should be called in retro_load_game(). 549 * If successful, libretro cores will be able to render to a 550 * frontend-provided framebuffer. 551 * The size of this framebuffer will be at least as large as 552 * max_width/max_height provided in get_av_info(). 553 * If HW rendering is used, pass only RETRO_HW_FRAME_BUFFER_VALID or 554 * NULL to retro_video_refresh_t. 555 */ 556 #define RETRO_ENVIRONMENT_GET_VARIABLE 15 557 /* struct retro_variable * -- 558 * Interface to acquire user-defined information from environment 559 * that cannot feasibly be supported in a multi-system way. 560 * 'key' should be set to a key which has already been set by 561 * SET_VARIABLES. 562 * 'data' will be set to a value or NULL. 563 */ 564 #define RETRO_ENVIRONMENT_SET_VARIABLES 16 565 /* const struct retro_variable * -- 566 * Allows an implementation to signal the environment 567 * which variables it might want to check for later using 568 * GET_VARIABLE. 569 * This allows the frontend to present these variables to 570 * a user dynamically. 571 * This should be called as early as possible (ideally in 572 * retro_set_environment). 573 * 574 * 'data' points to an array of retro_variable structs 575 * terminated by a { NULL, NULL } element. 576 * retro_variable::key should be namespaced to not collide 577 * with other implementations' keys. E.g. A core called 578 * 'foo' should use keys named as 'foo_option'. 579 * retro_variable::value should contain a human readable 580 * description of the key as well as a '|' delimited list 581 * of expected values. 582 * 583 * The number of possible options should be very limited, 584 * i.e. it should be feasible to cycle through options 585 * without a keyboard. 586 * 587 * First entry should be treated as a default. 588 * 589 * Example entry: 590 * { "foo_option", "Speed hack coprocessor X; false|true" } 591 * 592 * Text before first ';' is description. This ';' must be 593 * followed by a space, and followed by a list of possible 594 * values split up with '|'. 595 * 596 * Only strings are operated on. The possible values will 597 * generally be displayed and stored as-is by the frontend. 598 */ 599 #define RETRO_ENVIRONMENT_GET_VARIABLE_UPDATE 17 600 /* bool * -- 601 * Result is set to true if some variables are updated by 602 * frontend since last call to RETRO_ENVIRONMENT_GET_VARIABLE. 603 * Variables should be queried with GET_VARIABLE. 604 */ 605 #define RETRO_ENVIRONMENT_SET_SUPPORT_NO_GAME 18 606 /* const bool * -- 607 * If true, the libretro implementation supports calls to 608 * retro_load_game() with NULL as argument. 609 * Used by cores which can run without particular game data. 610 * This should be called within retro_set_environment() only. 611 */ 612 #define RETRO_ENVIRONMENT_GET_LIBRETRO_PATH 19 613 /* const char ** -- 614 * Retrieves the absolute path from where this libretro 615 * implementation was loaded. 616 * NULL is returned if the libretro was loaded statically 617 * (i.e. linked statically to frontend), or if the path cannot be 618 * determined. 619 * Mostly useful in cooperation with SET_SUPPORT_NO_GAME as assets can 620 * be loaded without ugly hacks. 621 */ 622 623 /* Environment 20 was an obsolete version of SET_AUDIO_CALLBACK. 624 * It was not used by any known core at the time, 625 * and was removed from the API. */ 626 #define RETRO_ENVIRONMENT_SET_AUDIO_CALLBACK 22 627 /* const struct retro_audio_callback * -- 628 * Sets an interface which is used to notify a libretro core about audio 629 * being available for writing. 630 * The callback can be called from any thread, so a core using this must 631 * have a thread safe audio implementation. 632 * It is intended for games where audio and video are completely 633 * asynchronous and audio can be generated on the fly. 634 * This interface is not recommended for use with emulators which have 635 * highly synchronous audio. 636 * 637 * The callback only notifies about writability; the libretro core still 638 * has to call the normal audio callbacks 639 * to write audio. The audio callbacks must be called from within the 640 * notification callback. 641 * The amount of audio data to write is up to the implementation. 642 * Generally, the audio callback will be called continously in a loop. 643 * 644 * Due to thread safety guarantees and lack of sync between audio and 645 * video, a frontend can selectively disallow this interface based on 646 * internal configuration. A core using this interface must also 647 * implement the "normal" audio interface. 648 * 649 * A libretro core using SET_AUDIO_CALLBACK should also make use of 650 * SET_FRAME_TIME_CALLBACK. 651 */ 652 #define RETRO_ENVIRONMENT_SET_FRAME_TIME_CALLBACK 21 653 /* const struct retro_frame_time_callback * -- 654 * Lets the core know how much time has passed since last 655 * invocation of retro_run(). 656 * The frontend can tamper with the timing to fake fast-forward, 657 * slow-motion, frame stepping, etc. 658 * In this case the delta time will use the reference value 659 * in frame_time_callback.. 660 */ 661 #define RETRO_ENVIRONMENT_GET_RUMBLE_INTERFACE 23 662 /* struct retro_rumble_interface * -- 663 * Gets an interface which is used by a libretro core to set 664 * state of rumble motors in controllers. 665 * A strong and weak motor is supported, and they can be 666 * controlled indepedently. 667 */ 668 #define RETRO_ENVIRONMENT_GET_INPUT_DEVICE_CAPABILITIES 24 669 /* uint64_t * -- 670 * Gets a bitmask telling which device type are expected to be 671 * handled properly in a call to retro_input_state_t. 672 * Devices which are not handled or recognized always return 673 * 0 in retro_input_state_t. 674 * Example bitmask: caps = (1 << RETRO_DEVICE_JOYPAD) | (1 << RETRO_DEVICE_ANALOG). 675 * Should only be called in retro_run(). 676 */ 677 #define RETRO_ENVIRONMENT_GET_SENSOR_INTERFACE (25 | RETRO_ENVIRONMENT_EXPERIMENTAL) 678 /* struct retro_sensor_interface * -- 679 * Gets access to the sensor interface. 680 * The purpose of this interface is to allow 681 * setting state related to sensors such as polling rate, 682 * enabling/disable it entirely, etc. 683 * Reading sensor state is done via the normal 684 * input_state_callback API. 685 */ 686 #define RETRO_ENVIRONMENT_GET_CAMERA_INTERFACE (26 | RETRO_ENVIRONMENT_EXPERIMENTAL) 687 /* struct retro_camera_callback * -- 688 * Gets an interface to a video camera driver. 689 * A libretro core can use this interface to get access to a 690 * video camera. 691 * New video frames are delivered in a callback in same 692 * thread as retro_run(). 693 * 694 * GET_CAMERA_INTERFACE should be called in retro_load_game(). 695 * 696 * Depending on the camera implementation used, camera frames 697 * will be delivered as a raw framebuffer, 698 * or as an OpenGL texture directly. 699 * 700 * The core has to tell the frontend here which types of 701 * buffers can be handled properly. 702 * An OpenGL texture can only be handled when using a 703 * libretro GL core (SET_HW_RENDER). 704 * It is recommended to use a libretro GL core when 705 * using camera interface. 706 * 707 * The camera is not started automatically. The retrieved start/stop 708 * functions must be used to explicitly 709 * start and stop the camera driver. 710 */ 711 #define RETRO_ENVIRONMENT_GET_LOG_INTERFACE 27 712 /* struct retro_log_callback * -- 713 * Gets an interface for logging. This is useful for 714 * logging in a cross-platform way 715 * as certain platforms cannot use use stderr for logging. 716 * It also allows the frontend to 717 * show logging information in a more suitable way. 718 * If this interface is not used, libretro cores should 719 * log to stderr as desired. 720 */ 721 #define RETRO_ENVIRONMENT_GET_PERF_INTERFACE 28 722 /* struct retro_perf_callback * -- 723 * Gets an interface for performance counters. This is useful 724 * for performance logging in a cross-platform way and for detecting 725 * architecture-specific features, such as SIMD support. 726 */ 727 #define RETRO_ENVIRONMENT_GET_LOCATION_INTERFACE 29 728 /* struct retro_location_callback * -- 729 * Gets access to the location interface. 730 * The purpose of this interface is to be able to retrieve 731 * location-based information from the host device, 732 * such as current latitude / longitude. 733 */ 734 #define RETRO_ENVIRONMENT_GET_CONTENT_DIRECTORY 30 /* Old name, kept for compatibility. */ 735 #define RETRO_ENVIRONMENT_GET_CORE_ASSETS_DIRECTORY 30 736 /* const char ** -- 737 * Returns the "core assets" directory of the frontend. 738 * This directory can be used to store specific assets that the 739 * core relies upon, such as art assets, 740 * input data, etc etc. 741 * The returned value can be NULL. 742 * If so, no such directory is defined, 743 * and it's up to the implementation to find a suitable directory. 744 */ 745 #define RETRO_ENVIRONMENT_GET_SAVE_DIRECTORY 31 746 /* const char ** -- 747 * Returns the "save" directory of the frontend. 748 * This directory can be used to store SRAM, memory cards, 749 * high scores, etc, if the libretro core 750 * cannot use the regular memory interface (retro_get_memory_data()). 751 * 752 * NOTE: libretro cores used to check GET_SYSTEM_DIRECTORY for 753 * similar things before. 754 * They should still check GET_SYSTEM_DIRECTORY if they want to 755 * be backwards compatible. 756 * The path here can be NULL. It should only be non-NULL if the 757 * frontend user has set a specific save path. 758 */ 759 #define RETRO_ENVIRONMENT_SET_SYSTEM_AV_INFO 32 760 /* const struct retro_system_av_info * -- 761 * Sets a new av_info structure. This can only be called from 762 * within retro_run(). 763 * This should *only* be used if the core is completely altering the 764 * internal resolutions, aspect ratios, timings, sampling rate, etc. 765 * Calling this can require a full reinitialization of video/audio 766 * drivers in the frontend, 767 * 768 * so it is important to call it very sparingly, and usually only with 769 * the users explicit consent. 770 * An eventual driver reinitialize will happen so that video and 771 * audio callbacks 772 * happening after this call within the same retro_run() call will 773 * target the newly initialized driver. 774 * 775 * This callback makes it possible to support configurable resolutions 776 * in games, which can be useful to 777 * avoid setting the "worst case" in max_width/max_height. 778 * 779 * ***HIGHLY RECOMMENDED*** Do not call this callback every time 780 * resolution changes in an emulator core if it's 781 * expected to be a temporary change, for the reasons of possible 782 * driver reinitialization. 783 * This call is not a free pass for not trying to provide 784 * correct values in retro_get_system_av_info(). If you need to change 785 * things like aspect ratio or nominal width/height, 786 * use RETRO_ENVIRONMENT_SET_GEOMETRY, which is a softer variant 787 * of SET_SYSTEM_AV_INFO. 788 * 789 * If this returns false, the frontend does not acknowledge a 790 * changed av_info struct. 791 */ 792 #define RETRO_ENVIRONMENT_SET_PROC_ADDRESS_CALLBACK 33 793 /* const struct retro_get_proc_address_interface * -- 794 * Allows a libretro core to announce support for the 795 * get_proc_address() interface. 796 * This interface allows for a standard way to extend libretro where 797 * use of environment calls are too indirect, 798 * e.g. for cases where the frontend wants to call directly into the core. 799 * 800 * If a core wants to expose this interface, SET_PROC_ADDRESS_CALLBACK 801 * **MUST** be called from within retro_set_environment(). 802 */ 803 #define RETRO_ENVIRONMENT_SET_SUBSYSTEM_INFO 34 804 /* const struct retro_subsystem_info * -- 805 * This environment call introduces the concept of libretro "subsystems". 806 * A subsystem is a variant of a libretro core which supports 807 * different kinds of games. 808 * The purpose of this is to support e.g. emulators which might 809 * have special needs, e.g. Super Nintendo's Super GameBoy, Sufami Turbo. 810 * It can also be used to pick among subsystems in an explicit way 811 * if the libretro implementation is a multi-system emulator itself. 812 * 813 * Loading a game via a subsystem is done with retro_load_game_special(), 814 * and this environment call allows a libretro core to expose which 815 * subsystems are supported for use with retro_load_game_special(). 816 * A core passes an array of retro_game_special_info which is terminated 817 * with a zeroed out retro_game_special_info struct. 818 * 819 * If a core wants to use this functionality, SET_SUBSYSTEM_INFO 820 * **MUST** be called from within retro_set_environment(). 821 */ 822 #define RETRO_ENVIRONMENT_SET_CONTROLLER_INFO 35 823 /* const struct retro_controller_info * -- 824 * This environment call lets a libretro core tell the frontend 825 * which controller types are recognized in calls to 826 * retro_set_controller_port_device(). 827 * 828 * Some emulators such as Super Nintendo 829 * support multiple lightgun types which must be specifically 830 * selected from. 831 * It is therefore sometimes necessary for a frontend to be able 832 * to tell the core about a special kind of input device which is 833 * not covered by the libretro input API. 834 * 835 * In order for a frontend to understand the workings of an input device, 836 * it must be a specialized type 837 * of the generic device types already defined in the libretro API. 838 * 839 * Which devices are supported can vary per input port. 840 * The core must pass an array of const struct retro_controller_info which 841 * is terminated with a blanked out struct. Each element of the struct 842 * corresponds to an ascending port index to 843 * retro_set_controller_port_device(). 844 * Even if special device types are set in the libretro core, 845 * libretro should only poll input based on the base input device types. 846 */ 847 #define RETRO_ENVIRONMENT_SET_MEMORY_MAPS (36 | RETRO_ENVIRONMENT_EXPERIMENTAL) 848 /* const struct retro_memory_map * -- 849 * This environment call lets a libretro core tell the frontend 850 * about the memory maps this core emulates. 851 * This can be used to implement, for example, cheats in a core-agnostic way. 852 * 853 * Should only be used by emulators; it doesn't make much sense for 854 * anything else. 855 * It is recommended to expose all relevant pointers through 856 * retro_get_memory_* as well. 857 * 858 * Can be called from retro_init and retro_load_game. 859 */ 860 #define RETRO_ENVIRONMENT_SET_GEOMETRY 37 861 /* const struct retro_game_geometry * -- 862 * This environment call is similar to SET_SYSTEM_AV_INFO for changing 863 * video parameters, but provides a guarantee that drivers will not be 864 * reinitialized. 865 * This can only be called from within retro_run(). 866 * 867 * The purpose of this call is to allow a core to alter nominal 868 * width/heights as well as aspect ratios on-the-fly, which can be 869 * useful for some emulators to change in run-time. 870 * 871 * max_width/max_height arguments are ignored and cannot be changed 872 * with this call as this could potentially require a reinitialization or a 873 * non-constant time operation. 874 * If max_width/max_height are to be changed, SET_SYSTEM_AV_INFO is required. 875 * 876 * A frontend must guarantee that this environment call completes in 877 * constant time. 878 */ 879 #define RETRO_ENVIRONMENT_GET_USERNAME 38 880 /* const char ** 881 * Returns the specified username of the frontend, if specified by the user. 882 * This username can be used as a nickname for a core that has online facilities 883 * or any other mode where personalization of the user is desirable. 884 * The returned value can be NULL. 885 * If this environ callback is used by a core that requires a valid username, 886 * a default username should be specified by the core. 887 */ 888 #define RETRO_ENVIRONMENT_GET_LANGUAGE 39 889 /* unsigned * -- 890 * Returns the specified language of the frontend, if specified by the user. 891 * It can be used by the core for localization purposes. 892 */ 893 #define RETRO_ENVIRONMENT_GET_CURRENT_SOFTWARE_FRAMEBUFFER (40 | RETRO_ENVIRONMENT_EXPERIMENTAL) 894 /* struct retro_framebuffer * -- 895 * Returns a preallocated framebuffer which the core can use for rendering 896 * the frame into when not using SET_HW_RENDER. 897 * The framebuffer returned from this call must not be used 898 * after the current call to retro_run() returns. 899 * 900 * The goal of this call is to allow zero-copy behavior where a core 901 * can render directly into video memory, avoiding extra bandwidth cost by copying 902 * memory from core to video memory. 903 * 904 * If this call succeeds and the core renders into it, 905 * the framebuffer pointer and pitch can be passed to retro_video_refresh_t. 906 * If the buffer from GET_CURRENT_SOFTWARE_FRAMEBUFFER is to be used, 907 * the core must pass the exact 908 * same pointer as returned by GET_CURRENT_SOFTWARE_FRAMEBUFFER; 909 * i.e. passing a pointer which is offset from the 910 * buffer is undefined. The width, height and pitch parameters 911 * must also match exactly to the values obtained from GET_CURRENT_SOFTWARE_FRAMEBUFFER. 912 * 913 * It is possible for a frontend to return a different pixel format 914 * than the one used in SET_PIXEL_FORMAT. This can happen if the frontend 915 * needs to perform conversion. 916 * 917 * It is still valid for a core to render to a different buffer 918 * even if GET_CURRENT_SOFTWARE_FRAMEBUFFER succeeds. 919 * 920 * A frontend must make sure that the pointer obtained from this function is 921 * writeable (and readable). 922 */ 923 924 enum retro_hw_render_interface_type 925 { 926 RETRO_HW_RENDER_INTERFACE_VULKAN = 0, 927 RETRO_HW_RENDER_INTERFACE_DUMMY = INT_MAX 928 }; 929 930 /* Base struct. All retro_hw_render_interface_* types 931 * contain at least these fields. */ 932 struct retro_hw_render_interface 933 { 934 enum retro_hw_render_interface_type interface_type; 935 unsigned interface_version; 936 }; 937 #define RETRO_ENVIRONMENT_GET_HW_RENDER_INTERFACE (41 | RETRO_ENVIRONMENT_EXPERIMENTAL) 938 /* const struct retro_hw_render_interface ** -- 939 * Returns an API specific rendering interface for accessing API specific data. 940 * Not all HW rendering APIs support or need this. 941 * The contents of the returned pointer is specific to the rendering API 942 * being used. See the various headers like libretro_vulkan.h, etc. 943 * 944 * GET_HW_RENDER_INTERFACE cannot be called before context_reset has been called. 945 * Similarly, after context_destroyed callback returns, 946 * the contents of the HW_RENDER_INTERFACE are invalidated. 947 */ 948 949 #define RETRO_ENVIRONMENT_SET_SUPPORT_ACHIEVEMENTS (42 | RETRO_ENVIRONMENT_EXPERIMENTAL) 950 /* const bool * -- 951 * If true, the libretro implementation supports achievements 952 * either via memory descriptors set with RETRO_ENVIRONMENT_SET_MEMORY_MAPS 953 * or via retro_get_memory_data/retro_get_memory_size. 954 * 955 * This must be called before the first call to retro_run. 956 */ 957 958 enum retro_hw_render_context_negotiation_interface_type 959 { 960 RETRO_HW_RENDER_CONTEXT_NEGOTIATION_INTERFACE_VULKAN = 0, 961 RETRO_HW_RENDER_CONTEXT_NEGOTIATION_INTERFACE_DUMMY = INT_MAX 962 }; 963 964 /* Base struct. All retro_hw_render_context_negotiation_interface_* types 965 * contain at least these fields. */ 966 struct retro_hw_render_context_negotiation_interface 967 { 968 enum retro_hw_render_context_negotiation_interface_type interface_type; 969 unsigned interface_version; 970 }; 971 #define RETRO_ENVIRONMENT_SET_HW_RENDER_CONTEXT_NEGOTIATION_INTERFACE (43 | RETRO_ENVIRONMENT_EXPERIMENTAL) 972 /* const struct retro_hw_render_context_negotiation_interface * -- 973 * Sets an interface which lets the libretro core negotiate with frontend how a context is created. 974 * The semantics of this interface depends on which API is used in SET_HW_RENDER earlier. 975 * This interface will be used when the frontend is trying to create a HW rendering context, 976 * so it will be used after SET_HW_RENDER, but before the context_reset callback. 977 */ 978 979 /* Serialized state is incomplete in some way. Set if serialization is 980 * usable in typical end-user cases but should not be relied upon to 981 * implement frame-sensitive frontend features such as netplay or 982 * rerecording. */ 983 #define RETRO_SERIALIZATION_QUIRK_INCOMPLETE (1 << 0) 984 /* The core must spend some time initializing before serialization is 985 * supported. retro_serialize() will initially fail; retro_unserialize() 986 * and retro_serialize_size() may or may not work correctly either. */ 987 #define RETRO_SERIALIZATION_QUIRK_MUST_INITIALIZE (1 << 1) 988 /* Serialization size may change within a session. */ 989 #define RETRO_SERIALIZATION_QUIRK_CORE_VARIABLE_SIZE (1 << 2) 990 /* Set by the frontend to acknowledge that it supports variable-sized 991 * states. */ 992 #define RETRO_SERIALIZATION_QUIRK_FRONT_VARIABLE_SIZE (1 << 3) 993 /* Serialized state can only be loaded during the same session. */ 994 #define RETRO_SERIALIZATION_QUIRK_SINGLE_SESSION (1 << 4) 995 /* Serialized state cannot be loaded on an architecture with a different 996 * endianness from the one it was saved on. */ 997 #define RETRO_SERIALIZATION_QUIRK_ENDIAN_DEPENDENT (1 << 5) 998 /* Serialized state cannot be loaded on a different platform from the one it 999 * was saved on for reasons other than endianness, such as word size 1000 * dependence */ 1001 #define RETRO_SERIALIZATION_QUIRK_PLATFORM_DEPENDENT (1 << 6) 1002 1003 #define RETRO_ENVIRONMENT_SET_SERIALIZATION_QUIRKS 44 1004 /* uint64_t * -- 1005 * Sets quirk flags associated with serialization. The frontend will zero any flags it doesn't 1006 * recognize or support. Should be set in either retro_init or retro_load_game, but not both. 1007 */ 1008 1009 1010 #define RETRO_MEMDESC_CONST (1 << 0) /* The frontend will never change this memory area once retro_load_game has returned. */ 1011 #define RETRO_MEMDESC_BIGENDIAN (1 << 1) /* The memory area contains big endian data. Default is little endian. */ 1012 #define RETRO_MEMDESC_ALIGN_2 (1 << 16) /* All memory access in this area is aligned to their own size, or 2, whichever is smaller. */ 1013 #define RETRO_MEMDESC_ALIGN_4 (2 << 16) 1014 #define RETRO_MEMDESC_ALIGN_8 (3 << 16) 1015 #define RETRO_MEMDESC_MINSIZE_2 (1 << 24) /* All memory in this region is accessed at least 2 bytes at the time. */ 1016 #define RETRO_MEMDESC_MINSIZE_4 (2 << 24) 1017 #define RETRO_MEMDESC_MINSIZE_8 (3 << 24) 1018 struct retro_memory_descriptor 1019 { 1020 uint64_t flags; 1021 1022 /* Pointer to the start of the relevant ROM or RAM chip. 1023 * It's strongly recommended to use 'offset' if possible, rather than 1024 * doing math on the pointer. 1025 * 1026 * If the same byte is mapped my multiple descriptors, their descriptors 1027 * must have the same pointer. 1028 * If 'start' does not point to the first byte in the pointer, put the 1029 * difference in 'offset' instead. 1030 * 1031 * May be NULL if there's nothing usable here (e.g. hardware registers and 1032 * open bus). No flags should be set if the pointer is NULL. 1033 * It's recommended to minimize the number of descriptors if possible, 1034 * but not mandatory. */ 1035 void *ptr; 1036 size_t offset; 1037 1038 /* This is the location in the emulated address space 1039 * where the mapping starts. */ 1040 size_t start; 1041 1042 /* Which bits must be same as in 'start' for this mapping to apply. 1043 * The first memory descriptor to claim a certain byte is the one 1044 * that applies. 1045 * A bit which is set in 'start' must also be set in this. 1046 * Can be zero, in which case each byte is assumed mapped exactly once. 1047 * In this case, 'len' must be a power of two. */ 1048 size_t select; 1049 1050 /* If this is nonzero, the set bits are assumed not connected to the 1051 * memory chip's address pins. */ 1052 size_t disconnect; 1053 1054 /* This one tells the size of the current memory area. 1055 * If, after start+disconnect are applied, the address is higher than 1056 * this, the highest bit of the address is cleared. 1057 * 1058 * If the address is still too high, the next highest bit is cleared. 1059 * Can be zero, in which case it's assumed to be infinite (as limited 1060 * by 'select' and 'disconnect'). */ 1061 size_t len; 1062 1063 /* To go from emulated address to physical address, the following 1064 * order applies: 1065 * Subtract 'start', pick off 'disconnect', apply 'len', add 'offset'. */ 1066 1067 /* The address space name must consist of only a-zA-Z0-9_-, 1068 * should be as short as feasible (maximum length is 8 plus the NUL), 1069 * and may not be any other address space plus one or more 0-9A-F 1070 * at the end. 1071 * However, multiple memory descriptors for the same address space is 1072 * allowed, and the address space name can be empty. NULL is treated 1073 * as empty. 1074 * 1075 * Address space names are case sensitive, but avoid lowercase if possible. 1076 * The same pointer may exist in multiple address spaces. 1077 * 1078 * Examples: 1079 * blank+blank - valid (multiple things may be mapped in the same namespace) 1080 * 'Sp'+'Sp' - valid (multiple things may be mapped in the same namespace) 1081 * 'A'+'B' - valid (neither is a prefix of each other) 1082 * 'S'+blank - valid ('S' is not in 0-9A-F) 1083 * 'a'+blank - valid ('a' is not in 0-9A-F) 1084 * 'a'+'A' - valid (neither is a prefix of each other) 1085 * 'AR'+blank - valid ('R' is not in 0-9A-F) 1086 * 'ARB'+blank - valid (the B can't be part of the address either, because 1087 * there is no namespace 'AR') 1088 * blank+'B' - not valid, because it's ambigous which address space B1234 1089 * would refer to. 1090 * The length can't be used for that purpose; the frontend may want 1091 * to append arbitrary data to an address, without a separator. */ 1092 const char *addrspace; 1093 1094 /* TODO: When finalizing this one, add a description field, which should be 1095 * "WRAM" or something roughly equally long. */ 1096 1097 /* TODO: When finalizing this one, replace 'select' with 'limit', which tells 1098 * which bits can vary and still refer to the same address (limit = ~select). 1099 * TODO: limit? range? vary? something else? */ 1100 1101 /* TODO: When finalizing this one, if 'len' is above what 'select' (or 1102 * 'limit') allows, it's bankswitched. Bankswitched data must have both 'len' 1103 * and 'select' != 0, and the mappings don't tell how the system switches the 1104 * banks. */ 1105 1106 /* TODO: When finalizing this one, fix the 'len' bit removal order. 1107 * For len=0x1800, pointer 0x1C00 should go to 0x1400, not 0x0C00. 1108 * Algorithm: Take bits highest to lowest, but if it goes above len, clear 1109 * the most recent addition and continue on the next bit. 1110 * TODO: Can the above be optimized? Is "remove the lowest bit set in both 1111 * pointer and 'len'" equivalent? */ 1112 1113 /* TODO: Some emulators (MAME?) emulate big endian systems by only accessing 1114 * the emulated memory in 32-bit chunks, native endian. But that's nothing 1115 * compared to Darek Mihocka <http://www.emulators.com/docs/nx07_vm101.htm> 1116 * (section Emulation 103 - Nearly Free Byte Reversal) - he flips the ENTIRE 1117 * RAM backwards! I'll want to represent both of those, via some flags. 1118 * 1119 * I suspect MAME either didn't think of that idea, or don't want the #ifdef. 1120 * Not sure which, nor do I really care. */ 1121 1122 /* TODO: Some of those flags are unused and/or don't really make sense. Clean 1123 * them up. */ 1124 }; 1125 1126 /* The frontend may use the largest value of 'start'+'select' in a 1127 * certain namespace to infer the size of the address space. 1128 * 1129 * If the address space is larger than that, a mapping with .ptr=NULL 1130 * should be at the end of the array, with .select set to all ones for 1131 * as long as the address space is big. 1132 * 1133 * Sample descriptors (minus .ptr, and RETRO_MEMFLAG_ on the flags): 1134 * SNES WRAM: 1135 * .start=0x7E0000, .len=0x20000 1136 * (Note that this must be mapped before the ROM in most cases; some of the 1137 * ROM mappers 1138 * try to claim $7E0000, or at least $7E8000.) 1139 * SNES SPC700 RAM: 1140 * .addrspace="S", .len=0x10000 1141 * SNES WRAM mirrors: 1142 * .flags=MIRROR, .start=0x000000, .select=0xC0E000, .len=0x2000 1143 * .flags=MIRROR, .start=0x800000, .select=0xC0E000, .len=0x2000 1144 * SNES WRAM mirrors, alternate equivalent descriptor: 1145 * .flags=MIRROR, .select=0x40E000, .disconnect=~0x1FFF 1146 * (Various similar constructions can be created by combining parts of 1147 * the above two.) 1148 * SNES LoROM (512KB, mirrored a couple of times): 1149 * .flags=CONST, .start=0x008000, .select=0x408000, .disconnect=0x8000, .len=512*1024 1150 * .flags=CONST, .start=0x400000, .select=0x400000, .disconnect=0x8000, .len=512*1024 1151 * SNES HiROM (4MB): 1152 * .flags=CONST, .start=0x400000, .select=0x400000, .len=4*1024*1024 1153 * .flags=CONST, .offset=0x8000, .start=0x008000, .select=0x408000, .len=4*1024*1024 1154 * SNES ExHiROM (8MB): 1155 * .flags=CONST, .offset=0, .start=0xC00000, .select=0xC00000, .len=4*1024*1024 1156 * .flags=CONST, .offset=4*1024*1024, .start=0x400000, .select=0xC00000, .len=4*1024*1024 1157 * .flags=CONST, .offset=0x8000, .start=0x808000, .select=0xC08000, .len=4*1024*1024 1158 * .flags=CONST, .offset=4*1024*1024+0x8000, .start=0x008000, .select=0xC08000, .len=4*1024*1024 1159 * Clarify the size of the address space: 1160 * .ptr=NULL, .select=0xFFFFFF 1161 * .len can be implied by .select in many of them, but was included for clarity. 1162 */ 1163 1164 struct retro_memory_map 1165 { 1166 const struct retro_memory_descriptor *descriptors; 1167 unsigned num_descriptors; 1168 }; 1169 1170 struct retro_controller_description 1171 { 1172 /* Human-readable description of the controller. Even if using a generic 1173 * input device type, this can be set to the particular device type the 1174 * core uses. */ 1175 const char *desc; 1176 1177 /* Device type passed to retro_set_controller_port_device(). If the device 1178 * type is a sub-class of a generic input device type, use the 1179 * RETRO_DEVICE_SUBCLASS macro to create an ID. 1180 * 1181 * E.g. RETRO_DEVICE_SUBCLASS(RETRO_DEVICE_JOYPAD, 1). */ 1182 unsigned id; 1183 }; 1184 1185 struct retro_controller_info 1186 { 1187 const struct retro_controller_description *types; 1188 unsigned num_types; 1189 }; 1190 1191 struct retro_subsystem_memory_info 1192 { 1193 /* The extension associated with a memory type, e.g. "psram". */ 1194 const char *extension; 1195 1196 /* The memory type for retro_get_memory(). This should be at 1197 * least 0x100 to avoid conflict with standardized 1198 * libretro memory types. */ 1199 unsigned type; 1200 }; 1201 1202 struct retro_subsystem_rom_info 1203 { 1204 /* Describes what the content is (SGB BIOS, GB ROM, etc). */ 1205 const char *desc; 1206 1207 /* Same definition as retro_get_system_info(). */ 1208 const char *valid_extensions; 1209 1210 /* Same definition as retro_get_system_info(). */ 1211 bool need_fullpath; 1212 1213 /* Same definition as retro_get_system_info(). */ 1214 bool block_extract; 1215 1216 /* This is set if the content is required to load a game. 1217 * If this is set to false, a zeroed-out retro_game_info can be passed. */ 1218 bool required; 1219 1220 /* Content can have multiple associated persistent 1221 * memory types (retro_get_memory()). */ 1222 const struct retro_subsystem_memory_info *memory; 1223 unsigned num_memory; 1224 }; 1225 1226 struct retro_subsystem_info 1227 { 1228 /* Human-readable string of the subsystem type, e.g. "Super GameBoy" */ 1229 const char *desc; 1230 1231 /* A computer friendly short string identifier for the subsystem type. 1232 * This name must be [a-z]. 1233 * E.g. if desc is "Super GameBoy", this can be "sgb". 1234 * This identifier can be used for command-line interfaces, etc. 1235 */ 1236 const char *ident; 1237 1238 /* Infos for each content file. The first entry is assumed to be the 1239 * "most significant" content for frontend purposes. 1240 * E.g. with Super GameBoy, the first content should be the GameBoy ROM, 1241 * as it is the most "significant" content to a user. 1242 * If a frontend creates new file paths based on the content used 1243 * (e.g. savestates), it should use the path for the first ROM to do so. */ 1244 const struct retro_subsystem_rom_info *roms; 1245 1246 /* Number of content files associated with a subsystem. */ 1247 unsigned num_roms; 1248 1249 /* The type passed to retro_load_game_special(). */ 1250 unsigned id; 1251 }; 1252 1253 typedef void (RETRO_CALLCONV *retro_proc_address_t)(void); 1254 1255 /* libretro API extension functions: 1256 * (None here so far). 1257 * 1258 * Get a symbol from a libretro core. 1259 * Cores should only return symbols which are actual 1260 * extensions to the libretro API. 1261 * 1262 * Frontends should not use this to obtain symbols to standard 1263 * libretro entry points (static linking or dlsym). 1264 * 1265 * The symbol name must be equal to the function name, 1266 * e.g. if void retro_foo(void); exists, the symbol must be called "retro_foo". 1267 * The returned function pointer must be cast to the corresponding type. 1268 */ 1269 typedef retro_proc_address_t (RETRO_CALLCONV *retro_get_proc_address_t)(const char *sym); 1270 1271 struct retro_get_proc_address_interface 1272 { 1273 retro_get_proc_address_t get_proc_address; 1274 }; 1275 1276 enum retro_log_level 1277 { 1278 RETRO_LOG_DEBUG = 0, 1279 RETRO_LOG_INFO, 1280 RETRO_LOG_WARN, 1281 RETRO_LOG_ERROR, 1282 1283 RETRO_LOG_DUMMY = INT_MAX 1284 }; 1285 1286 /* Logging function. Takes log level argument as well. */ 1287 typedef void (RETRO_CALLCONV *retro_log_printf_t)(enum retro_log_level level, 1288 const char *fmt, ...); 1289 1290 struct retro_log_callback 1291 { 1292 retro_log_printf_t log; 1293 }; 1294 1295 /* Performance related functions */ 1296 1297 /* ID values for SIMD CPU features */ 1298 #define RETRO_SIMD_SSE (1 << 0) 1299 #define RETRO_SIMD_SSE2 (1 << 1) 1300 #define RETRO_SIMD_VMX (1 << 2) 1301 #define RETRO_SIMD_VMX128 (1 << 3) 1302 #define RETRO_SIMD_AVX (1 << 4) 1303 #define RETRO_SIMD_NEON (1 << 5) 1304 #define RETRO_SIMD_SSE3 (1 << 6) 1305 #define RETRO_SIMD_SSSE3 (1 << 7) 1306 #define RETRO_SIMD_MMX (1 << 8) 1307 #define RETRO_SIMD_MMXEXT (1 << 9) 1308 #define RETRO_SIMD_SSE4 (1 << 10) 1309 #define RETRO_SIMD_SSE42 (1 << 11) 1310 #define RETRO_SIMD_AVX2 (1 << 12) 1311 #define RETRO_SIMD_VFPU (1 << 13) 1312 #define RETRO_SIMD_PS (1 << 14) 1313 #define RETRO_SIMD_AES (1 << 15) 1314 #define RETRO_SIMD_VFPV3 (1 << 16) 1315 #define RETRO_SIMD_VFPV4 (1 << 17) 1316 #define RETRO_SIMD_POPCNT (1 << 18) 1317 #define RETRO_SIMD_MOVBE (1 << 19) 1318 #define RETRO_SIMD_CMOV (1 << 20) 1319 #define RETRO_SIMD_ASIMD (1 << 21) 1320 1321 typedef uint64_t retro_perf_tick_t; 1322 typedef int64_t retro_time_t; 1323 1324 struct retro_perf_counter 1325 { 1326 const char *ident; 1327 retro_perf_tick_t start; 1328 retro_perf_tick_t total; 1329 retro_perf_tick_t call_cnt; 1330 1331 bool registered; 1332 }; 1333 1334 /* Returns current time in microseconds. 1335 * Tries to use the most accurate timer available. 1336 */ 1337 typedef retro_time_t (RETRO_CALLCONV *retro_perf_get_time_usec_t)(void); 1338 1339 /* A simple counter. Usually nanoseconds, but can also be CPU cycles. 1340 * Can be used directly if desired (when creating a more sophisticated 1341 * performance counter system). 1342 * */ 1343 typedef retro_perf_tick_t (RETRO_CALLCONV *retro_perf_get_counter_t)(void); 1344 1345 /* Returns a bit-mask of detected CPU features (RETRO_SIMD_*). */ 1346 typedef uint64_t (RETRO_CALLCONV *retro_get_cpu_features_t)(void); 1347 1348 /* Asks frontend to log and/or display the state of performance counters. 1349 * Performance counters can always be poked into manually as well. 1350 */ 1351 typedef void (RETRO_CALLCONV *retro_perf_log_t)(void); 1352 1353 /* Register a performance counter. 1354 * ident field must be set with a discrete value and other values in 1355 * retro_perf_counter must be 0. 1356 * Registering can be called multiple times. To avoid calling to 1357 * frontend redundantly, you can check registered field first. */ 1358 typedef void (RETRO_CALLCONV *retro_perf_register_t)(struct retro_perf_counter *counter); 1359 1360 /* Starts a registered counter. */ 1361 typedef void (RETRO_CALLCONV *retro_perf_start_t)(struct retro_perf_counter *counter); 1362 1363 /* Stops a registered counter. */ 1364 typedef void (RETRO_CALLCONV *retro_perf_stop_t)(struct retro_perf_counter *counter); 1365 1366 /* For convenience it can be useful to wrap register, start and stop in macros. 1367 * E.g.: 1368 * #ifdef LOG_PERFORMANCE 1369 * #define RETRO_PERFORMANCE_INIT(perf_cb, name) static struct retro_perf_counter name = {#name}; if (!name.registered) perf_cb.perf_register(&(name)) 1370 * #define RETRO_PERFORMANCE_START(perf_cb, name) perf_cb.perf_start(&(name)) 1371 * #define RETRO_PERFORMANCE_STOP(perf_cb, name) perf_cb.perf_stop(&(name)) 1372 * #else 1373 * ... Blank macros ... 1374 * #endif 1375 * 1376 * These can then be used mid-functions around code snippets. 1377 * 1378 * extern struct retro_perf_callback perf_cb; * Somewhere in the core. 1379 * 1380 * void do_some_heavy_work(void) 1381 * { 1382 * RETRO_PERFORMANCE_INIT(cb, work_1; 1383 * RETRO_PERFORMANCE_START(cb, work_1); 1384 * heavy_work_1(); 1385 * RETRO_PERFORMANCE_STOP(cb, work_1); 1386 * 1387 * RETRO_PERFORMANCE_INIT(cb, work_2); 1388 * RETRO_PERFORMANCE_START(cb, work_2); 1389 * heavy_work_2(); 1390 * RETRO_PERFORMANCE_STOP(cb, work_2); 1391 * } 1392 * 1393 * void retro_deinit(void) 1394 * { 1395 * perf_cb.perf_log(); * Log all perf counters here for example. 1396 * } 1397 */ 1398 1399 struct retro_perf_callback 1400 { 1401 retro_perf_get_time_usec_t get_time_usec; 1402 retro_get_cpu_features_t get_cpu_features; 1403 1404 retro_perf_get_counter_t get_perf_counter; 1405 retro_perf_register_t perf_register; 1406 retro_perf_start_t perf_start; 1407 retro_perf_stop_t perf_stop; 1408 retro_perf_log_t perf_log; 1409 }; 1410 1411 /* FIXME: Document the sensor API and work out behavior. 1412 * It will be marked as experimental until then. 1413 */ 1414 enum retro_sensor_action 1415 { 1416 RETRO_SENSOR_ACCELEROMETER_ENABLE = 0, 1417 RETRO_SENSOR_ACCELEROMETER_DISABLE, 1418 1419 RETRO_SENSOR_DUMMY = INT_MAX 1420 }; 1421 1422 /* Id values for SENSOR types. */ 1423 #define RETRO_SENSOR_ACCELEROMETER_X 0 1424 #define RETRO_SENSOR_ACCELEROMETER_Y 1 1425 #define RETRO_SENSOR_ACCELEROMETER_Z 2 1426 1427 typedef bool (RETRO_CALLCONV *retro_set_sensor_state_t)(unsigned port, 1428 enum retro_sensor_action action, unsigned rate); 1429 1430 typedef float (RETRO_CALLCONV *retro_sensor_get_input_t)(unsigned port, unsigned id); 1431 1432 struct retro_sensor_interface 1433 { 1434 retro_set_sensor_state_t set_sensor_state; 1435 retro_sensor_get_input_t get_sensor_input; 1436 }; 1437 1438 enum retro_camera_buffer 1439 { 1440 RETRO_CAMERA_BUFFER_OPENGL_TEXTURE = 0, 1441 RETRO_CAMERA_BUFFER_RAW_FRAMEBUFFER, 1442 1443 RETRO_CAMERA_BUFFER_DUMMY = INT_MAX 1444 }; 1445 1446 /* Starts the camera driver. Can only be called in retro_run(). */ 1447 typedef bool (RETRO_CALLCONV *retro_camera_start_t)(void); 1448 1449 /* Stops the camera driver. Can only be called in retro_run(). */ 1450 typedef void (RETRO_CALLCONV *retro_camera_stop_t)(void); 1451 1452 /* Callback which signals when the camera driver is initialized 1453 * and/or deinitialized. 1454 * retro_camera_start_t can be called in initialized callback. 1455 */ 1456 typedef void (RETRO_CALLCONV *retro_camera_lifetime_status_t)(void); 1457 1458 /* A callback for raw framebuffer data. buffer points to an XRGB8888 buffer. 1459 * Width, height and pitch are similar to retro_video_refresh_t. 1460 * First pixel is top-left origin. 1461 */ 1462 typedef void (RETRO_CALLCONV *retro_camera_frame_raw_framebuffer_t)(const uint32_t *buffer, 1463 unsigned width, unsigned height, size_t pitch); 1464 1465 /* A callback for when OpenGL textures are used. 1466 * 1467 * texture_id is a texture owned by camera driver. 1468 * Its state or content should be considered immutable, except for things like 1469 * texture filtering and clamping. 1470 * 1471 * texture_target is the texture target for the GL texture. 1472 * These can include e.g. GL_TEXTURE_2D, GL_TEXTURE_RECTANGLE, and possibly 1473 * more depending on extensions. 1474 * 1475 * affine points to a packed 3x3 column-major matrix used to apply an affine 1476 * transform to texture coordinates. (affine_matrix * vec3(coord_x, coord_y, 1.0)) 1477 * After transform, normalized texture coord (0, 0) should be bottom-left 1478 * and (1, 1) should be top-right (or (width, height) for RECTANGLE). 1479 * 1480 * GL-specific typedefs are avoided here to avoid relying on gl.h in 1481 * the API definition. 1482 */ 1483 typedef void (RETRO_CALLCONV *retro_camera_frame_opengl_texture_t)(unsigned texture_id, 1484 unsigned texture_target, const float *affine); 1485 1486 struct retro_camera_callback 1487 { 1488 /* Set by libretro core. 1489 * Example bitmask: caps = (1 << RETRO_CAMERA_BUFFER_OPENGL_TEXTURE) | (1 << RETRO_CAMERA_BUFFER_RAW_FRAMEBUFFER). 1490 */ 1491 uint64_t caps; 1492 1493 /* Desired resolution for camera. Is only used as a hint. */ 1494 unsigned width; 1495 unsigned height; 1496 1497 /* Set by frontend. */ 1498 retro_camera_start_t start; 1499 retro_camera_stop_t stop; 1500 1501 /* Set by libretro core if raw framebuffer callbacks will be used. */ 1502 retro_camera_frame_raw_framebuffer_t frame_raw_framebuffer; 1503 1504 /* Set by libretro core if OpenGL texture callbacks will be used. */ 1505 retro_camera_frame_opengl_texture_t frame_opengl_texture; 1506 1507 /* Set by libretro core. Called after camera driver is initialized and 1508 * ready to be started. 1509 * Can be NULL, in which this callback is not called. 1510 */ 1511 retro_camera_lifetime_status_t initialized; 1512 1513 /* Set by libretro core. Called right before camera driver is 1514 * deinitialized. 1515 * Can be NULL, in which this callback is not called. 1516 */ 1517 retro_camera_lifetime_status_t deinitialized; 1518 }; 1519 1520 /* Sets the interval of time and/or distance at which to update/poll 1521 * location-based data. 1522 * 1523 * To ensure compatibility with all location-based implementations, 1524 * values for both interval_ms and interval_distance should be provided. 1525 * 1526 * interval_ms is the interval expressed in milliseconds. 1527 * interval_distance is the distance interval expressed in meters. 1528 */ 1529 typedef void (RETRO_CALLCONV *retro_location_set_interval_t)(unsigned interval_ms, 1530 unsigned interval_distance); 1531 1532 /* Start location services. The device will start listening for changes to the 1533 * current location at regular intervals (which are defined with 1534 * retro_location_set_interval_t). */ 1535 typedef bool (RETRO_CALLCONV *retro_location_start_t)(void); 1536 1537 /* Stop location services. The device will stop listening for changes 1538 * to the current location. */ 1539 typedef void (RETRO_CALLCONV *retro_location_stop_t)(void); 1540 1541 /* Get the position of the current location. Will set parameters to 1542 * 0 if no new location update has happened since the last time. */ 1543 typedef bool (RETRO_CALLCONV *retro_location_get_position_t)(double *lat, double *lon, 1544 double *horiz_accuracy, double *vert_accuracy); 1545 1546 /* Callback which signals when the location driver is initialized 1547 * and/or deinitialized. 1548 * retro_location_start_t can be called in initialized callback. 1549 */ 1550 typedef void (RETRO_CALLCONV *retro_location_lifetime_status_t)(void); 1551 1552 struct retro_location_callback 1553 { 1554 retro_location_start_t start; 1555 retro_location_stop_t stop; 1556 retro_location_get_position_t get_position; 1557 retro_location_set_interval_t set_interval; 1558 1559 retro_location_lifetime_status_t initialized; 1560 retro_location_lifetime_status_t deinitialized; 1561 }; 1562 1563 enum retro_rumble_effect 1564 { 1565 RETRO_RUMBLE_STRONG = 0, 1566 RETRO_RUMBLE_WEAK = 1, 1567 1568 RETRO_RUMBLE_DUMMY = INT_MAX 1569 }; 1570 1571 /* Sets rumble state for joypad plugged in port 'port'. 1572 * Rumble effects are controlled independently, 1573 * and setting e.g. strong rumble does not override weak rumble. 1574 * Strength has a range of [0, 0xffff]. 1575 * 1576 * Returns true if rumble state request was honored. 1577 * Calling this before first retro_run() is likely to return false. */ 1578 typedef bool (RETRO_CALLCONV *retro_set_rumble_state_t)(unsigned port, 1579 enum retro_rumble_effect effect, uint16_t strength); 1580 1581 struct retro_rumble_interface 1582 { 1583 retro_set_rumble_state_t set_rumble_state; 1584 }; 1585 1586 /* Notifies libretro that audio data should be written. */ 1587 typedef void (RETRO_CALLCONV *retro_audio_callback_t)(void); 1588 1589 /* True: Audio driver in frontend is active, and callback is 1590 * expected to be called regularily. 1591 * False: Audio driver in frontend is paused or inactive. 1592 * Audio callback will not be called until set_state has been 1593 * called with true. 1594 * Initial state is false (inactive). 1595 */ 1596 typedef void (RETRO_CALLCONV *retro_audio_set_state_callback_t)(bool enabled); 1597 1598 struct retro_audio_callback 1599 { 1600 retro_audio_callback_t callback; 1601 retro_audio_set_state_callback_t set_state; 1602 }; 1603 1604 /* Notifies a libretro core of time spent since last invocation 1605 * of retro_run() in microseconds. 1606 * 1607 * It will be called right before retro_run() every frame. 1608 * The frontend can tamper with timing to support cases like 1609 * fast-forward, slow-motion and framestepping. 1610 * 1611 * In those scenarios the reference frame time value will be used. */ 1612 typedef int64_t retro_usec_t; 1613 typedef void (RETRO_CALLCONV *retro_frame_time_callback_t)(retro_usec_t usec); 1614 struct retro_frame_time_callback 1615 { 1616 retro_frame_time_callback_t callback; 1617 /* Represents the time of one frame. It is computed as 1618 * 1000000 / fps, but the implementation will resolve the 1619 * rounding to ensure that framestepping, etc is exact. */ 1620 retro_usec_t reference; 1621 }; 1622 1623 /* Pass this to retro_video_refresh_t if rendering to hardware. 1624 * Passing NULL to retro_video_refresh_t is still a frame dupe as normal. 1625 * */ 1626 #define RETRO_HW_FRAME_BUFFER_VALID ((void*)-1) 1627 1628 /* Invalidates the current HW context. 1629 * Any GL state is lost, and must not be deinitialized explicitly. 1630 * If explicit deinitialization is desired by the libretro core, 1631 * it should implement context_destroy callback. 1632 * If called, all GPU resources must be reinitialized. 1633 * Usually called when frontend reinits video driver. 1634 * Also called first time video driver is initialized, 1635 * allowing libretro core to initialize resources. 1636 */ 1637 typedef void (RETRO_CALLCONV *retro_hw_context_reset_t)(void); 1638 1639 /* Gets current framebuffer which is to be rendered to. 1640 * Could change every frame potentially. 1641 */ 1642 typedef uintptr_t (RETRO_CALLCONV *retro_hw_get_current_framebuffer_t)(void); 1643 1644 /* Get a symbol from HW context. */ 1645 typedef retro_proc_address_t (RETRO_CALLCONV *retro_hw_get_proc_address_t)(const char *sym); 1646 1647 enum retro_hw_context_type 1648 { 1649 RETRO_HW_CONTEXT_NONE = 0, 1650 /* OpenGL 2.x. Driver can choose to use latest compatibility context. */ 1651 RETRO_HW_CONTEXT_OPENGL = 1, 1652 /* OpenGL ES 2.0. */ 1653 RETRO_HW_CONTEXT_OPENGLES2 = 2, 1654 /* Modern desktop core GL context. Use version_major/ 1655 * version_minor fields to set GL version. */ 1656 RETRO_HW_CONTEXT_OPENGL_CORE = 3, 1657 /* OpenGL ES 3.0 */ 1658 RETRO_HW_CONTEXT_OPENGLES3 = 4, 1659 /* OpenGL ES 3.1+. Set version_major/version_minor. For GLES2 and GLES3, 1660 * use the corresponding enums directly. */ 1661 RETRO_HW_CONTEXT_OPENGLES_VERSION = 5, 1662 1663 /* Vulkan, see RETRO_ENVIRONMENT_GET_HW_RENDER_INTERFACE. */ 1664 RETRO_HW_CONTEXT_VULKAN = 6, 1665 1666 RETRO_HW_CONTEXT_DUMMY = INT_MAX 1667 }; 1668 1669 struct retro_hw_render_callback 1670 { 1671 /* Which API to use. Set by libretro core. */ 1672 enum retro_hw_context_type context_type; 1673 1674 /* Called when a context has been created or when it has been reset. 1675 * An OpenGL context is only valid after context_reset() has been called. 1676 * 1677 * When context_reset is called, OpenGL resources in the libretro 1678 * implementation are guaranteed to be invalid. 1679 * 1680 * It is possible that context_reset is called multiple times during an 1681 * application lifecycle. 1682 * If context_reset is called without any notification (context_destroy), 1683 * the OpenGL context was lost and resources should just be recreated 1684 * without any attempt to "free" old resources. 1685 */ 1686 retro_hw_context_reset_t context_reset; 1687 1688 /* Set by frontend. 1689 * TODO: This is rather obsolete. The frontend should not 1690 * be providing preallocated framebuffers. */ 1691 retro_hw_get_current_framebuffer_t get_current_framebuffer; 1692 1693 /* Set by frontend. */ 1694 retro_hw_get_proc_address_t get_proc_address; 1695 1696 /* Set if render buffers should have depth component attached. 1697 * TODO: Obsolete. */ 1698 bool depth; 1699 1700 /* Set if stencil buffers should be attached. 1701 * TODO: Obsolete. */ 1702 bool stencil; 1703 1704 /* If depth and stencil are true, a packed 24/8 buffer will be added. 1705 * Only attaching stencil is invalid and will be ignored. */ 1706 1707 /* Use conventional bottom-left origin convention. If false, 1708 * standard libretro top-left origin semantics are used. 1709 * TODO: Move to GL specific interface. */ 1710 bool bottom_left_origin; 1711 1712 /* Major version number for core GL context or GLES 3.1+. */ 1713 unsigned version_major; 1714 1715 /* Minor version number for core GL context or GLES 3.1+. */ 1716 unsigned version_minor; 1717 1718 /* If this is true, the frontend will go very far to avoid 1719 * resetting context in scenarios like toggling fullscreen, etc. 1720 * TODO: Obsolete? Maybe frontend should just always assume this ... 1721 */ 1722 bool cache_context; 1723 1724 /* The reset callback might still be called in extreme situations 1725 * such as if the context is lost beyond recovery. 1726 * 1727 * For optimal stability, set this to false, and allow context to be 1728 * reset at any time. 1729 */ 1730 1731 /* A callback to be called before the context is destroyed in a 1732 * controlled way by the frontend. */ 1733 retro_hw_context_reset_t context_destroy; 1734 1735 /* OpenGL resources can be deinitialized cleanly at this step. 1736 * context_destroy can be set to NULL, in which resources will 1737 * just be destroyed without any notification. 1738 * 1739 * Even when context_destroy is non-NULL, it is possible that 1740 * context_reset is called without any destroy notification. 1741 * This happens if context is lost by external factors (such as 1742 * notified by GL_ARB_robustness). 1743 * 1744 * In this case, the context is assumed to be already dead, 1745 * and the libretro implementation must not try to free any OpenGL 1746 * resources in the subsequent context_reset. 1747 */ 1748 1749 /* Creates a debug context. */ 1750 bool debug_context; 1751 }; 1752 1753 /* Callback type passed in RETRO_ENVIRONMENT_SET_KEYBOARD_CALLBACK. 1754 * Called by the frontend in response to keyboard events. 1755 * down is set if the key is being pressed, or false if it is being released. 1756 * keycode is the RETROK value of the char. 1757 * character is the text character of the pressed key. (UTF-32). 1758 * key_modifiers is a set of RETROKMOD values or'ed together. 1759 * 1760 * The pressed/keycode state can be indepedent of the character. 1761 * It is also possible that multiple characters are generated from a 1762 * single keypress. 1763 * Keycode events should be treated separately from character events. 1764 * However, when possible, the frontend should try to synchronize these. 1765 * If only a character is posted, keycode should be RETROK_UNKNOWN. 1766 * 1767 * Similarily if only a keycode event is generated with no corresponding 1768 * character, character should be 0. 1769 */ 1770 typedef void (RETRO_CALLCONV *retro_keyboard_event_t)(bool down, unsigned keycode, 1771 uint32_t character, uint16_t key_modifiers); 1772 1773 struct retro_keyboard_callback 1774 { 1775 retro_keyboard_event_t callback; 1776 }; 1777 1778 /* Callbacks for RETRO_ENVIRONMENT_SET_DISK_CONTROL_INTERFACE. 1779 * Should be set for implementations which can swap out multiple disk 1780 * images in runtime. 1781 * 1782 * If the implementation can do this automatically, it should strive to do so. 1783 * However, there are cases where the user must manually do so. 1784 * 1785 * Overview: To swap a disk image, eject the disk image with 1786 * set_eject_state(true). 1787 * Set the disk index with set_image_index(index). Insert the disk again 1788 * with set_eject_state(false). 1789 */ 1790 1791 /* If ejected is true, "ejects" the virtual disk tray. 1792 * When ejected, the disk image index can be set. 1793 */ 1794 typedef bool (RETRO_CALLCONV *retro_set_eject_state_t)(bool ejected); 1795 1796 /* Gets current eject state. The initial state is 'not ejected'. */ 1797 typedef bool (RETRO_CALLCONV *retro_get_eject_state_t)(void); 1798 1799 /* Gets current disk index. First disk is index 0. 1800 * If return value is >= get_num_images(), no disk is currently inserted. 1801 */ 1802 typedef unsigned (RETRO_CALLCONV *retro_get_image_index_t)(void); 1803 1804 /* Sets image index. Can only be called when disk is ejected. 1805 * The implementation supports setting "no disk" by using an 1806 * index >= get_num_images(). 1807 */ 1808 typedef bool (RETRO_CALLCONV *retro_set_image_index_t)(unsigned index); 1809 1810 /* Gets total number of images which are available to use. */ 1811 typedef unsigned (RETRO_CALLCONV *retro_get_num_images_t)(void); 1812 1813 struct retro_game_info; 1814 1815 /* Replaces the disk image associated with index. 1816 * Arguments to pass in info have same requirements as retro_load_game(). 1817 * Virtual disk tray must be ejected when calling this. 1818 * 1819 * Replacing a disk image with info = NULL will remove the disk image 1820 * from the internal list. 1821 * As a result, calls to get_image_index() can change. 1822 * 1823 * E.g. replace_image_index(1, NULL), and previous get_image_index() 1824 * returned 4 before. 1825 * Index 1 will be removed, and the new index is 3. 1826 */ 1827 typedef bool (RETRO_CALLCONV *retro_replace_image_index_t)(unsigned index, 1828 const struct retro_game_info *info); 1829 1830 /* Adds a new valid index (get_num_images()) to the internal disk list. 1831 * This will increment subsequent return values from get_num_images() by 1. 1832 * This image index cannot be used until a disk image has been set 1833 * with replace_image_index. */ 1834 typedef bool (RETRO_CALLCONV *retro_add_image_index_t)(void); 1835 1836 struct retro_disk_control_callback 1837 { 1838 retro_set_eject_state_t set_eject_state; 1839 retro_get_eject_state_t get_eject_state; 1840 1841 retro_get_image_index_t get_image_index; 1842 retro_set_image_index_t set_image_index; 1843 retro_get_num_images_t get_num_images; 1844 1845 retro_replace_image_index_t replace_image_index; 1846 retro_add_image_index_t add_image_index; 1847 }; 1848 1849 enum retro_pixel_format 1850 { 1851 /* 0RGB1555, native endian. 1852 * 0 bit must be set to 0. 1853 * This pixel format is default for compatibility concerns only. 1854 * If a 15/16-bit pixel format is desired, consider using RGB565. */ 1855 RETRO_PIXEL_FORMAT_0RGB1555 = 0, 1856 1857 /* XRGB8888, native endian. 1858 * X bits are ignored. */ 1859 RETRO_PIXEL_FORMAT_XRGB8888 = 1, 1860 1861 /* RGB565, native endian. 1862 * This pixel format is the recommended format to use if a 15/16-bit 1863 * format is desired as it is the pixel format that is typically 1864 * available on a wide range of low-power devices. 1865 * 1866 * It is also natively supported in APIs like OpenGL ES. */ 1867 RETRO_PIXEL_FORMAT_RGB565 = 2, 1868 1869 /* Ensure sizeof() == sizeof(int). */ 1870 RETRO_PIXEL_FORMAT_UNKNOWN = INT_MAX 1871 }; 1872 1873 struct retro_message 1874 { 1875 const char *msg; /* Message to be displayed. */ 1876 unsigned frames; /* Duration in frames of message. */ 1877 }; 1878 1879 /* Describes how the libretro implementation maps a libretro input bind 1880 * to its internal input system through a human readable string. 1881 * This string can be used to better let a user configure input. */ 1882 struct retro_input_descriptor 1883 { 1884 /* Associates given parameters with a description. */ 1885 unsigned port; 1886 unsigned device; 1887 unsigned index; 1888 unsigned id; 1889 1890 /* Human readable description for parameters. 1891 * The pointer must remain valid until 1892 * retro_unload_game() is called. */ 1893 const char *description; 1894 }; 1895 1896 struct retro_system_info 1897 { 1898 /* All pointers are owned by libretro implementation, and pointers must 1899 * remain valid until retro_deinit() is called. */ 1900 1901 const char *library_name; /* Descriptive name of library. Should not 1902 * contain any version numbers, etc. */ 1903 const char *library_version; /* Descriptive version of core. */ 1904 1905 const char *valid_extensions; /* A string listing probably content 1906 * extensions the core will be able to 1907 * load, separated with pipe. 1908 * I.e. "bin|rom|iso". 1909 * Typically used for a GUI to filter 1910 * out extensions. */ 1911 1912 /* If true, retro_load_game() is guaranteed to provide a valid pathname 1913 * in retro_game_info::path. 1914 * ::data and ::size are both invalid. 1915 * 1916 * If false, ::data and ::size are guaranteed to be valid, but ::path 1917 * might not be valid. 1918 * 1919 * This is typically set to true for libretro implementations that must 1920 * load from file. 1921 * Implementations should strive for setting this to false, as it allows 1922 * the frontend to perform patching, etc. */ 1923 bool need_fullpath; 1924 1925 /* If true, the frontend is not allowed to extract any archives before 1926 * loading the real content. 1927 * Necessary for certain libretro implementations that load games 1928 * from zipped archives. */ 1929 bool block_extract; 1930 }; 1931 1932 struct retro_game_geometry 1933 { 1934 unsigned base_width; /* Nominal video width of game. */ 1935 unsigned base_height; /* Nominal video height of game. */ 1936 unsigned max_width; /* Maximum possible width of game. */ 1937 unsigned max_height; /* Maximum possible height of game. */ 1938 1939 float aspect_ratio; /* Nominal aspect ratio of game. If 1940 * aspect_ratio is <= 0.0, an aspect ratio 1941 * of base_width / base_height is assumed. 1942 * A frontend could override this setting, 1943 * if desired. */ 1944 }; 1945 1946 struct retro_system_timing 1947 { 1948 double fps; /* FPS of video content. */ 1949 double sample_rate; /* Sampling rate of audio. */ 1950 }; 1951 1952 struct retro_system_av_info 1953 { 1954 struct retro_game_geometry geometry; 1955 struct retro_system_timing timing; 1956 }; 1957 1958 struct retro_variable 1959 { 1960 /* Variable to query in RETRO_ENVIRONMENT_GET_VARIABLE. 1961 * If NULL, obtains the complete environment string if more 1962 * complex parsing is necessary. 1963 * The environment string is formatted as key-value pairs 1964 * delimited by semicolons as so: 1965 * "key1=value1;key2=value2;..." 1966 */ 1967 const char *key; 1968 1969 /* Value to be obtained. If key does not exist, it is set to NULL. */ 1970 const char *value; 1971 }; 1972 1973 struct retro_game_info 1974 { 1975 const char *path; /* Path to game, UTF-8 encoded. 1976 * Usually used as a reference. 1977 * May be NULL if rom was loaded from stdin 1978 * or similar. 1979 * retro_system_info::need_fullpath guaranteed 1980 * that this path is valid. */ 1981 const void *data; /* Memory buffer of loaded game. Will be NULL 1982 * if need_fullpath was set. */ 1983 size_t size; /* Size of memory buffer. */ 1984 const char *meta; /* String of implementation specific meta-data. */ 1985 }; 1986 1987 #define RETRO_MEMORY_ACCESS_WRITE (1 << 0) 1988 /* The core will write to the buffer provided by retro_framebuffer::data. */ 1989 #define RETRO_MEMORY_ACCESS_READ (1 << 1) 1990 /* The core will read from retro_framebuffer::data. */ 1991 #define RETRO_MEMORY_TYPE_CACHED (1 << 0) 1992 /* The memory in data is cached. 1993 * If not cached, random writes and/or reading from the buffer is expected to be very slow. */ 1994 struct retro_framebuffer 1995 { 1996 void *data; /* The framebuffer which the core can render into. 1997 Set by frontend in GET_CURRENT_SOFTWARE_FRAMEBUFFER. 1998 The initial contents of data are unspecified. */ 1999 unsigned width; /* The framebuffer width used by the core. Set by core. */ 2000 unsigned height; /* The framebuffer height used by the core. Set by core. */ 2001 size_t pitch; /* The number of bytes between the beginning of a scanline, 2002 and beginning of the next scanline. 2003 Set by frontend in GET_CURRENT_SOFTWARE_FRAMEBUFFER. */ 2004 enum retro_pixel_format format; /* The pixel format the core must use to render into data. 2005 This format could differ from the format used in 2006 SET_PIXEL_FORMAT. 2007 Set by frontend in GET_CURRENT_SOFTWARE_FRAMEBUFFER. */ 2008 2009 unsigned access_flags; /* How the core will access the memory in the framebuffer. 2010 RETRO_MEMORY_ACCESS_* flags. 2011 Set by core. */ 2012 unsigned memory_flags; /* Flags telling core how the memory has been mapped. 2013 RETRO_MEMORY_TYPE_* flags. 2014 Set by frontend in GET_CURRENT_SOFTWARE_FRAMEBUFFER. */ 2015 }; 2016 2017 /* Callbacks */ 2018 2019 /* Environment callback. Gives implementations a way of performing 2020 * uncommon tasks. Extensible. */ 2021 typedef bool (RETRO_CALLCONV *retro_environment_t)(unsigned cmd, void *data); 2022 2023 /* Render a frame. Pixel format is 15-bit 0RGB1555 native endian 2024 * unless changed (see RETRO_ENVIRONMENT_SET_PIXEL_FORMAT). 2025 * 2026 * Width and height specify dimensions of buffer. 2027 * Pitch specifices length in bytes between two lines in buffer. 2028 * 2029 * For performance reasons, it is highly recommended to have a frame 2030 * that is packed in memory, i.e. pitch == width * byte_per_pixel. 2031 * Certain graphic APIs, such as OpenGL ES, do not like textures 2032 * that are not packed in memory. 2033 */ 2034 typedef void (RETRO_CALLCONV *retro_video_refresh_t)(const void *data, unsigned width, 2035 unsigned height, size_t pitch); 2036 2037 /* Renders a single audio frame. Should only be used if implementation 2038 * generates a single sample at a time. 2039 * Format is signed 16-bit native endian. 2040 */ 2041 typedef void (RETRO_CALLCONV *retro_audio_sample_t)(int16_t left, int16_t right); 2042 2043 /* Renders multiple audio frames in one go. 2044 * 2045 * One frame is defined as a sample of left and right channels, interleaved. 2046 * I.e. int16_t buf[4] = { l, r, l, r }; would be 2 frames. 2047 * Only one of the audio callbacks must ever be used. 2048 */ 2049 typedef size_t (RETRO_CALLCONV *retro_audio_sample_batch_t)(const int16_t *data, 2050 size_t frames); 2051 2052 /* Polls input. */ 2053 typedef void (RETRO_CALLCONV *retro_input_poll_t)(void); 2054 2055 /* Queries for input for player 'port'. device will be masked with 2056 * RETRO_DEVICE_MASK. 2057 * 2058 * Specialization of devices such as RETRO_DEVICE_JOYPAD_MULTITAP that 2059 * have been set with retro_set_controller_port_device() 2060 * will still use the higher level RETRO_DEVICE_JOYPAD to request input. 2061 */ 2062 typedef int16_t (RETRO_CALLCONV *retro_input_state_t)(unsigned port, unsigned device, 2063 unsigned index, unsigned id); 2064 2065 /* Sets callbacks. retro_set_environment() is guaranteed to be called 2066 * before retro_init(). 2067 * 2068 * The rest of the set_* functions are guaranteed to have been called 2069 * before the first call to retro_run() is made. */ 2070 RETRO_API void retro_set_environment(retro_environment_t); 2071 RETRO_API void retro_set_video_refresh(retro_video_refresh_t); 2072 RETRO_API void retro_set_audio_sample(retro_audio_sample_t); 2073 RETRO_API void retro_set_audio_sample_batch(retro_audio_sample_batch_t); 2074 RETRO_API void retro_set_input_poll(retro_input_poll_t); 2075 RETRO_API void retro_set_input_state(retro_input_state_t); 2076 2077 /* Library global initialization/deinitialization. */ 2078 RETRO_API void retro_init(void); 2079 RETRO_API void retro_deinit(void); 2080 2081 /* Must return RETRO_API_VERSION. Used to validate ABI compatibility 2082 * when the API is revised. */ 2083 RETRO_API unsigned retro_api_version(void); 2084 2085 /* Gets statically known system info. Pointers provided in *info 2086 * must be statically allocated. 2087 * Can be called at any time, even before retro_init(). */ 2088 RETRO_API void retro_get_system_info(struct retro_system_info *info); 2089 2090 /* Gets information about system audio/video timings and geometry. 2091 * Can be called only after retro_load_game() has successfully completed. 2092 * NOTE: The implementation of this function might not initialize every 2093 * variable if needed. 2094 * E.g. geom.aspect_ratio might not be initialized if core doesn't 2095 * desire a particular aspect ratio. */ 2096 RETRO_API void retro_get_system_av_info(struct retro_system_av_info *info); 2097 2098 /* Sets device to be used for player 'port'. 2099 * By default, RETRO_DEVICE_JOYPAD is assumed to be plugged into all 2100 * available ports. 2101 * Setting a particular device type is not a guarantee that libretro cores 2102 * will only poll input based on that particular device type. It is only a 2103 * hint to the libretro core when a core cannot automatically detect the 2104 * appropriate input device type on its own. It is also relevant when a 2105 * core can change its behavior depending on device type. */ 2106 RETRO_API void retro_set_controller_port_device(unsigned port, unsigned device); 2107 2108 /* Resets the current game. */ 2109 RETRO_API void retro_reset(void); 2110 2111 /* Runs the game for one video frame. 2112 * During retro_run(), input_poll callback must be called at least once. 2113 * 2114 * If a frame is not rendered for reasons where a game "dropped" a frame, 2115 * this still counts as a frame, and retro_run() should explicitly dupe 2116 * a frame if GET_CAN_DUPE returns true. 2117 * In this case, the video callback can take a NULL argument for data. 2118 */ 2119 RETRO_API void retro_run(void); 2120 2121 /* Returns the amount of data the implementation requires to serialize 2122 * internal state (save states). 2123 * Between calls to retro_load_game() and retro_unload_game(), the 2124 * returned size is never allowed to be larger than a previous returned 2125 * value, to ensure that the frontend can allocate a save state buffer once. 2126 */ 2127 RETRO_API size_t retro_serialize_size(void); 2128 2129 /* Serializes internal state. If failed, or size is lower than 2130 * retro_serialize_size(), it should return false, true otherwise. */ 2131 RETRO_API bool retro_serialize(void *data, size_t size); 2132 RETRO_API bool retro_unserialize(const void *data, size_t size); 2133 2134 RETRO_API void retro_cheat_reset(void); 2135 RETRO_API void retro_cheat_set(unsigned index, bool enabled, const char *code); 2136 2137 /* Loads a game. */ 2138 RETRO_API bool retro_load_game(const struct retro_game_info *game); 2139 2140 /* Loads a "special" kind of game. Should not be used, 2141 * except in extreme cases. */ 2142 RETRO_API bool retro_load_game_special( 2143 unsigned game_type, 2144 const struct retro_game_info *info, size_t num_info 2145 ); 2146 2147 /* Unloads a currently loaded game. */ 2148 RETRO_API void retro_unload_game(void); 2149 2150 /* Gets region of game. */ 2151 RETRO_API unsigned retro_get_region(void); 2152 2153 /* Gets region of memory. */ 2154 RETRO_API void *retro_get_memory_data(unsigned id); 2155 RETRO_API size_t retro_get_memory_size(unsigned id); 2156 2157 #ifdef __cplusplus 2158 } 2159 #endif 2160 2161 #endif 2162