Accept RETRO_DEVICE_ANALOG.
[bsnes:bsnes.git] / bsnes / target-libretro / libretro.h
1 #ifndef LIBRETRO_H__
2 #define LIBRETRO_H__
3
4 #include <stdint.h>
5 #include <stddef.h>
6
7 // Hack applied for MSVC when compiling in C89 mode as it isn't C99 compliant.
8 #ifdef __cplusplus
9 extern "C" {
10 #else
11 #if defined(_MSC_VER) && !defined(SN_TARGET_PS3) && !defined(__cplusplus)
12 #define bool unsigned char
13 #define true 1
14 #define false 0
15 #else
16 #include <stdbool.h>
17 #endif
18 #endif
19
20 // Used for checking API/ABI mismatches that can break libretro implementations.
21 // It is not incremented for compatible changes.
22 #define RETRO_API_VERSION         1
23
24 // Libretro's fundamental device abstractions.
25 #define RETRO_DEVICE_MASK         0xff
26 #define RETRO_DEVICE_NONE         0
27
28 // The JOYPAD is called RetroPad. It is essentially a Super Nintendo controller,
29 // but with additional L2/R2/L3/R3 buttons, similar to a PS1 DualShock.
30 #define RETRO_DEVICE_JOYPAD       1
31
32 // The mouse is a simple mouse, similar to Super Nintendo's mouse.
33 // X and Y coordinates are reported relatively to last poll (poll callback).
34 // It is up to the libretro implementation to keep track of where the mouse pointer is supposed to be on the screen.
35 // The frontend must make sure not to interfere with its own hardware mouse pointer.
36 #define RETRO_DEVICE_MOUSE        2
37
38 // KEYBOARD device lets one poll for raw key pressed.
39 // It is poll based, so input callback will return with the current pressed state.
40 #define RETRO_DEVICE_KEYBOARD     3
41
42 // Lightgun X/Y coordinates are reported relatively to last poll, similar to mouse.
43 #define RETRO_DEVICE_LIGHTGUN     4
44
45 // The ANALOG device is an extension to JOYPAD (RetroPad).
46 // Similar to DualShock it adds two analog sticks.
47 // This is treated as a separate device type as it returns values in the full analog range
48 // of [-0x8000, 0x7fff]. Positive X axis is right. Positive Y axis is down.
49 // Only use ANALOG type when polling for analog values of the axes.
50 #define RETRO_DEVICE_ANALOG       5
51
52 // These device types are specializations of the base types above.
53 // They should only be used in retro_set_controller_type() to inform libretro implementations
54 // about use of a very specific device type.
55 //
56 // In input state callback, however, only the base type should be used in the 'device' field.
57 #define RETRO_DEVICE_JOYPAD_MULTITAP        ((1 << 8) | RETRO_DEVICE_JOYPAD)
58 #define RETRO_DEVICE_LIGHTGUN_SUPER_SCOPE   ((1 << 8) | RETRO_DEVICE_LIGHTGUN)
59 #define RETRO_DEVICE_LIGHTGUN_JUSTIFIER     ((2 << 8) | RETRO_DEVICE_LIGHTGUN)
60 #define RETRO_DEVICE_LIGHTGUN_JUSTIFIERS    ((3 << 8) | RETRO_DEVICE_LIGHTGUN)
61
62 // Buttons for the RetroPad (JOYPAD).
63 // The placement of these is equivalent to placements on the Super Nintendo controller.
64 // L2/R2/L3/R3 buttons correspond to the PS1 DualShock.
65 #define RETRO_DEVICE_ID_JOYPAD_B        0
66 #define RETRO_DEVICE_ID_JOYPAD_Y        1
67 #define RETRO_DEVICE_ID_JOYPAD_SELECT   2
68 #define RETRO_DEVICE_ID_JOYPAD_START    3
69 #define RETRO_DEVICE_ID_JOYPAD_UP       4
70 #define RETRO_DEVICE_ID_JOYPAD_DOWN     5
71 #define RETRO_DEVICE_ID_JOYPAD_LEFT     6
72 #define RETRO_DEVICE_ID_JOYPAD_RIGHT    7
73 #define RETRO_DEVICE_ID_JOYPAD_A        8
74 #define RETRO_DEVICE_ID_JOYPAD_X        9
75 #define RETRO_DEVICE_ID_JOYPAD_L       10
76 #define RETRO_DEVICE_ID_JOYPAD_R       11
77 #define RETRO_DEVICE_ID_JOYPAD_L2      12
78 #define RETRO_DEVICE_ID_JOYPAD_R2      13
79 #define RETRO_DEVICE_ID_JOYPAD_L3      14
80 #define RETRO_DEVICE_ID_JOYPAD_R3      15
81
82 // Index / Id values for ANALOG device.
83 #define RETRO_DEVICE_INDEX_ANALOG_LEFT   0
84 #define RETRO_DEVICE_INDEX_ANALOG_RIGHT  1
85 #define RETRO_DEVICE_ID_ANALOG_X         0
86 #define RETRO_DEVICE_ID_ANALOG_Y         1
87
88 // Id values for MOUSE.
89 #define RETRO_DEVICE_ID_MOUSE_X      0
90 #define RETRO_DEVICE_ID_MOUSE_Y      1
91 #define RETRO_DEVICE_ID_MOUSE_LEFT   2
92 #define RETRO_DEVICE_ID_MOUSE_RIGHT  3
93
94 // Id values for LIGHTGUN types.
95 #define RETRO_DEVICE_ID_LIGHTGUN_X        0
96 #define RETRO_DEVICE_ID_LIGHTGUN_Y        1
97 #define RETRO_DEVICE_ID_LIGHTGUN_TRIGGER  2
98 #define RETRO_DEVICE_ID_LIGHTGUN_CURSOR   3
99 #define RETRO_DEVICE_ID_LIGHTGUN_TURBO    4
100 #define RETRO_DEVICE_ID_LIGHTGUN_PAUSE    5
101 #define RETRO_DEVICE_ID_LIGHTGUN_START    6
102
103 // Returned from retro_get_region().
104 #define RETRO_REGION_NTSC  0
105 #define RETRO_REGION_PAL   1
106
107 // Passed to retro_get_memory_data/size().
108 // If the memory type doesn't apply to the implementation NULL/0 can be returned.
109 #define RETRO_MEMORY_MASK        0xff
110
111 // Regular save ram. This ram is usually found on a game cartridge, backed up by a battery.
112 // If save game data is too complex for a single memory buffer,
113 // the SYSTEM_DIRECTORY environment callback can be used.
114 #define RETRO_MEMORY_SAVE_RAM    0
115
116 // Some games have a built-in clock to keep track of time.
117 // This memory is usually just a couple of bytes to keep track of time.
118 #define RETRO_MEMORY_RTC         1
119
120 // System ram lets a frontend peek into a game systems main RAM.
121 #define RETRO_MEMORY_SYSTEM_RAM  2
122
123 // Video ram lets a frontend peek into a game systems video RAM (VRAM).
124 #define RETRO_MEMORY_VIDEO_RAM   3
125
126 // Special memory types.
127 #define RETRO_MEMORY_SNES_BSX_RAM             ((1 << 8) | RETRO_MEMORY_SAVE_RAM)
128 #define RETRO_MEMORY_SNES_BSX_PRAM            ((2 << 8) | RETRO_MEMORY_SAVE_RAM)
129 #define RETRO_MEMORY_SNES_SUFAMI_TURBO_A_RAM  ((3 << 8) | RETRO_MEMORY_SAVE_RAM)
130 #define RETRO_MEMORY_SNES_SUFAMI_TURBO_B_RAM  ((4 << 8) | RETRO_MEMORY_SAVE_RAM)
131 #define RETRO_MEMORY_SNES_GAME_BOY_RAM        ((5 << 8) | RETRO_MEMORY_SAVE_RAM)
132 #define RETRO_MEMORY_SNES_GAME_BOY_RTC        ((6 << 8) | RETRO_MEMORY_RTC)
133
134 // Special game types passed into retro_load_game_special().
135 // Only used when multiple ROMs are required.
136 #define RETRO_GAME_TYPE_BSX             0x101
137 #define RETRO_GAME_TYPE_BSX_SLOTTED     0x102
138 #define RETRO_GAME_TYPE_SUFAMI_TURBO    0x103
139 #define RETRO_GAME_TYPE_SUPER_GAME_BOY  0x104
140
141 // Keysyms used for ID in input state callback when polling RETRO_KEYBOARD.
142 enum retro_key
143 {
144    RETROK_UNKNOWN        = 0,
145    RETROK_FIRST          = 0,
146    RETROK_BACKSPACE      = 8,
147    RETROK_TAB            = 9,
148    RETROK_CLEAR          = 12,
149    RETROK_RETURN         = 13,
150    RETROK_PAUSE          = 19,
151    RETROK_ESCAPE         = 27,
152    RETROK_SPACE          = 32,
153    RETROK_EXCLAIM        = 33,
154    RETROK_QUOTEDBL       = 34,
155    RETROK_HASH           = 35,
156    RETROK_DOLLAR         = 36,
157    RETROK_AMPERSAND      = 38,
158    RETROK_QUOTE          = 39,
159    RETROK_LEFTPAREN      = 40,
160    RETROK_RIGHTPAREN     = 41,
161    RETROK_ASTERISK       = 42,
162    RETROK_PLUS           = 43,
163    RETROK_COMMA          = 44,
164    RETROK_MINUS          = 45,
165    RETROK_PERIOD         = 46,
166    RETROK_SLASH          = 47,
167    RETROK_0              = 48,
168    RETROK_1              = 49,
169    RETROK_2              = 50,
170    RETROK_3              = 51,
171    RETROK_4              = 52,
172    RETROK_5              = 53,
173    RETROK_6              = 54,
174    RETROK_7              = 55,
175    RETROK_8              = 56,
176    RETROK_9              = 57,
177    RETROK_COLON          = 58,
178    RETROK_SEMICOLON      = 59,
179    RETROK_LESS           = 60,
180    RETROK_EQUALS         = 61,
181    RETROK_GREATER        = 62,
182    RETROK_QUESTION       = 63,
183    RETROK_AT             = 64,
184    RETROK_LEFTBRACKET    = 91,
185    RETROK_BACKSLASH      = 92,
186    RETROK_RIGHTBRACKET   = 93,
187    RETROK_CARET          = 94,
188    RETROK_UNDERSCORE     = 95,
189    RETROK_BACKQUOTE      = 96,
190    RETROK_a              = 97,
191    RETROK_b              = 98,
192    RETROK_c              = 99,
193    RETROK_d              = 100,
194    RETROK_e              = 101,
195    RETROK_f              = 102,
196    RETROK_g              = 103,
197    RETROK_h              = 104,
198    RETROK_i              = 105,
199    RETROK_j              = 106,
200    RETROK_k              = 107,
201    RETROK_l              = 108,
202    RETROK_m              = 109,
203    RETROK_n              = 110,
204    RETROK_o              = 111,
205    RETROK_p              = 112,
206    RETROK_q              = 113,
207    RETROK_r              = 114,
208    RETROK_s              = 115,
209    RETROK_t              = 116,
210    RETROK_u              = 117,
211    RETROK_v              = 118,
212    RETROK_w              = 119,
213    RETROK_x              = 120,
214    RETROK_y              = 121,
215    RETROK_z              = 122,
216    RETROK_DELETE         = 127,
217
218    RETROK_KP0            = 256,
219    RETROK_KP1            = 257,
220    RETROK_KP2            = 258,
221    RETROK_KP3            = 259,
222    RETROK_KP4            = 260,
223    RETROK_KP5            = 261,
224    RETROK_KP6            = 262,
225    RETROK_KP7            = 263,
226    RETROK_KP8            = 264,
227    RETROK_KP9            = 265,
228    RETROK_KP_PERIOD      = 266,
229    RETROK_KP_DIVIDE      = 267,
230    RETROK_KP_MULTIPLY    = 268,
231    RETROK_KP_MINUS       = 269,
232    RETROK_KP_PLUS        = 270,
233    RETROK_KP_ENTER       = 271,
234    RETROK_KP_EQUALS      = 272,
235
236    RETROK_UP             = 273,
237    RETROK_DOWN           = 274,
238    RETROK_RIGHT          = 275,
239    RETROK_LEFT           = 276,
240    RETROK_INSERT         = 277,
241    RETROK_HOME           = 278,
242    RETROK_END            = 279,
243    RETROK_PAGEUP         = 280,
244    RETROK_PAGEDOWN       = 281,
245
246    RETROK_F1             = 282,
247    RETROK_F2             = 283,
248    RETROK_F3             = 284,
249    RETROK_F4             = 285,
250    RETROK_F5             = 286,
251    RETROK_F6             = 287,
252    RETROK_F7             = 288,
253    RETROK_F8             = 289,
254    RETROK_F9             = 290,
255    RETROK_F10            = 291,
256    RETROK_F11            = 292,
257    RETROK_F12            = 293,
258    RETROK_F13            = 294,
259    RETROK_F14            = 295,
260    RETROK_F15            = 296,
261
262    RETROK_NUMLOCK        = 300,
263    RETROK_CAPSLOCK       = 301,
264    RETROK_SCROLLOCK      = 302,
265    RETROK_RSHIFT         = 303,
266    RETROK_LSHIFT         = 304,
267    RETROK_RCTRL          = 305,
268    RETROK_LCTRL          = 306,
269    RETROK_RALT           = 307,
270    RETROK_LALT           = 308,
271    RETROK_RMETA          = 309,
272    RETROK_LMETA          = 310,
273    RETROK_LSUPER         = 311,
274    RETROK_RSUPER         = 312,
275    RETROK_MODE           = 313,
276    RETROK_COMPOSE        = 314,
277
278    RETROK_HELP           = 315,
279    RETROK_PRINT          = 316,
280    RETROK_SYSREQ         = 317,
281    RETROK_BREAK          = 318,
282    RETROK_MENU           = 319,
283    RETROK_POWER          = 320,
284    RETROK_EURO           = 321,
285    RETROK_UNDO           = 322,
286
287    RETROK_LAST
288 };
289
290 // Environment commands.
291 #define RETRO_ENVIRONMENT_SET_ROTATION  1  // const unsigned * --
292                                            // Sets screen rotation of graphics.
293                                            // Is only implemented if rotation can be accelerated by hardware.
294                                            // Valid values are 0, 1, 2, 3, which rotates screen by 0, 90, 180, 270 degrees
295                                            // counter-clockwise respectively.
296                                            //
297 #define RETRO_ENVIRONMENT_GET_OVERSCAN  2  // bool * --
298                                            // Boolean value whether or not the implementation should use overscan, or crop away overscan.
299                                            //
300 #define RETRO_ENVIRONMENT_GET_CAN_DUPE  3  // bool * --
301                                            // Boolean value whether or not RetroArch supports frame duping,
302                                            // passing NULL to video frame callback.
303                                            //
304 #define RETRO_ENVIRONMENT_GET_VARIABLE  4  // struct retro_variable * --
305                                            // Interface to aquire user-defined information from environment
306                                            // that cannot feasibly be supported in a multi-system way.
307                                            // Mostly used for obscure,
308                                            // specific features that the user can tap into when neseccary.
309                                            //
310 #define RETRO_ENVIRONMENT_SET_VARIABLES 5  // const struct retro_variable * --
311                                            // Allows an implementation to signal the environment
312                                            // which variables it might want to check for later using GET_VARIABLE.
313                                            // 'data' points to an array of retro_variable structs terminated by a { NULL, NULL } element.
314                                            // retro_variable::value should contain a human readable description of the key.
315                                            //
316 #define RETRO_ENVIRONMENT_SET_MESSAGE   6  // const struct retro_message * --
317                                            // Sets a message to be displayed in implementation-specific manner for a certain amount of 'frames'.
318                                            // Should not be used for trivial messages, which should simply be logged to stderr.
319 #define RETRO_ENVIRONMENT_SHUTDOWN      7  // N/A (NULL) --
320                                            // Requests the frontend to shutdown.
321                                            // Should only be used if game has a specific
322                                            // way to shutdown the game from a menu item or similar.
323                                            //
324 #define RETRO_ENVIRONMENT_SET_PERFORMANCE_LEVEL 8
325                                            // const unsigned * --
326                                            // Gives a hint to the frontend how demanding this implementation
327                                            // is on a system. E.g. reporting a level of 2 means
328                                            // this implementation should run decently on all frontends
329                                            // of level 2 and up.
330                                            //
331                                            // It can be used by the frontend to potentially warn
332                                            // about too demanding implementations.
333                                            // 
334                                            // The levels are "floating", but roughly defined as:
335                                            // 0: Low-powered embedded devices such as Raspberry Pi
336                                            // 1: 6th generation consoles, such as Wii/Xbox 1, and phones, tablets, etc.
337                                            // 2: 7th generation consoles, such as PS3/360, with sub-par CPUs.
338                                            // 3: Modern desktop/laptops with reasonably powerful CPUs.
339                                            // 4: High-end desktops with very powerful CPUs.
340                                            //
341                                            // This function can be called on a per-game basis,
342                                            // as certain games an implementation can play might be
343                                            // particularily demanding.
344                                            // If called, it should be called in retro_load_game().
345                                            //
346 #define RETRO_ENVIRONMENT_GET_SYSTEM_DIRECTORY 9
347                                            // const char ** --
348                                            // Returns the "system" directory of the frontend.
349                                            // This directory can be used to store system specific ROMs such as BIOSes, configuration data, etc.
350                                            // The returned value can be NULL.
351                                            // If so, no such directory is defined,
352                                            // and it's up to the implementation to find a suitable directory.
353                                            //
354 #define RETRO_ENVIRONMENT_SET_PIXEL_FORMAT 10
355                                            // const enum retro_pixel_format * --
356                                            // Sets the internal pixel format used by the implementation.
357                                            // The default pixel format is RETRO_PIXEL_FORMAT_XRGB1555.
358                                            // If the call returns false, the frontend does not support this pixel format.
359                                            // This function should be called inside retro_load_game() or retro_get_system_av_info().
360
361 enum retro_pixel_format
362 {
363    RETRO_PIXEL_FORMAT_0RGB1555 = 0, // 0RGB1555, native endian. 0 bit must be set to 0.
364    RETRO_PIXEL_FORMAT_XRGB8888      // XRGB8888, native endian. X bits are ignored.
365 };
366
367 struct retro_message
368 {
369    const char *msg;        // Message to be displayed.
370    unsigned    frames;     // Duration in frames of message.
371 };
372
373 struct retro_system_info
374 {
375    const char *library_name;      // Descriptive name of library. Should not contain any version numbers, etc.
376    const char *library_version;   // Descriptive version of core.
377
378    const char *valid_extensions;  // A string listing probably rom extensions the core will be able to load, separated with pipe.
379                                   // I.e. "bin|rom|iso".
380                                   // Typically used for a GUI to filter out extensions.
381
382    bool        need_fullpath;     // If true, retro_load_game() is guaranteed to provide a valid pathname in retro_game_info::path.
383                                   // ::data and ::size are both invalid.
384                                   // If false, ::data and ::size are guaranteed to be valid, but ::path might not be valid.
385                                   // This is typically set to true for libretro implementations that must load from file.
386                                   // Implementations should strive for setting this to false, as it allows the frontend to perform patching, etc.
387
388    bool        block_extract;     // If true, the frontend is not allowed to extract any archives before loading the real ROM.
389                                   // Necessary for certain libretro implementations that load games from zipped archives.
390 };
391
392 struct retro_game_geometry
393 {
394    unsigned base_width;    // Nominal video width of game.
395    unsigned base_height;   // Nominal video height of game.
396    unsigned max_width;     // Maximum possible width of game.
397    unsigned max_height;    // Maximum possible height of game.
398
399    float    aspect_ratio;  // Nominal aspect ratio of game. If aspect_ratio is <= 0.0,
400                            // an aspect ratio of base_width / base_height is assumed.
401                            // A frontend could override this setting if desired.
402 };
403
404 struct retro_system_timing
405 {
406    double fps;             // FPS of video content.
407    double sample_rate;     // Sampling rate of audio.
408 };
409
410 struct retro_system_av_info
411 {
412    struct retro_game_geometry geometry;
413    struct retro_system_timing timing;
414 };
415
416 struct retro_variable
417 {
418    const char *key;        // Variable to query in RETRO_ENVIRONMENT_GET_VARIABLE.
419                            // If NULL, obtains the complete environment string if more complex parsing is necessary.
420                            // The environment string is formatted as key-value pairs delimited by semicolons as so:
421                            // "key1=value1;key2=value2;..."
422    const char *value;      // Value to be obtained. If key does not exist, it is set to NULL.
423 };
424
425 struct retro_game_info
426 {
427    const char *path;       // Path to game, UTF-8 encoded. Usually used as a reference.
428                            // May be NULL if rom was loaded from stdin or similar.
429                            // retro_system_info::need_fullpath guaranteed that this path is valid.
430    const void *data;       // Memory buffer of loaded game. Will be NULL if need_fullpath was set.
431    size_t      size;       // Size of memory buffer.
432    const char *meta;       // String of implementation specific meta-data.
433 };
434
435 // Callbacks
436 //
437 // Environment callback. Gives implementations a way of performing uncommon tasks. Extensible.
438 typedef bool (*retro_environment_t)(unsigned cmd, void *data);
439
440 // Render a frame. Pixel format is 15-bit 0RGB1555 native endian unless changed (see RETRO_ENVIRONMENT_SET_PIXEL_FORMAT).
441 // Width and height specify dimensions of buffer.
442 // Pitch specifices length in bytes between two lines in buffer.
443 typedef void (*retro_video_refresh_t)(const void *data, unsigned width, unsigned height, size_t pitch);
444
445 // Renders a single audio frame. Should only be used if implementation generates a single sample at a time.
446 // Format is signed 16-bit native endian.
447 typedef void (*retro_audio_sample_t)(int16_t left, int16_t right);
448 // Renders multiple audio frames in one go. One frame is defined as a sample of left and right channels, interleaved.
449 // I.e. int16_t buf[4] = { l, r, l, r }; would be 2 frames.
450 // Only one of the audio callbacks must ever be used.
451 typedef size_t (*retro_audio_sample_batch_t)(const int16_t *data, size_t frames);
452
453 // Polls input.
454 typedef void (*retro_input_poll_t)(void);
455 // Queries for input for player 'port'. device will be masked with RETRO_DEVICE_MASK.
456 // Specialization of devices such as RETRO_DEVICE_JOYPAD_MULTITAP that have been set with retro_set_controller_port_device()
457 // will still use the higher level RETRO_DEVICE_JOYPAD to request input.
458 typedef int16_t (*retro_input_state_t)(unsigned port, unsigned device, unsigned index, unsigned id);
459
460 // Sets callbacks. retro_set_environment() is guaranteed to be called before retro_init().
461 // The rest of the set_* functions are guaranteed to have been called before the first call to retro_run() is made.
462 void retro_set_environment(retro_environment_t);
463 void retro_set_video_refresh(retro_video_refresh_t);
464 void retro_set_audio_sample(retro_audio_sample_t);
465 void retro_set_audio_sample_batch(retro_audio_sample_batch_t);
466 void retro_set_input_poll(retro_input_poll_t);
467 void retro_set_input_state(retro_input_state_t);
468
469 // Library global initialization/deinitialization.
470 void retro_init(void);
471 void retro_deinit(void);
472
473 // Must return RETRO_API_VERSION. Used to validate ABI compatibility when the API is revised.
474 unsigned retro_api_version(void);
475
476 // Gets statically known system info. Pointers provided in *info must be statically allocated.
477 // Can be called at any time, even before retro_init().
478 void retro_get_system_info(struct retro_system_info *info);
479
480 // Gets information about system audio/video timings and geometry.
481 // Can be called only after retro_load_game() has successfully completed.
482 void retro_get_system_av_info(struct retro_system_av_info *info);
483
484 // Sets device to be used for player 'port'.
485 void retro_set_controller_port_device(unsigned port, unsigned device);
486
487 // Resets the current game.
488 void retro_reset(void);
489
490 // Runs the game for one video frame.
491 // During retro_run(), input_poll callback must be called at least once.
492 //
493 // If a frame is not rendered for reasons where a game "dropped" a frame,
494 // this still counts as a frame, and retro_run() should explicitly dupe a frame if GET_CAN_DUPE returns true.
495 // In this case, the video callback can take a NULL argument for data.
496 void retro_run(void);
497
498 // Returns the amount of data the implementation requires to serialize internal state (save states).
499 // Beetween calls to retro_load_game() and retro_unload_game(), the returned size is never allowed to be larger than a previous returned value, to
500 // ensure that the frontend can allocate a save state buffer once.
501 size_t retro_serialize_size(void);
502
503 // Serializes internal state. If failed, or size is lower than retro_serialize_size(), it should return false, true otherwise.
504 bool retro_serialize(void *data, size_t size);
505 bool retro_unserialize(const void *data, size_t size);
506
507 void retro_cheat_reset(void);
508 void retro_cheat_set(unsigned index, bool enabled, const char *code);
509
510 // Loads a game.
511 bool retro_load_game(const struct retro_game_info *game);
512
513 // Loads a "special" kind of game. Should not be used except in extreme cases.
514 bool retro_load_game_special(
515   unsigned game_type,
516   const struct retro_game_info *info, size_t num_info
517 );
518
519 // Unloads a currently loaded game.
520 void retro_unload_game(void);
521
522 // Gets region of game.
523 unsigned retro_get_region(void);
524
525 // Gets region of memory.
526 void *retro_get_memory_data(unsigned id);
527 size_t retro_get_memory_size(unsigned id);
528
529 #ifdef __cplusplus
530 }
531 #endif
532
533 #endif