scripthook.h

Go to the documentation of this file.

#ifndef GRW_SCRIPTHOOK_H
#define GRW_SCRIPTHOOK_H
 
#include <stdint.h>
 
#ifdef __cplusplus
extern "C" {
#endif

 
#define SH_API_VERSION 1
 
#ifdef SH_BUILD
#define SH_API __declspec(dllexport)
#else
#define SH_API
#endif

typedef struct { float x, y, z; } ShVec3;


 
enum ShGameState {
    SH_STATE_UNKNOWN = 0,
    SH_STATE_MENU,
    SH_STATE_LOADING,
    SH_STATE_LOBBY,
    SH_STATE_INGAME,
    SH_STATE_RELOADING,

    SH_STATE_PAUSED,
    SH_STATE_GAMEOVER,

    SH_STATE_DRONE,
    SH_STATE_BINOCULAR,
    SH_STATE_CINEMATIC
};

enum ShUiState {
    SH_UI_DRONE      = 0x0001,  
    SH_UI_BINOCULAR  = 0x0002,
    SH_UI_VEHICLE    = 0x0004,  
    SH_UI_PAUSE      = 0x0008,  
    SH_UI_LOADOUT    = 0x0010,
    SH_UI_MAP        = 0x0020,
    SH_UI_SKILLS     = 0x0040,
    SH_UI_COMWHEEL   = 0x0080,
    SH_UI_GAMEOVER   = 0x0100,
    SH_UI_LOADING    = 0x0200,
    SH_UI_CINEMATIC  = 0x0400,
    SH_UI_POPUP      = 0x0800   
};
SH_API uint32_t ShGetUiState(void);
SH_API int      ShInDrone(void);
SH_API int      ShInLoadout(void);
SH_API int      ShInMap(void);
SH_API int      ShInBinocular(void);


enum ShError {
    SH_OK = 0,
    SH_ERR_BAD_ARG,
    SH_ERR_NO_GLOBAL,
    SH_ERR_NO_POSITION,
    SH_ERR_NO_CANDIDATE,
    SH_ERR_NO_ROOT,
    SH_ERR_UNWRITABLE,
    SH_ERR_NOT_ENTITY,
    SH_ERR_HOOK_FAILED,
    SH_ERR_NO_PHYSICS,
    SH_ERR_NO_GROUND,
    SH_ERR_NOT_IN_GAME,
    SH_ERR_NOT_STREAMED,
    SH_ERR_CONTROLLER,
    SH_ERR_UI_NOT_READY,   
    SH_ERR_UI_PROP,        
    SH_ERR_UI_ASSET        
};


#define SH_STREAM_RADIUS 1500.0f


typedef struct {
    uint64_t entity;
    uint64_t node;
    uint64_t root;
} ShPlayer;
 
typedef int (*ShLastError_t)(void);
typedef const char *(*ShErrorString_t)(int err);
typedef int (*ShGetVersion_t)(void);
typedef int (*ShGetPlayer_t)(ShPlayer *out);
typedef int (*ShTeleportPlayer_t)(const ShVec3 *pos,
                                  const ShVec3 *orient);
typedef int (*ShWalkToRoot_t)(uint64_t entity, uint64_t *outRoot);
typedef int (*ShGetPlayerPosition_t)(ShVec3 *out);
typedef void (*ShInvalidate_t)(void);


SH_API int  ShLastError(void);
SH_API const char *ShErrorString(int err);
SH_API int  ShGetVersion(void);


SH_API int  ShGetPlayer(ShPlayer *out);
SH_API int  ShGetPlayerPosition(ShVec3 *out);
SH_API int  ShGetCameraEyePosition(ShVec3 *out);
SH_API int  ShTeleportPlayer(const ShVec3 *pos,
                             const ShVec3 *orient);

SH_API int  ShTeleportPlayerHops(const ShVec3 *pos,
                                 const ShVec3 *orient,
                                 float hopMetres, int delayMs);

SH_API int  ShIsInVehicle(void);


SH_API int  ShPlaceEntity(uint64_t entity, const ShVec3 *pos,
                          const ShVec3 *orient);

SH_API int  ShPlaceEntityRot(uint64_t entity, const ShVec3 *pos,
                             float yaw, float pitch, float roll);

SH_API int  ShGetEntityTransform(uint64_t entity, ShVec3 *pos,
                                 float *yaw, float *pitch,
                                 float *roll);

SH_API int  ShQueueTransform(uint64_t entity, const ShVec3 *pos,
                             float yaw, float pitch, float roll);
enum ShEntityKind {
    SH_KIND_ANY = 0,
    SH_KIND_PLAYER,
    SH_KIND_NPC,
    SH_KIND_VEHICLE,
    SH_KIND_DRONE,
    SH_KIND_TEAMMATE,
    SH_KIND_TURRET,
    SH_KIND_MINE,
    SH_KIND_DOOR,
    SH_KIND_LOOTCHEST,
    SH_KIND_OTHER
};

#define SH_FIND_UNNAMED  0x1
 
typedef struct {
    uint64_t entity;
    ShVec3   pos;
    float    distance;
    int      kind;
    uint32_t maxHealth;
    char     name[32];
} ShEntity;

SH_API int  ShFindEntities(int kind, float radius, uint32_t flags,
                           ShEntity *out, int max);

SH_API int  ShGetEntityKind(uint64_t entity);
SH_API const char *ShKindName(int kind);

typedef struct {
    uint64_t component;
    uint64_t dataBlock;   
    uint32_t classHash;
    char     name[32];    
} ShComponent;

SH_API int ShGetComponents(uint64_t entity, ShComponent *out,
                           int max);

SH_API uint64_t ShFindComponent(uint64_t entity,
                                uint32_t classHash);


SH_API int  ShQueueCall(uint64_t fn, uint64_t a0, uint64_t a1,
                        uint64_t a2, uint64_t a3);

SH_API int  ShQueueCallF(uint64_t fn, uint64_t a0, uint64_t a1,
                         float f2, float f3, float f4);
SH_API int  ShQueueResult(uint64_t *outRet);

 
typedef struct {
    uint32_t    id;
    const char *name;
} ShVehicle;

SH_API int ShVehicleCount(void);
SH_API const ShVehicle *ShVehicleAt(int index);
SH_API const char *ShVehicleName(uint32_t vehicleId);

SH_API uint64_t ShSpawnVehicle(uint32_t vehicleId,
                               const ShVec3 *pos);
SH_API void ShSpawnInvalidate(void);

SH_API int      ShReadBytes(uint64_t addr, void *out, uint32_t len);
SH_API uint64_t ShReadU64(uint64_t addr, int *ok);
SH_API float    ShReadF32(uint64_t addr, int *ok);

typedef void (*ShFrameFn_t)(void *user);
SH_API int  ShRegisterFrameCallback(ShFrameFn_t fn, void *user);
SH_API void ShUnregisterFrameCallback(ShFrameFn_t fn);


SH_API int   ShTriggerLightning(void);
SH_API float ShGetWetness(void);
SH_API int   ShSetLightningFrequency(int enable, float value);

SH_API int   ShSetGodMode(int on);
SH_API int   ShSetGhostMode(int on);
SH_API int   ShGetGodMode(void);

SH_API int   ShExplosionShield(const ShVec3 *at, float radius);

SH_API int   ShSetEntityPhysics(uint64_t entity, int on);
SH_API int   ShAttachEntity(uint64_t child, uint64_t parent,
                            const ShVec3 *offset);
SH_API int   ShDetachEntity(uint64_t child);

 
typedef struct {
    uint64_t id;     
    int      kind;   
} ShNpcArchetype;

SH_API int ShNpcCount(void);
SH_API const ShNpcArchetype *ShNpcAt(int index);

SH_API uint64_t ShSpawnNpc(uint64_t archetypeId, const ShVec3 *pos);

SH_API int ShDespawn(uint64_t entity);


SH_API int  ShWalkToRoot(uint64_t entity, uint64_t *outRoot);
SH_API void ShInvalidate(void);


typedef struct {
    ShVec3   origin;
    ShVec3   dir;
    ShVec3   hitPos;      
    uint32_t hits;        
    uint64_t descriptor;
    uint64_t collector;
    uint8_t  raw[32];     

    uint64_t projectile;  
    uint32_t projHits;    
    uint64_t hitObject;   
    float    hitDist;     
} ShRay;
 
enum ShRayMode {
    SH_RAY_OFF = 0,
    SH_RAY_ALL,        
    SH_RAY_DIRECTED    
};

SH_API void ShRayFilter(const ShVec3 *from, float radius,
                        float minLength);
SH_API void ShRayFilterPlayer(float radius, float minLength);

SH_API void ShRayLog(int mode);
SH_API uint32_t ShRayCount(void);
SH_API int ShGetRays(ShRay *out, int max);

typedef struct {
    float  minLength;    
    float  maxLength;    
    int    hitsOnly;     
    ShVec3 from;         
    float  fromRadius;   
    ShVec3 through;      
    float  throughRadius;
} ShRayQuery;

SH_API int ShQueryRays(const ShRayQuery *q, ShRay *out, int max);


typedef struct {
    uint64_t entity;      
    uint64_t root;        
    int      kind;        
    uint32_t id;          
    ShVec3   pos;         
    ShVec3   normal;      
    float    distance;    
    uint64_t shooter;     
    int      byPlayer;    
    uint64_t projectile;
    int      index;       
} ShHit;

typedef void (*ShHitFn)(const ShHit *hit, void *user);

SH_API int  ShHitHookInstall(void);
SH_API int  ShHitHookReady(void);

#define SH_EVT_MINE_ONLY     0x1
#define SH_EVT_NO_SELF       0x2

SH_API int  ShOnHit(ShHitFn fn, void *user, int flags);
SH_API int  ShOffHit(ShHitFn fn);

SH_API uint32_t ShHitCount(void);
SH_API int  ShGetHits(ShHit *out, int max);

typedef struct {
    uint64_t shooter;     
    int      kind;        
    int      byPlayer;    
    ShVec3   origin;      
    ShVec3   dir;         
    float    yaw;         
    float    pitch;       
    float    range;       
    uint64_t projectile;
} ShShot;
 
typedef void (*ShFireFn)(const ShShot *shot, void *user);

SH_API int  ShOnFire(ShFireFn fn, void *user, int flags);
SH_API int  ShOffFire(ShFireFn fn);
SH_API uint32_t ShShotCount(void);
SH_API int  ShGetShots(ShShot *out, int max);


SH_API int  ShSetVisible(uint64_t entity, uint64_t node,
                         int visible, int persist);
SH_API int  ShEntityNodeCount(uint64_t entity);

SH_API int  ShGetEntityNodes(uint64_t entity, uint64_t *out,
                             int max);
SH_API int  ShGetHeadNodes(uint64_t entity, uint64_t *out,
                           int max);

 
typedef void (*ShMenuFn)(uint32_t menu, uint32_t item, int value,
                         void *user);

SH_API uint32_t ShMenuCreate(const char *title);
SH_API uint32_t ShMenuSub(uint32_t parent, const char *label);
SH_API int  ShMenuAction(uint32_t menu, const char *label,
                         ShMenuFn fn, void *user);
SH_API int  ShMenuToggle(uint32_t menu, const char *label,
                         int initial, ShMenuFn fn, void *user);
SH_API int  ShMenuNumber(uint32_t menu, const char *label,
                         float initial, float lo, float hi,
                         float step, ShMenuFn fn, void *user);
SH_API int  ShMenuList(uint32_t menu, const char *label,
                       const char **opts, int n, int initial,
                       ShMenuFn fn, void *user);
SH_API int  ShMenuClear(uint32_t menu);
SH_API int  ShMenuDestroy(uint32_t menu);
SH_API int  ShMenuStatus(uint32_t menu, const char *text);
SH_API void ShMenuSetKey(int vk);
SH_API int  ShMenuIsOpen(void);
SH_API void ShMenuOpen(int open);

 
enum {
    SH_HUD_TOPLEFT = 0,
    SH_HUD_TOPRIGHT,
    SH_HUD_BOTTOMLEFT,
    SH_HUD_BOTTOMRIGHT
};

SH_API uint32_t ShHudCreate(const char *name, int anchor,
                            int priority);
SH_API int  ShHudSet(uint32_t hud, const char *text);
SH_API int  ShHudColour(uint32_t hud, uint32_t rgb);
SH_API int  ShHudShow(uint32_t hud, int visible);
SH_API void ShHudDestroy(uint32_t hud);


typedef struct {
    ShVec3 pos;
    ShVec3 right;
    ShVec3 forward;
    ShVec3 up;
    float  fov;
    int    mode;
    uint64_t camera;
} ShCamera;

SH_API int  ShCameraHookInstall(void);
SH_API int  ShCameraReady(void);
SH_API uint64_t ShCameraCalls(void);
SH_API uint64_t ShCameraWrites(void);


SH_API int  ShInPauseMenu(void);


SH_API int  ShSetCameraBlur(int on);
SH_API int  ShCameraBlurOff(void);




SH_API int  ShGetVelocity(uint64_t entity, ShVec3 *out);
SH_API int  ShSetVelocity(uint64_t entity, const ShVec3 *v);
SH_API int  ShAddVelocity(uint64_t entity, const ShVec3 *v);

SH_API int  ShGetAngularVelocity(uint64_t entity, ShVec3 *out);
SH_API int  ShSetAngularVelocity(uint64_t entity, const ShVec3 *v);
SH_API int  ShAddAngularVelocity(uint64_t entity, const ShVec3 *v);

SH_API int  ShShove(uint64_t entity, const ShVec3 *dir,
                    float strength, const ShVec3 *atWorldPos);

SH_API int  ShCanMove(uint64_t entity);


 
SH_API uint64_t ShHavokWorld(void);
SH_API uint32_t ShGetBodyId(uint64_t entity);
SH_API int  ShHavokScan(int *bodies, int *owners, int *mapped);


 
#define SH_INPUT_KEYS  0x01  
#define SH_INPUT_MOVE  0x02  
#define SH_INPUT_FIRE  0x04  
#define SH_INPUT_AIM   0x08  
#define SH_INPUT_LOOK  0x10  

SH_API int  ShBlockInput(uint32_t mask);
SH_API uint32_t ShBlockedInput(void);


SH_API int  ShSetCrashIntercept(int on);
SH_API int  ShCrashInterceptOn(void);


SH_API int  ShCrashCount(void);

SH_API int  ShCrashHealed(void);

SH_API int  ShCrashReport(char *buf, int len);

SH_API int  ShSetCrashFreeze(int on);
SH_API int  ShCrashFreezeOn(void);



SH_API int  ShGetCamera(ShCamera *out);

SH_API int  ShSetCamera(const ShVec3 *pos);
SH_API int  ShCameraOrbit(float back, float up);

SH_API int  ShCameraFree(const ShVec3 *pos, float yaw, float pitch);
SH_API int  ShCameraAngles(float *yaw, float *pitch);
SH_API void ShCameraRelease(void);

SH_API void ShCameraReleaseFields(uint32_t fields);
SH_API uint32_t ShCameraOwned(void);

SH_API int  ShCameraFirstPerson(float forward, float up);

SH_API int  ShGetHeadPosition(ShVec3 *out);
SH_API int  ShHeadBone(void);

#define SH_CAM_POS    0x01
#define SH_CAM_ROT    0x02
#define SH_CAM_FOV    0x04
#define SH_CAM_SKEW   0x08
#define SH_CAM_MODE   0x10
 
typedef struct {
    uint32_t apply;
    ShVec3   pos;
    float    yaw, pitch, roll;
    float    fov;
    float    skewX, skewY;
    int      mode;
} ShCameraOverride;

SH_API int  ShCameraApply(const ShCameraOverride *o);

SH_API int  ShCameraMatrix(int index, float *out16);


SH_API int  ShGetGameState(void);
SH_API int  ShIsInGame(void);
SH_API int  ShGetGameStateName(char *buf, int len);
 
typedef int (*ShGetGameState_t)(void);
typedef int (*ShIsInGame_t)(void);


SH_API int  ShPhysicsReady(void);
SH_API int  ShGroundHeight(float x, float y, float *outZ);
SH_API int  ShGroundHeightFrom(float x, float y, float nearZ,
                               float *outZ);
SH_API int  ShTeleportPlayerToGround(float x, float y,
                                     float clearance);


SH_API int  ShGetHealthPlayer(uint32_t *cur, uint32_t *max);
SH_API int  ShSetHealthPlayer(uint32_t value);
SH_API int  ShSetGodModePlayer(int on);

SH_API int  ShDamagePlayer(uint32_t amount);
SH_API int  ShKillPlayer(void);
SH_API int  ShSetCannotDiePlayer(int on);
SH_API void ShInvalidateHealth(void);

SH_API int  ShGetHealthEntity(uint64_t entity, uint32_t *cur,
                              uint32_t *max);
SH_API int  ShSetHealthEntity(uint64_t entity, uint32_t value);
SH_API int  ShSetGodModeEntity(uint64_t entity, int on);

SH_API int  ShStatRead(uint64_t stat, uint32_t *out);
SH_API int  ShStatWrite(uint64_t stat, uint32_t value);

#define SH_RES_FOOD      0
#define SH_RES_GASOLINE  1
#define SH_RES_MEDICINE  2
#define SH_RES_COMMS     3
SH_API int  ShGetResource(int which, uint32_t *out);
SH_API int  ShSetResource(int which, uint32_t value);
SH_API int  ShSetAllResources(uint32_t value);

SH_API int  ShGetSkillPoints(uint32_t *out);
SH_API int  ShSetSkillPoints(uint32_t value);

SH_API int  ShSetVisibility(float factor);
SH_API int  ShGetVisibility(float *out);

SH_API int  ShGetAmmo(int slot, uint32_t *out);
SH_API int  ShSetAmmo(int slot, uint32_t value);


enum ShWeather {
    SH_WEATHER_SUNNY = 0,
    SH_WEATHER_CLOUDS_LIGHT,
    SH_WEATHER_CLOUDS_HEAVY,
    SH_WEATHER_FOG,
    SH_WEATHER_RAIN_LIGHT,
    SH_WEATHER_RAIN_HEAVY
};
SH_API int  ShSetWeather(int type);
SH_API int  ShSetWeatherBlend(int type, float seconds);
SH_API int  ShReleaseWeather(void);
SH_API int  ShGetWeather(int *out);

SH_API int  ShSetTime(float hours);
SH_API int  ShGetTime(float *out);

SH_API int  ShSetTimeSpeed(float multiplier);
SH_API int  ShGetTimeSpeed(float *out);


typedef struct {
    uint32_t nameHash;
    int      index;
    uint64_t fn;
} ShMethod;

SH_API int  ShReflectMethod(uint64_t obj, uint32_t nameHash,
                            uint64_t *outFn);
SH_API int  ShReflectMethods(uint64_t obj, ShMethod *out, int max);
SH_API uint32_t ShReflectClassHash(uint64_t obj);

SH_API int  ShReflectCall(uint64_t obj, uint32_t nameHash,
                          uint64_t a1, uint64_t a2, uint64_t a3,
                          uint64_t *outRet);

#define SH_HASH_ENTER     0x78B1EF6Au
#define SH_HASH_EXIT      0x343B2B30u
#define SH_HASH_INIT      0x66464B4Au
#define SH_HASH_SHUTDOWN  0x6CD4BC94u
#define SH_HASH_GAMEOVER  0xCA671D0Au  

SH_API int  ShSceneEnter(uint64_t obj);
SH_API int  ShSceneExit(uint64_t obj);

SH_API uint64_t ShGameFlow(void);

#define SH_FLOW_GAMEOVER_SCENE  9
#define SH_FLOW_ALT_SCENE       11
SH_API uint64_t ShGameFlowObject(int slot);

SH_API uint64_t ShHybridMenu(void);

SH_API int  ShTriggerGameOver(int reason);


SH_API int      ShUiReady(void);
SH_API void     ShUiEnable(int on);
SH_API int      ShUiSetDefaultFont(const char *guid);
SH_API int      ShUiSetDefaultImage(const char *guid);
SH_API int      ShUiGen(void);
SH_API uint64_t ShSceneHandle(void);

SH_API uint32_t ShUiPanel(float x, float y, float w, float h,
                          uint32_t rgb, float alpha);
SH_API uint32_t ShUiLabel(uint32_t panel, float x, float y, float w,
                          float h, const char *text, uint32_t rgb);
SH_API uint32_t ShUiImage(uint32_t panel, float x, float y, float w,
                          float h, uint32_t rgb, float alpha);
 
SH_API int  ShUiSetText(uint32_t id, const char *text);
SH_API int  ShUiSetPos(uint32_t id, float x, float y);
SH_API int  ShUiSetSize(uint32_t id, float w, float h);
SH_API int  ShUiSetColour(uint32_t id, uint32_t rgb);
SH_API int  ShUiSetAlpha(uint32_t id, float alpha);
SH_API int  ShUiShow(uint32_t id, int visible);
SH_API int  ShUiDestroy(uint32_t id);

#define SH_PT_FLOAT   1
#define SH_PT_BOOL    2
#define SH_PT_UINT    3
#define SH_PT_VEC2    4
#define SH_PT_VEC3    5
#define SH_PT_STRING  6
 
#define SH_P_POSITION  0x01   
#define SH_P_ROTATION3 0x02   
#define SH_P_ROTATION  0x03   
#define SH_P_COLOUR    0x05   
#define SH_P_ALPHA     0x06   
#define SH_P_VISIBLE   0x07   
#define SH_P_SCALE     0x35   
#define SH_P_TEXT      0x08   
#define SH_P_AUTOSIZE  0x09   
#define SH_P_STYLE     0x0A   
#define SH_P_FONTSIZE  0x0C   
#define SH_P_LINEGAP   0x0E   
#define SH_P_SIZE      0x0F   
#define SH_P_IMAGE     0x2A   
#define SH_P_UV0       0x38   
#define SH_P_UV1       0x39   
#define SH_P_CONTSIZE  0x3E   

#define SH_W_CONTAINER 1
#define SH_W_LABEL     2
#define SH_W_IMAGE     3
#define SH_W_PANEL     4

SH_API uint32_t ShUiCreate(uint32_t parent, int cls, float x, float y,
                           float w, float h);

SH_API int  ShUiPropType(uint32_t id, uint32_t prop);
SH_API int  ShUiSetF(uint32_t id, uint32_t prop, float v);
SH_API int  ShUiSetU(uint32_t id, uint32_t prop, uint32_t v);
SH_API int  ShUiSetV(uint32_t id, uint32_t prop, const float *v, int n);
SH_API int  ShUiSetS(uint32_t id, uint32_t prop, const char *utf8);
SH_API int  ShUiGetF(uint32_t id, uint32_t prop, float *out);
SH_API int  ShUiGetU(uint32_t id, uint32_t prop, uint32_t *out);
SH_API int  ShUiGetV(uint32_t id, uint32_t prop, float *out, int n);
SH_API int  ShUiGetS(uint32_t id, uint32_t prop, char *out, int n);
SH_API int  ShUiSetAutoSize(uint32_t id, int autoW, int autoH);
SH_API int  ShUiMeasure(uint32_t id, float *w, float *h);

SH_API uint32_t ShUiTextureCreate(int w, int h, const uint8_t *rgba,
                                  int stride);
SH_API int  ShUiImageSet(uint32_t id, uint32_t texture);
SH_API int  ShUiPropCount(void);
SH_API int  ShUiPropAt(int i, char *cls, int n, uint32_t *prop,
                       int *type);

SH_API uint32_t ShUiSceneCreate(const char *name, int order);
SH_API int      ShUiSceneSetOrder(uint32_t scene, int order);
SH_API int      ShUiSceneShow(uint32_t scene, int visible);
SH_API int      ShUiSceneDestroy(uint32_t scene);
SH_API uint32_t ShUiCreateIn(uint32_t scene, uint32_t parent, int cls,
                             float x, float y, float w, float h);
SH_API int      ShUiSetReset(uint32_t scene,
                             void (*fn)(uint32_t scene, void *user),
                             void *user);
SH_API int      ShUiBegin(void);
SH_API int      ShUiCommit(void);
SH_API int      ShUiAbort(void);
SH_API int      ShUiCommitAsync(void (*done)(int ok, void *user),
                                void *user);

SH_API int      ShUiReparent(uint32_t id, uint32_t parent, int index);
SH_API int      ShUiChildCount(uint32_t id);
SH_API uint32_t ShUiChildAt(uint32_t id, int index);

#define SH_UI_EV_DOWN 1
#define SH_UI_EV_UP   2
#define SH_UI_EV_MOVE 3
typedef struct { int type; int key; int x; int y; } ShUiEvent;
typedef int (*ShUiInputFn)(uint32_t scene, const ShUiEvent *e,
                           void *user);
SH_API int      ShUiSetInput(uint32_t scene, ShUiInputFn fn, void *user);
SH_API int      ShUiFocus(uint32_t scene, int take);
SH_API uint32_t ShUiFocused(void);
SH_API int      ShBlockKey(int vk, int on);
SH_API int      ShCaptureKeys(int on);

#define SH_SCENE_DRONE      "HUD_Drone"
#define SH_SCENE_BINOCULAR  "HUD_Binocular"
#define SH_SCENE_VEHICLE    "HUD_Vehicle"
#define SH_SCENE_PAUSE      "Menu_TabbedPage"
#define SH_SCENE_LOADOUT    "MENU_LoadoutV2"
#define SH_SCENE_MAP        "MENU_Map_Cursor"
#define SH_SCENE_SKILLS     "MENU_Skills"
#define SH_SCENE_COMWHEEL   "HUD_ComWheel"
#define SH_SCENE_GAMEOVER   "MENU_GameOver"
#define SH_SCENE_LOADING    "MENU_LoadingScreen"
#define SH_SCENE_CINEMATIC  "HUD_Cinematic"
SH_API int      ShGameSceneActive(const char *name);
SH_API int      ShGameScenes(char *buf, int n);



SH_API int      ShGameSceneCount(void);
SH_API uint64_t ShGameSceneAt(int i);
SH_API int      ShGameSceneName(uint64_t scene, char *buf, int n);

SH_API uint64_t ShSceneRoot(uint64_t scene);

SH_API int      ShWidgetChildCount(uint64_t widget);
SH_API uint64_t ShWidgetChildAt(uint64_t widget, int i);

SH_API int      ShWidgetClass(uint64_t widget, char *out, int n);

SH_API int      ShWidgetPropType(uint64_t widget, uint32_t prop);
SH_API int      ShWidgetGetF(uint64_t widget, uint32_t prop, float *out);
SH_API int      ShWidgetGetU(uint64_t widget, uint32_t prop,
                             uint32_t *out);
SH_API int      ShWidgetGetV(uint64_t widget, uint32_t prop, float *out,
                             int n);
SH_API int      ShWidgetGetS(uint64_t widget, uint32_t prop, char *out,
                             int n);

SH_API uint64_t ShUiHandle(uint32_t id);

 
typedef int (*ShGetHealthPlayer_t)(uint32_t *, uint32_t *);
typedef int (*ShSetHealthPlayer_t)(uint32_t);
typedef int (*ShSetGodModePlayer_t)(int);
typedef int (*ShPhysicsReady_t)(void);
typedef int (*ShGroundHeight_t)(float, float, float *);
typedef int (*ShTeleportPlayerToGround_t)(float, float, float);

 
#ifdef __cplusplus
}
#endif
 
#endif