game.h

/*
 *  Copyright (C) 2014-2025 Team Kodi
 *  This file is part of Kodi - https://kodi.tv
 *
 *  SPDX-License-Identifier: GPL-2.0-or-later
 *  See LICENSES/README.md for more information.
 */
 
#ifndef C_API_ADDONINSTANCE_GAME_H
#define C_API_ADDONINSTANCE_GAME_H
 
#include "../addon_base.h"
 
#include <stddef.h> /* size_t */
#include <stdint.h>
 
#ifdef __cplusplus
extern "C"
{
#endif /* __cplusplus */
 
  //============================================================================
  typedef enum GAME_ERROR
  {
    GAME_ERROR_NO_ERROR,
 
    GAME_ERROR_UNKNOWN,
 
    GAME_ERROR_NOT_IMPLEMENTED,
 
    GAME_ERROR_REJECTED,
 
    GAME_ERROR_INVALID_PARAMETERS,
 
    GAME_ERROR_FAILED,
 
    GAME_ERROR_NOT_LOADED,
 
    GAME_ERROR_RESTRICTED,
 
    GAME_ERROR_MISSING_FILES,
  } GAME_ERROR;
  //----------------------------------------------------------------------------
 
  //--==----==----==----==----==----==----==----==----==----==----==----==----==--
 
  //============================================================================
  typedef enum GAME_PCM_FORMAT
  {
    GAME_PCM_FORMAT_UNKNOWN,
 
    GAME_PCM_FORMAT_S16NE,
  } GAME_PCM_FORMAT;
  //----------------------------------------------------------------------------
 
  //============================================================================
  typedef enum GAME_AUDIO_CHANNEL
  {
    GAME_CH_NULL,
 
    GAME_CH_FL,
 
    GAME_CH_FR,
 
    GAME_CH_FC,
 
    GAME_CH_LFE,
 
    GAME_CH_BL,
 
    GAME_CH_BR,
 
    GAME_CH_FLOC,
 
    GAME_CH_FROC,
 
    GAME_CH_BC,
 
    GAME_CH_SL,
 
    GAME_CH_SR,
 
    GAME_CH_TFL,
 
    GAME_CH_TFR,
 
    GAME_CH_TFC,
 
    GAME_CH_TC,
 
    GAME_CH_TBL,
 
    GAME_CH_TBR,
 
    GAME_CH_TBC,
 
    GAME_CH_BLOC,
 
    GAME_CH_BROC,
  } GAME_AUDIO_CHANNEL;
  //----------------------------------------------------------------------------
 
  //============================================================================
  typedef struct game_stream_audio_properties
  {
    GAME_PCM_FORMAT format;
    const GAME_AUDIO_CHANNEL* channel_map;
  } ATTR_PACKED game_stream_audio_properties;
  //----------------------------------------------------------------------------
 
  //============================================================================
  typedef struct game_stream_audio_packet
  {
    const uint8_t* data;
 
    size_t size;
  } ATTR_PACKED game_stream_audio_packet;
  //----------------------------------------------------------------------------
 
 
  //--==----==----==----==----==----==----==----==----==----==----==----==----==--
 
  //============================================================================
  typedef enum GAME_PIXEL_FORMAT
  {
    GAME_PIXEL_FORMAT_UNKNOWN,
 
    GAME_PIXEL_FORMAT_0RGB8888,
 
    GAME_PIXEL_FORMAT_RGB565,
 
    GAME_PIXEL_FORMAT_0RGB1555,
  } GAME_PIXEL_FORMAT;
  //----------------------------------------------------------------------------
 
  //============================================================================
  typedef enum GAME_VIDEO_ROTATION
  {
    GAME_VIDEO_ROTATION_0,
 
    GAME_VIDEO_ROTATION_90_CCW,
 
    GAME_VIDEO_ROTATION_180_CCW,
 
    GAME_VIDEO_ROTATION_270_CCW,
  } GAME_VIDEO_ROTATION;
  //----------------------------------------------------------------------------
 
  //============================================================================
  typedef struct game_stream_video_properties
  {
    GAME_PIXEL_FORMAT format;
 
    unsigned int nominal_width;
 
    unsigned int nominal_height;
 
    float nominal_display_aspect_ratio;
 
    unsigned int max_width;
 
    unsigned int max_height;
  } ATTR_PACKED game_stream_video_properties;
  //----------------------------------------------------------------------------
 
  //============================================================================
  typedef struct game_stream_video_packet
  {
    unsigned int width;
 
    unsigned int height;
 
    float display_aspect_ratio;
 
    GAME_VIDEO_ROTATION rotation;
 
    const uint8_t* data;
 
    size_t size;
  } ATTR_PACKED game_stream_video_packet;
  //----------------------------------------------------------------------------
 
 
  //--==----==----==----==----==----==----==----==----==----==----==----==----==--
 
  //============================================================================
  typedef enum GAME_HW_CONTEXT_TYPE
  {
    GAME_HW_CONTEXT_NONE,
 
    GAME_HW_CONTEXT_OPENGL,
 
    GAME_HW_CONTEXT_OPENGLES2,
 
    GAME_HW_CONTEXT_OPENGL_CORE,
 
    GAME_HW_CONTEXT_OPENGLES3,
 
    GAME_HW_CONTEXT_OPENGLES_VERSION,
 
    GAME_HW_CONTEXT_VULKAN
  } GAME_HW_CONTEXT_TYPE;
  //----------------------------------------------------------------------------
 
  //==============================================================================
  typedef struct game_hw_rendering_properties
  {
    GAME_HW_CONTEXT_TYPE context_type;
 
    bool depth;
 
    bool stencil;
 
    bool bottom_left_origin;
 
    unsigned int version_major;
 
    unsigned int version_minor;
 
    bool cache_context;
 
    bool debug_context;
 
  } ATTR_PACKED game_hw_rendering_properties;
  //------------------------------------------------------------------------------
 
  //==============================================================================
  typedef struct game_stream_hw_framebuffer_properties
  {
    unsigned int max_width;
 
    unsigned int max_height;
 
    float nominal_display_aspect_ratio;
 
  } ATTR_PACKED game_stream_hw_framebuffer_properties;
  //----------------------------------------------------------------------------
 
  //============================================================================
  typedef struct game_stream_hw_framebuffer_buffer
  {
    uintptr_t framebuffer;
  } ATTR_PACKED game_stream_hw_framebuffer_buffer;
  //----------------------------------------------------------------------------
 
  //============================================================================
  typedef struct game_stream_hw_framebuffer_packet
  {
    uintptr_t framebuffer;
 
    unsigned int width;
    unsigned int height;
 
    float display_aspect_ratio;
 
    GAME_VIDEO_ROTATION rotation;
  } ATTR_PACKED game_stream_hw_framebuffer_packet;
  //----------------------------------------------------------------------------
 
  //============================================================================
  typedef void (*game_proc_address_t)(void);
  //----------------------------------------------------------------------------
 
 
  //--==----==----==----==----==----==----==----==----==----==----==----==----==--
 
  //============================================================================
  typedef game_stream_video_properties game_stream_sw_framebuffer_properties;
  //----------------------------------------------------------------------------
 
  //============================================================================
  typedef struct game_stream_sw_framebuffer_buffer
  {
    GAME_PIXEL_FORMAT format;
    uint8_t* data;
    size_t size;
  } ATTR_PACKED game_stream_sw_framebuffer_buffer;
  //----------------------------------------------------------------------------
 
  //============================================================================
  typedef game_stream_video_packet game_stream_sw_framebuffer_packet;
  //----------------------------------------------------------------------------
 
 
  //--==----==----==----==----==----==----==----==----==----==----==----==----==--
 
  //============================================================================
  typedef enum GAME_STREAM_TYPE
  {
    GAME_STREAM_UNKNOWN,
 
    GAME_STREAM_AUDIO,
 
    GAME_STREAM_VIDEO,
 
    GAME_STREAM_HW_FRAMEBUFFER,
 
    GAME_STREAM_SW_FRAMEBUFFER,
  } GAME_STREAM_TYPE;
  //----------------------------------------------------------------------------
 
  //============================================================================
  typedef struct game_stream_properties
  {
    GAME_STREAM_TYPE type;
 
    union
    {
      game_stream_audio_properties audio;
 
      game_stream_video_properties video;
 
      game_stream_hw_framebuffer_properties hw_framebuffer;
 
      game_stream_sw_framebuffer_properties sw_framebuffer;
    };
  } ATTR_PACKED game_stream_properties;
  //----------------------------------------------------------------------------
 
  //============================================================================
  typedef struct game_stream_buffer
  {
    GAME_STREAM_TYPE type;
 
    union
    {
      game_stream_hw_framebuffer_buffer hw_framebuffer;
 
      game_stream_sw_framebuffer_buffer sw_framebuffer;
    };
  } ATTR_PACKED game_stream_buffer;
  //----------------------------------------------------------------------------
 
  //============================================================================
  typedef struct game_stream_packet
  {
    GAME_STREAM_TYPE type;
 
    union
    {
      game_stream_audio_packet audio;
 
      game_stream_video_packet video;
 
      game_stream_hw_framebuffer_packet hw_framebuffer;
 
      game_stream_sw_framebuffer_packet sw_framebuffer;
    };
  } ATTR_PACKED game_stream_packet;
  //----------------------------------------------------------------------------
 
 
  //--==----==----==----==----==----==----==----==----==----==----==----==----==--
 
  //============================================================================
  typedef enum GAME_REGION
  {
    GAME_REGION_UNKNOWN,
 
    GAME_REGION_NTSC,
 
    GAME_REGION_PAL,
  } GAME_REGION;
  //----------------------------------------------------------------------------
 
  //============================================================================
  typedef enum SPECIAL_GAME_TYPE
  {
    SPECIAL_GAME_TYPE_BSX,
 
    SPECIAL_GAME_TYPE_BSX_SLOTTED,
 
    SPECIAL_GAME_TYPE_SUFAMI_TURBO,
 
    SPECIAL_GAME_TYPE_SUPER_GAME_BOY,
  } SPECIAL_GAME_TYPE;
  //----------------------------------------------------------------------------
 
  //============================================================================
  typedef enum GAME_MEMORY
  {
    GAME_MEMORY_MASK = 0xff,
 
    GAME_MEMORY_SAVE_RAM = 0,
 
    GAME_MEMORY_RTC = 1,
 
    GAME_MEMORY_SYSTEM_RAM = 2,
 
    GAME_MEMORY_VIDEO_RAM = 3,
 
    GAME_MEMORY_SNES_BSX_RAM = ((1 << 8) | GAME_MEMORY_SAVE_RAM),
 
    GAME_MEMORY_SNES_BSX_PRAM = ((2 << 8) | GAME_MEMORY_SAVE_RAM),
 
    GAME_MEMORY_SNES_SUFAMI_TURBO_A_RAM = ((3 << 8) | GAME_MEMORY_SAVE_RAM),
 
    GAME_MEMORY_SNES_SUFAMI_TURBO_B_RAM = ((4 << 8) | GAME_MEMORY_SAVE_RAM),
 
    GAME_MEMORY_SNES_GAME_BOY_RAM = ((5 << 8) | GAME_MEMORY_SAVE_RAM),
 
    GAME_MEMORY_SNES_GAME_BOY_RTC = ((6 << 8) | GAME_MEMORY_RTC),
  } GAME_MEMORY;
  //----------------------------------------------------------------------------
 
  //============================================================================
  typedef enum GAME_SIMD
  {
    GAME_SIMD_SSE = (1 << 0),
 
    GAME_SIMD_SSE2 = (1 << 1),
 
    GAME_SIMD_VMX = (1 << 2),
 
    GAME_SIMD_VMX128 = (1 << 3),
 
    GAME_SIMD_AVX = (1 << 4),
 
    GAME_SIMD_NEON = (1 << 5),
 
    GAME_SIMD_SSE3 = (1 << 6),
 
    GAME_SIMD_SSSE3 = (1 << 7),
 
    GAME_SIMD_MMX = (1 << 8),
 
    GAME_SIMD_MMXEXT = (1 << 9),
 
    GAME_SIMD_SSE4 = (1 << 10),
 
    GAME_SIMD_SSE42 = (1 << 11),
 
    GAME_SIMD_AVX2 = (1 << 12),
 
    GAME_SIMD_VFPU = (1 << 13),
  } GAME_SIMD;
  //----------------------------------------------------------------------------
 
 
  //--==----==----==----==----==----==----==----==----==----==----==----==----==--
 
  //==============================================================================
#define ROOT_PORT_ADDRESS "/"
  //------------------------------------------------------------------------------
 
  //==============================================================================
#define DEFAULT_PORT_ID "1"
  //------------------------------------------------------------------------------
 
  //==============================================================================
#define KEYBOARD_PORT_ID "keyboard"
  //------------------------------------------------------------------------------
 
  //==============================================================================
#define MOUSE_PORT_ID "mouse"
  //------------------------------------------------------------------------------
 
  //==============================================================================
#define DEFAULT_PORT_ADDRESS "/1"
  //------------------------------------------------------------------------------
 
  //==============================================================================
#define KEYBOARD_PORT_ADDRESS "/keyboard"
  //------------------------------------------------------------------------------
 
  //==============================================================================
#define MOUSE_PORT_ADDRESS "/mouse"
  //------------------------------------------------------------------------------
 
  //============================================================================
  typedef enum GAME_INPUT_EVENT_SOURCE
  {
    GAME_INPUT_EVENT_DIGITAL_BUTTON,
 
    GAME_INPUT_EVENT_ANALOG_BUTTON,
 
    GAME_INPUT_EVENT_AXIS,
 
    GAME_INPUT_EVENT_ANALOG_STICK,
 
    GAME_INPUT_EVENT_ACCELEROMETER,
 
    GAME_INPUT_EVENT_KEY,
 
    GAME_INPUT_EVENT_RELATIVE_POINTER,
 
    GAME_INPUT_EVENT_ABSOLUTE_POINTER,
 
    GAME_INPUT_EVENT_MOTOR,
  } GAME_INPUT_EVENT_SOURCE;
  //----------------------------------------------------------------------------
 
  //============================================================================
  typedef enum GAME_KEY_MOD
  {
    GAME_KEY_MOD_NONE = 0x0000,
 
    GAME_KEY_MOD_SHIFT = 0x0001,
 
    GAME_KEY_MOD_CTRL = 0x0002,
 
    GAME_KEY_MOD_ALT = 0x0004,
 
    GAME_KEY_MOD_META = 0x0008,
 
    GAME_KEY_MOD_SUPER = 0x0010,
 
    GAME_KEY_MOD_NUMLOCK = 0x0100,
 
    GAME_KEY_MOD_CAPSLOCK = 0x0200,
 
    GAME_KEY_MOD_SCROLLOCK = 0x0400,
  } GAME_KEY_MOD;
  //----------------------------------------------------------------------------
 
  //============================================================================
  typedef enum GAME_PORT_TYPE
  {
    GAME_PORT_UNKNOWN,
 
    GAME_PORT_KEYBOARD,
 
    GAME_PORT_MOUSE,
 
    GAME_PORT_CONTROLLER,
  } GAME_PORT_TYPE;
  //----------------------------------------------------------------------------
 
  typedef struct game_controller_layout
  {
    char* controller_id;
    bool provides_input; // False for multitaps
    char** digital_buttons;
    unsigned int digital_button_count;
    char** analog_buttons;
    unsigned int analog_button_count;
    char** analog_sticks;
    unsigned int analog_stick_count;
    char** accelerometers;
    unsigned int accelerometer_count;
    char** keys;
    unsigned int key_count;
    char** rel_pointers;
    unsigned int rel_pointer_count;
    char** abs_pointers;
    unsigned int abs_pointer_count;
    char** motors;
    unsigned int motor_count;
  } ATTR_PACKED game_controller_layout;
 
  struct game_input_port;
 
  //============================================================================
  typedef struct game_input_device
  {
    const char* controller_id;
 
    const char* port_address;
 
    struct game_input_port* available_ports;
 
    unsigned int port_count;
  } ATTR_PACKED game_input_device;
  //----------------------------------------------------------------------------
 
  //============================================================================
  typedef struct game_input_port
  {
    GAME_PORT_TYPE type;
 
    const char* port_id;
 
    bool force_connected;
 
    bool autoconnect;
 
    game_input_device* accepted_devices;
 
    unsigned int device_count;
  } ATTR_PACKED game_input_port;
  //----------------------------------------------------------------------------
 
  //============================================================================
  typedef struct game_input_topology
  {
    game_input_port* ports;
 
    unsigned int port_count;
 
    int player_limit;
  } ATTR_PACKED game_input_topology;
  //----------------------------------------------------------------------------
 
  //============================================================================
  typedef struct game_digital_button_event
  {
    bool pressed;
  } ATTR_PACKED game_digital_button_event;
  //----------------------------------------------------------------------------
 
  //============================================================================
  typedef struct game_analog_button_event
  {
    float magnitude;
  } ATTR_PACKED game_analog_button_event;
  //----------------------------------------------------------------------------
 
  //============================================================================
  typedef struct game_axis_event
  {
    float position;
  } ATTR_PACKED game_axis_event;
  //----------------------------------------------------------------------------
 
  //============================================================================
  typedef struct game_analog_stick_event
  {
    float x;
 
    float y;
  } ATTR_PACKED game_analog_stick_event;
  //----------------------------------------------------------------------------
 
  //============================================================================
  typedef struct game_accelerometer_event
  {
    float x;
 
    float y;
 
    float z;
  } ATTR_PACKED game_accelerometer_event;
  //----------------------------------------------------------------------------
 
  //============================================================================
  typedef struct game_key_event
  {
    bool pressed;
 
    uint32_t unicode;
 
    GAME_KEY_MOD modifiers;
  } ATTR_PACKED game_key_event;
  //----------------------------------------------------------------------------
 
  //============================================================================
  typedef struct game_rel_pointer_event
  {
    int x;
 
    int y;
  } ATTR_PACKED game_rel_pointer_event;
  //----------------------------------------------------------------------------
 
  //============================================================================
  typedef struct game_abs_pointer_event
  {
    bool pressed;
 
    float x;
 
    float y;
  } ATTR_PACKED game_abs_pointer_event;
  //----------------------------------------------------------------------------
 
  //============================================================================
  typedef struct game_motor_event
  {
    float magnitude;
  } ATTR_PACKED game_motor_event;
  //----------------------------------------------------------------------------
 
  //============================================================================
  typedef struct game_input_event
  {
    GAME_INPUT_EVENT_SOURCE type;
 
    const char* controller_id;
 
    GAME_PORT_TYPE port_type;
 
    const char* port_address;
 
    const char* feature_name;
 
    union
    {
      struct game_digital_button_event digital_button;
 
      struct game_analog_button_event analog_button;
 
      struct game_axis_event axis;
 
      struct game_analog_stick_event analog_stick;
 
      struct game_accelerometer_event accelerometer;
 
      struct game_key_event key;
 
      struct game_rel_pointer_event rel_pointer;
 
      struct game_abs_pointer_event abs_pointer;
 
      struct game_motor_event motor;
    };
  } ATTR_PACKED game_input_event;
  //----------------------------------------------------------------------------
 
 
  //--==----==----==----==----==----==----==----==----==----==----==----==----==--
 
  //============================================================================
  struct game_system_timing
  {
    double fps;
 
    double sample_rate;
  };
  //----------------------------------------------------------------------------
 
 
  //--==----==----==----==----==----==----==----==----==----==----==----==----==--
 
  //============================================================================
  typedef enum GAME_RC_UNLOCK_STATE
  {
    GAME_RC_UNLOCK_STATE_LOCKED = 0,
 
    GAME_RC_UNLOCK_STATE_SOFTCORE = 1,
 
    GAME_RC_UNLOCK_STATE_HARDCORE = 2,
  } GAME_RC_UNLOCK_STATE;
  //----------------------------------------------------------------------------
 
  //============================================================================
  typedef struct game_rc_achievement
  {
    unsigned int id;
 
    const char* title;
 
    const char* description;
 
    const char* badge_url;
 
    const char* badge_locked_url;
 
    unsigned int points;
 
    GAME_RC_UNLOCK_STATE unlock_state;
 
    int64_t unlock_time;
 
    float rarity;
 
    float rarity_hardcore;
  } ATTR_PACKED game_rc_achievement;
  //----------------------------------------------------------------------------
 
  //============================================================================
  typedef struct game_rc_game_loaded
  {
    unsigned int game_id;
 
    const char* title;
 
    const char* icon_url;
 
    const game_rc_achievement* achievements;
 
    unsigned int achievement_count;
  } ATTR_PACKED game_rc_game_loaded;
  //----------------------------------------------------------------------------
 
  //============================================================================
  typedef struct game_rc_achievement_triggered
  {
    unsigned int id;
 
    const char* title;
 
    const char* description;
 
    const char* badge_url;
 
    unsigned int points;
 
    bool hardcore;
  } ATTR_PACKED game_rc_achievement_triggered;
  //----------------------------------------------------------------------------
 
  //============================================================================
  typedef struct game_rc_login_result
  {
    bool success;
 
    const char* username;
 
    const char* display_name;
 
    const char* icon_url;
 
    unsigned int points;
 
    const char* error_message;
 
    bool credentials_rejected;
  } ATTR_PACKED game_rc_login_result;
  //----------------------------------------------------------------------------
 
  //============================================================================
  typedef struct game_rc_achievement_progress
  {
    unsigned int id;
 
    float measured_percent;
 
    const char* measured_progress;
  } ATTR_PACKED game_rc_achievement_progress;
 
  //============================================================================
  typedef struct game_rc_leaderboard
  {
    unsigned int id;
 
    const char* title;
 
    const char* description;
 
    const char* value;
  } ATTR_PACKED game_rc_leaderboard;
 
  //============================================================================
  typedef struct game_rc_leaderboard_scoreboard
  {
    unsigned int id;
 
    const char* submitted_score;
 
    const char* best_score;
 
    unsigned int new_rank;
 
    unsigned int num_entries;
  } ATTR_PACKED game_rc_leaderboard_scoreboard;
 
  //============================================================================
  typedef struct game_rc_leaderboard_tracker
  {
    unsigned int id;
 
    const char* display;
  } ATTR_PACKED game_rc_leaderboard_tracker;
 
  //============================================================================
  typedef struct game_rc_achievement_challenge
  {
    unsigned int id;
 
    const char* title;
 
    const char* badge_url;
  } ATTR_PACKED game_rc_achievement_challenge;
 
  //============================================================================
  typedef struct game_rc_achievement_progress_indicator
  {
    unsigned int id;
 
    const char* title;
 
    const char* badge_url;
 
    const char* measured_progress;
 
    float measured_percent;
  } ATTR_PACKED game_rc_achievement_progress_indicator;
  //----------------------------------------------------------------------------
 
 
  //--==----==----==----==----==----==----==----==----==----==----==----==----==--
 
  typedef struct AddonProps_Game
  {
    const char* game_client_dll_path;
 
    const char** proxy_dll_paths;
 
    unsigned int proxy_dll_count;
 
    const char** resource_directories;
 
    unsigned int resource_directory_count;
 
    const char* profile_directory;
 
    bool supports_vfs;
 
    const char** extensions;
 
    unsigned int extension_count;
 
    const char* libretro_core;
  } AddonProps_Game;
 
  typedef void* KODI_GAME_STREAM_HANDLE;
 
  struct AddonInstance_Game;
 
  typedef struct AddonToKodiFuncTable_Game
  {
    KODI_HANDLE kodiInstance;
 
    bool (*EnableHardwareRendering)(void*, const game_hw_rendering_properties*);
    void (*CloseGame)(KODI_HANDLE kodiInstance);
    double (*GetPlaybackSpeed)(KODI_HANDLE kodiInstance);
    void (*SetGameTiming)(KODI_HANDLE kodiInstance, const struct game_system_timing* timing_info);
    KODI_GAME_STREAM_HANDLE (*OpenStream)(KODI_HANDLE, const struct game_stream_properties*);
    bool (*GetStreamBuffer)(KODI_HANDLE,
                            KODI_GAME_STREAM_HANDLE,
                            unsigned int,
                            unsigned int,
                            struct game_stream_buffer*);
    void (*AddStreamData)(KODI_HANDLE, KODI_GAME_STREAM_HANDLE, const struct game_stream_packet*);
    void (*ReleaseStreamBuffer)(KODI_HANDLE, KODI_GAME_STREAM_HANDLE, struct game_stream_buffer*);
    void (*CloseStream)(KODI_HANDLE, KODI_GAME_STREAM_HANDLE);
    game_proc_address_t (*HwGetProcAddress)(KODI_HANDLE kodiInstance, const char* symbol);
    bool (*InputEvent)(KODI_HANDLE kodiInstance, const struct game_input_event* event);
    void (*RCOnGameLoaded)(KODI_HANDLE kodiInstance, const struct game_rc_game_loaded* data);
    void (*RCOnAchievementTriggered)(KODI_HANDLE kodiInstance,
                                     const struct game_rc_achievement_triggered* data);
    void (*RCOnGameCompleted)(KODI_HANDLE kodiInstance, const char* title, bool hardcore);
    void (*RCOnRichPresenceUpdated)(KODI_HANDLE kodiInstance, const char* evaluation);
    void (*RCOnLoginResult)(KODI_HANDLE kodiInstance, const struct game_rc_login_result* data);
 
    void (*RCOnAchievementProgress)(KODI_HANDLE kodiInstance,
                                    const struct game_rc_achievement_progress* progress,
                                    unsigned int count);
    void (*RCOnServerError)(KODI_HANDLE kodiInstance, const char* message, const char* api);
    void (*RCOnConnectionChanged)(KODI_HANDLE kodiInstance, bool connected);
 
    void (*RCOnChallengeIndicator)(KODI_HANDLE kodiInstance,
                                   const struct game_rc_achievement_challenge* data,
                                   bool show);
    void (*RCOnAchievementProgressShow)(KODI_HANDLE kodiInstance,
                                        const struct game_rc_achievement_progress_indicator* data);
    void (*RCOnAchievementProgressUpdate)(
        KODI_HANDLE kodiInstance, const struct game_rc_achievement_progress_indicator* data);
    void (*RCOnAchievementProgressHide)(KODI_HANDLE kodiInstance,
                                        const struct game_rc_achievement_progress_indicator* data);
    void (*RCOnLeaderboardStarted)(KODI_HANDLE kodiInstance,
                                   const struct game_rc_leaderboard* data);
    void (*RCOnLeaderboardFailed)(KODI_HANDLE kodiInstance, const struct game_rc_leaderboard* data);
    void (*RCOnLeaderboardSubmitted)(KODI_HANDLE kodiInstance,
                                     const struct game_rc_leaderboard* data);
    void (*RCOnLeaderboardTrackerShow)(KODI_HANDLE kodiInstance,
                                       const struct game_rc_leaderboard_tracker* data);
    void (*RCOnLeaderboardTrackerUpdate)(KODI_HANDLE kodiInstance,
                                         const struct game_rc_leaderboard_tracker* data);
    void (*RCOnLeaderboardTrackerHide)(KODI_HANDLE kodiInstance,
                                       const struct game_rc_leaderboard_tracker* data);
    void (*RCOnLeaderboardScoreboard)(KODI_HANDLE kodiInstance,
                                      const struct game_rc_leaderboard_scoreboard* data);
    void (*RCOnReset)(KODI_HANDLE kodiInstance);
    void (*RCOnSubsetCompleted)(KODI_HANDLE kodiInstance, const char* title);
 
    bool (*StartStream)(KODI_HANDLE, KODI_GAME_STREAM_HANDLE);
 
    void (*ReportMissingFile)(KODI_HANDLE kodiInstance, const char* path);
 
    void (*SetFastForwarding)(KODI_HANDLE kodiInstance, bool fastForward, double ratio);
  } AddonToKodiFuncTable_Game;
 
  typedef struct KodiToAddonFuncTable_Game
  {
    KODI_HANDLE addonInstance;
 
    GAME_ERROR(__cdecl* LoadGame)(const struct AddonInstance_Game*, const char*);
    GAME_ERROR(__cdecl* LoadGameSpecial)
    (const struct AddonInstance_Game*, enum SPECIAL_GAME_TYPE, const char**, size_t);
    GAME_ERROR(__cdecl* LoadStandalone)(const struct AddonInstance_Game*);
    GAME_ERROR(__cdecl* UnloadGame)(const struct AddonInstance_Game*);
    GAME_ERROR(__cdecl* GetGameTiming)
    (const struct AddonInstance_Game*, struct game_system_timing*);
    GAME_REGION(__cdecl* GetRegion)(const struct AddonInstance_Game*);
    bool(__cdecl* RequiresGameLoop)(const struct AddonInstance_Game*);
    GAME_ERROR(__cdecl* RunFrame)(const struct AddonInstance_Game*);
    GAME_ERROR(__cdecl* Reset)(const struct AddonInstance_Game*);
    GAME_ERROR(__cdecl* HwContextReset)(const struct AddonInstance_Game*);
    GAME_ERROR(__cdecl* HwContextDestroy)(const struct AddonInstance_Game*);
    GAME_ERROR(__cdecl* AudioAvailable)(const AddonInstance_Game*);
    bool(__cdecl* HasFeature)(const struct AddonInstance_Game*, const char*, const char*);
    game_input_topology*(__cdecl* GetTopology)(const struct AddonInstance_Game*);
    void(__cdecl* FreeTopology)(const struct AddonInstance_Game*, struct game_input_topology*);
    void(__cdecl* SetControllerLayouts)(const struct AddonInstance_Game*,
                                        const struct game_controller_layout*,
                                        unsigned int);
    bool(__cdecl* EnableKeyboard)(const struct AddonInstance_Game*, bool, const char*);
    bool(__cdecl* EnableMouse)(const struct AddonInstance_Game*, bool, const char*);
    bool(__cdecl* ConnectController)(const struct AddonInstance_Game*,
                                     bool,
                                     const char*,
                                     const char*);
    bool(__cdecl* InputEvent)(const struct AddonInstance_Game*, const struct game_input_event*);
    size_t(__cdecl* SerializeSize)(const struct AddonInstance_Game*);
    GAME_ERROR(__cdecl* Serialize)(const struct AddonInstance_Game*, uint8_t*, size_t);
    GAME_ERROR(__cdecl* Deserialize)(const struct AddonInstance_Game*, const uint8_t*, size_t);
    GAME_ERROR(__cdecl* CheatReset)(const struct AddonInstance_Game*);
    GAME_ERROR(__cdecl* GetMemory)
    (const struct AddonInstance_Game*, enum GAME_MEMORY, uint8_t**, size_t*);
    GAME_ERROR(__cdecl* SetCheat)
    (const struct AddonInstance_Game*, unsigned int, bool, const char*);
    bool(__cdecl* GetEjectState)(const AddonInstance_Game*);
    GAME_ERROR(__cdecl* SetEjectState)(const AddonInstance_Game*, bool);
    unsigned int(__cdecl* GetImageIndex)(const AddonInstance_Game*);
    GAME_ERROR(__cdecl* SetImageIndex)(const AddonInstance_Game*, unsigned int);
    unsigned int(__cdecl* GetImageCount)(const AddonInstance_Game*);
    GAME_ERROR(__cdecl* AddImageIndex)(const AddonInstance_Game*);
    GAME_ERROR(__cdecl* ReplaceImageIndex)(const AddonInstance_Game*, unsigned int, const char*);
    GAME_ERROR(__cdecl* RemoveImageIndex)(const AddonInstance_Game*, unsigned int);
    GAME_ERROR(__cdecl* SetInitialImage)(const AddonInstance_Game*, unsigned int, const char*);
    char*(__cdecl* GetImagePath)(const AddonInstance_Game*, unsigned int);
    char*(__cdecl* GetImageLabel)(const AddonInstance_Game*, unsigned int);
    GAME_ERROR(__cdecl* SetRetroAchievementsCredentials)
    (const AddonInstance_Game*, const char*, const char*);
    GAME_ERROR(__cdecl* RCSetHardcoreEnabled)(const AddonInstance_Game*, bool);
    GAME_ERROR(__cdecl* RCSetEncoreModeEnabled)(const AddonInstance_Game*, bool);
    GAME_ERROR(__cdecl* ActivateAchievement)(const AddonInstance_Game*, unsigned int, const char*);
    GAME_ERROR(__cdecl* GetCheevoUrlId)
    (const AddonInstance_Game*,
     void(__cdecl*)(const void*, const char*, unsigned int),
     const void*);
    size_t(__cdecl* AchievementStateSize)(const struct AddonInstance_Game*);
    GAME_ERROR(__cdecl* SerializeAchievements)
    (const struct AddonInstance_Game*, uint8_t*, size_t);
    GAME_ERROR(__cdecl* DeserializeAchievements)
    (const struct AddonInstance_Game*, const uint8_t*, size_t);
    void(__cdecl* FreeString)(const AddonInstance_Game*, char*);
  } KodiToAddonFuncTable_Game;
 
  typedef struct AddonInstance_Game
  {
    struct AddonProps_Game* props;
    struct AddonToKodiFuncTable_Game* toKodi;
    struct KodiToAddonFuncTable_Game* toAddon;
  } AddonInstance_Game;
 
#ifdef __cplusplus
}
#endif /* __cplusplus */
 
#endif /* !C_API_ADDONINSTANCE_GAME_H */