class

RadialWheelController

46 properties
70 functions

Extends game.ui.HUDGameController game.ui.WidgetGameController world.ui.IWidgetGameController ink.IWidgetController IScriptable ISerializable

Properties

Property	Type	Offset
`radialWeapons`	`WeaponRadialSlot?[]`	`0x58`	scripted
`inputHintController`	`RadialSlot?`	`0x68`	scripted
`activeSlotTooltip`	`RadialSlot?`	`0x78`	scripted
`activeWeaponSlotTooltip`	`RadialSlot?`	`0x88`	scripted
`statusEffects`	`RadialSlot?`	`0x98`	scripted
`pointerRef`	`ink.WidgetReference`	`0xA8`	scripted
`patternPanelWidgetRef`	`ink.WidgetReference`	`0x150`	scripted
`prevTabButtonRef`	`ink.WidgetReference`	`0x168`	scripted
`nextTabButtonRef`	`ink.WidgetReference`	`0x180`	scripted
`prevTabButton`	`WeakHandle<ink.ButtonController>`	`0x228`	scripted
`nextTabButton`	`WeakHandle<ink.ButtonController>`	`0x238`	scripted
`activeTab`	`int`	`0x248`	scripted
`patternWheelInkWidget`	`WeakHandle<ink.Widget>`	`0x250`	scripted
`activeSlot`	`WeaponRadialSlot?`	`0x260`	scripted
`pointer`	`WeakHandle<PointerController>`	`0x270`	scripted
`activeIndex`	`int`	`0x280`	scripted
`initialized`	`bool`	`0x284`	scripted
`isActive`	`bool`	`0x285`	scripted
`pendingRadialSlotAsyncSpawnCount`	`int`	`0x288`	scripted
`consSlotCachedData`	`game.InventoryItemData`	`0x290`	scripted
`gadgetSlotCachedData`	`game.InventoryItemData`	`0x4F0`	scripted
`cyclingActionRegistered`	`CName`	`0x750`	scripted
`registeredInputHints`	`game.ui.InputHintData[]`	`0x758`	scripted
`applyInputHint`	`game.ui.InputHintData`	`0x768`	scripted
`cycleInputHintDataLeft`	`game.ui.InputHintData`	`0x7C0`	scripted
`cycleInputHintDataRight`	`game.ui.InputHintData`	`0x818`	scripted
`UI_MoveUpInputHint`	`game.ui.InputHintData`	`0x870`	scripted
`UI_MoveDownInputHint`	`game.ui.InputHintData`	`0x8C8`	scripted
`inspectWeaponsInputHint`	`game.ui.InputHintData`	`0x920`	scripted
`radialMode`	`ERadialMode`	`0x978`	scripted
`inventoryManager`	`InventoryDataManagerV2?`	`0x980`	scripted
`equipmentSystem`	`WeakHandle<EquipmentSystem>`	`0x990`	scripted
`transactionSystem`	`WeakHandle<game.TransactionSystem>`	`0x9A0`	scripted
`playerPuppet`	`WeakHandle<PlayerPuppet>`	`0x9B0`	scripted
`quickSlotBlackboard`	`WeakHandle<game.IBlackboard>`	`0x9C0`	scripted
`QuickSlotBlackboardDef`	`UI_QuickSlotsDataDef?`	`0x9D0`	scripted
`axisInputCallbackID`	`red.CallbackObject?`	`0x9E0`	scripted
`UISystemBB`	`WeakHandle<game.IBlackboard>`	`0x9F0`	scripted
`UISystemDef`	`UI_SystemDef?`	`0xA00`	scripted
`isInMenuCallbackID`	`red.CallbackObject?`	`0xA10`	scripted
`equipmentUIBlackboard`	`WeakHandle<game.IBlackboard>`	`0xA20`	scripted
`EquipmentBlackboardDef`	`UI_EquipmentDef?`	`0xA30`	scripted
`equipmentUICallbackID`	`red.CallbackObject?`	`0xA40`	scripted
`cineCamUIBlackboard`	`WeakHandle<game.IBlackboard>`	`0xA50`	scripted
`AutodriveBlackboardDef`	`UI_AutodriveDataDef?`	`0xA60`	scripted
`cineCamUICallbackID`	`red.CallbackObject?`	`0xA70`	scripted

Functions

void HandleEquipmentChangeByTask(SPaperdollEquipData eqData) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "RadialWheelController",
    "HandleEquipmentChangeByTask;script_ref<SPaperdollEquipData>",
    (RadialWheelController_HandleEquipmentChangeByTask x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RadialWheelController_HandleEquipmentChangeByTask(
    RadialWheelController self,
    SPaperdollEquipData eqData
);

void HandleEquipmentChangeTask(game.ScriptTaskData data) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "RadialWheelController",
    "HandleEquipmentChangeTask;ScriptTaskData",
    (RadialWheelController_HandleEquipmentChangeTask x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RadialWheelController_HandleEquipmentChangeTask(
    RadialWheelController self,
    game.ScriptTaskData? data
);

bool OnInitialize() RTTI

Generated hook

re.Hooks.Place(
    "RadialWheelController",
    "OnInitialize",
    (RadialWheelController_OnInitialize x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RadialWheelController_OnInitialize(
    RadialWheelController self
);

bool OnLateInit(LateInit evt) RTTI

Generated hook

re.Hooks.Place(
    "RadialWheelController",
    "OnLateInit",
    (RadialWheelController_OnLateInit x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RadialWheelController_OnLateInit(
    RadialWheelController self,
    LateInit? evt
);

bool OnUninitialize() RTTI

Generated hook

re.Hooks.Place(
    "RadialWheelController",
    "OnUninitialize",
    (RadialWheelController_OnUninitialize x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RadialWheelController_OnUninitialize(
    RadialWheelController self
);

void SetActiveContetnt(int tabId) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "RadialWheelController",
    "SetActiveContetnt;Int32",
    (RadialWheelController_SetActiveContetnt x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RadialWheelController_SetActiveContetnt(
    RadialWheelController self,
    int tabId
);

bool OnPressTab0(ink.PointerEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "RadialWheelController",
    "OnPressTab0",
    (RadialWheelController_OnPressTab0 x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RadialWheelController_OnPressTab0(
    RadialWheelController self,
    ink.PointerEvent? evt
);

bool OnPressTab1(ink.PointerEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "RadialWheelController",
    "OnPressTab1",
    (RadialWheelController_OnPressTab1 x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RadialWheelController_OnPressTab1(
    RadialWheelController self,
    ink.PointerEvent? evt
);

void NextTab() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "RadialWheelController",
    "NextTab;",
    (RadialWheelController_NextTab x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RadialWheelController_NextTab(
    RadialWheelController self
);

void PreviousTab() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "RadialWheelController",
    "PreviousTab;",
    (RadialWheelController_PreviousTab x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RadialWheelController_PreviousTab(
    RadialWheelController self
);

bool IsPatternWheelEnabled() RTTI

Generated hook

re.Hooks.Place(
    "RadialWheelController",
    "IsPatternWheelEnabled;",
    (RadialWheelController_IsPatternWheelEnabled x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RadialWheelController_IsPatternWheelEnabled(
    RadialWheelController self
);

void RegisterBlackboards(bool shouldRegister) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "RadialWheelController",
    "RegisterBlackboards;Bool",
    (RadialWheelController_RegisterBlackboards x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RadialWheelController_RegisterBlackboards(
    RadialWheelController self,
    bool shouldRegister
);

void Shutdown() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "RadialWheelController",
    "Shutdown;",
    (RadialWheelController_Shutdown x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RadialWheelController_Shutdown(
    RadialWheelController self
);

void SendPSMRadialCloseRequest() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "RadialWheelController",
    "SendPSMRadialCloseRequest;",
    (RadialWheelController_SendPSMRadialCloseRequest x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RadialWheelController_SendPSMRadialCloseRequest(
    RadialWheelController self
);

void UpdateRequired() overrideRTTI

Generated hook

re.Hooks.PlaceVoid(
    "RadialWheelController",
    "UpdateRequired;",
    (RadialWheelController_UpdateRequired x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RadialWheelController_UpdateRequired(
    RadialWheelController self
);

int GetValidNeighbouringIndex(game.InventoryItemData[] arr, int fromIndex, bool searchNext) RTTI

Generated hook

re.Hooks.Place(
    "RadialWheelController",
    "GetValidNeighbouringIndex;script_ref<array<InventoryItemData>>Int32Bool",
    (RadialWheelController_GetValidNeighbouringIndex x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RadialWheelController_GetValidNeighbouringIndex(
    RadialWheelController self,
    game.InventoryItemData[] arr,
    int fromIndex,
    bool searchNext
);

void CacheData() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "RadialWheelController",
    "CacheData;",
    (RadialWheelController_CacheData x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RadialWheelController_CacheData(
    RadialWheelController self
);

void CacheAllInputHintData() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "RadialWheelController",
    "CacheAllInputHintData;",
    (RadialWheelController_CacheAllInputHintData x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RadialWheelController_CacheAllInputHintData(
    RadialWheelController self
);

void CacheInputHintData(game.ui.InputHintData inputHintData, CName action, CName source, int queuePriority, int sortingPriority, string localizedLabel)

RTTI

Generated hook

re.Hooks.PlaceVoid(
    "RadialWheelController",
    "CacheInputHintData;script_ref<InputHintData>CNameCNameInt32Int32String",
    (RadialWheelController_CacheInputHintData x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RadialWheelController_CacheInputHintData(
    RadialWheelController self,
    game.ui.InputHintData inputHintData,
    CName action,
    CName source,
    int queuePriority,
    int sortingPriority,
    string localizedLabel
);

Vector2 ConvertMarginToVector(ink.Margin margin) RTTI

Generated hook

re.Hooks.Place(
    "RadialWheelController",
    "ConvertMarginToVector;inkMargin",
    (RadialWheelController_ConvertMarginToVector x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Vector2>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RadialWheelController_ConvertMarginToVector(
    RadialWheelController self,
    ink.Margin margin
);

WeaponRadialSlot? DetermineActiveSlot(float angle) RTTI

Generated hook

re.Hooks.Place(
    "RadialWheelController",
    "DetermineActiveSlot;Float",
    (RadialWheelController_DetermineActiveSlot x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.WeaponRadialSlot>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RadialWheelController_DetermineActiveSlot(
    RadialWheelController self,
    float angle
);

bool SetActiveSlot(WeaponRadialSlot newActiveSlot) RTTI

Generated hook

re.Hooks.Place(
    "RadialWheelController",
    "SetActiveSlot;WeaponRadialSlot",
    (RadialWheelController_SetActiveSlot x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RadialWheelController_SetActiveSlot(
    RadialWheelController self,
    WeaponRadialSlot? newActiveSlot
);

bool IsGadgetOrConsumableSlot(WeaponRadialSlot slot) RTTI

Generated hook

re.Hooks.Place(
    "RadialWheelController",
    "IsGadgetOrConsumableSlot;WeaponRadialSlot",
    (RadialWheelController_IsGadgetOrConsumableSlot x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RadialWheelController_IsGadgetOrConsumableSlot(
    RadialWheelController self,
    WeaponRadialSlot? slot
);

float ConvertVectorToAngle(Vector4 input) RTTI

Generated hook

re.Hooks.Place(
    "RadialWheelController",
    "ConvertVectorToAngle;Vector4",
    (RadialWheelController_ConvertVectorToAngle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RadialWheelController_ConvertVectorToAngle(
    RadialWheelController self,
    Vector4 input
);

void SpawnRadialWeapons() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "RadialWheelController",
    "SpawnRadialWeapons;",
    (RadialWheelController_SpawnRadialWeapons x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RadialWheelController_SpawnRadialWeapons(
    RadialWheelController self
);

bool SpawnSlotWidget(RadialSlot slot) RTTI

Generated hook

re.Hooks.Place(
    "RadialWheelController",
    "SpawnSlotWidget;RadialSlot",
    (RadialWheelController_SpawnSlotWidget x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RadialWheelController_SpawnSlotWidget(
    RadialWheelController self,
    RadialSlot? slot
);

bool OnSlotWidgetSpawned(ink.Widget widget, IScriptable userData) RTTI

Generated hook

re.Hooks.Place(
    "RadialWheelController",
    "OnSlotWidgetSpawned",
    (RadialWheelController_OnSlotWidgetSpawned x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RadialWheelController_OnSlotWidgetSpawned(
    RadialWheelController self,
    ink.Widget? widget,
    IScriptable? userData
);

void SetupWidgetForSlot(ink.Widget widget, RadialSlot slot) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "RadialWheelController",
    "SetupWidgetForSlot;inkWidgetRadialSlot",
    (RadialWheelController_SetupWidgetForSlot x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RadialWheelController_SetupWidgetForSlot(
    RadialWheelController self,
    ink.Widget? widget,
    RadialSlot? slot
);

void RefreshSlots() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "RadialWheelController",
    "RefreshSlots;",
    (RadialWheelController_RefreshSlots x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RadialWheelController_RefreshSlots(
    RadialWheelController self
);

void RefreshWeapons() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "RadialWheelController",
    "RefreshWeapons;",
    (RadialWheelController_RefreshWeapons x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RadialWheelController_RefreshWeapons(
    RadialWheelController self
);

void RefreshHotkeys() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "RadialWheelController",
    "RefreshHotkeys;",
    (RadialWheelController_RefreshHotkeys x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RadialWheelController_RefreshHotkeys(
    RadialWheelController self
);

void RefreshHotkey(CyclableRadialSlot slot) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "RadialWheelController",
    "RefreshHotkey;CyclableRadialSlot",
    (RadialWheelController_RefreshHotkey x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RadialWheelController_RefreshHotkey(
    RadialWheelController self,
    CyclableRadialSlot? slot
);

void RefreshCyberware() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "RadialWheelController",
    "RefreshCyberware;",
    (RadialWheelController_RefreshCyberware x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RadialWheelController_RefreshCyberware(
    RadialWheelController self
);

bool BindItem(CyclableRadialSlot slot, EHotkeyRequestType requestType) RTTI

Generated hook

re.Hooks.Place(
    "RadialWheelController",
    "BindItem;CyclableRadialSlotEHotkeyRequestType",
    (RadialWheelController_BindItem x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RadialWheelController_BindItem(
    RadialWheelController self,
    CyclableRadialSlot? slot,
    EHotkeyRequestType requestType
);

bool DrawItem(RadialSlot slot) RTTI

Generated hook

re.Hooks.Place(
    "RadialWheelController",
    "DrawItem;RadialSlot",
    (RadialWheelController_DrawItem x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RadialWheelController_DrawItem(
    RadialWheelController self,
    RadialSlot? slot
);

void ApplySlot(RadialSlot slot) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "RadialWheelController",
    "ApplySlot;RadialSlot",
    (RadialWheelController_ApplySlot x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RadialWheelController_ApplySlot(
    RadialWheelController self,
    RadialSlot? slot
);

void DisarmPlayer() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "RadialWheelController",
    "DisarmPlayer;",
    (RadialWheelController_DisarmPlayer x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RadialWheelController_DisarmPlayer(
    RadialWheelController self
);

void CycleSlot(WeaponRadialSlot cyclableWeaponSlot, CName actionName) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "RadialWheelController",
    "CycleSlot;WeaponRadialSlotCName",
    (RadialWheelController_CycleSlot x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RadialWheelController_CycleSlot(
    RadialWheelController self,
    WeaponRadialSlot? cyclableWeaponSlot,
    CName actionName
);

void CycleWeapons(WeaponRadialSlot cyclableWeaponSlot, bool next) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "RadialWheelController",
    "CycleWeapons;WeaponRadialSlotBool",
    (RadialWheelController_CycleWeapons x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RadialWheelController_CycleWeapons(
    RadialWheelController self,
    WeaponRadialSlot? cyclableWeaponSlot,
    bool next
);

void CycleHotkeys(CyclableRadialSlot cyclableSlot, bool next) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "RadialWheelController",
    "CycleHotkeys;CyclableRadialSlotBool",
    (RadialWheelController_CycleHotkeys x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RadialWheelController_CycleHotkeys(
    RadialWheelController self,
    CyclableRadialSlot? cyclableSlot,
    bool next
);

void CycleCyberware(CyclableRadialSlot cyclableSlot) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "RadialWheelController",
    "CycleCyberware;CyclableRadialSlot",
    (RadialWheelController_CycleCyberware x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RadialWheelController_CycleCyberware(
    RadialWheelController self,
    CyclableRadialSlot? cyclableSlot
);

void UpdatePointer(Vector4 rawInputVector, float rawAngle) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "RadialWheelController",
    "UpdatePointer;Vector4Float",
    (RadialWheelController_UpdatePointer x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RadialWheelController_UpdatePointer(
    RadialWheelController self,
    Vector4 rawInputVector,
    float rawAngle
);

void UpdateStatusEffects() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "RadialWheelController",
    "UpdateStatusEffects;",
    (RadialWheelController_UpdateStatusEffects x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RadialWheelController_UpdateStatusEffects(
    RadialWheelController self
);

void UpdateActiveTooltip() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "RadialWheelController",
    "UpdateActiveTooltip;",
    (RadialWheelController_UpdateActiveTooltip x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RadialWheelController_UpdateActiveTooltip(
    RadialWheelController self
);

void RestoreCachedSlots() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "RadialWheelController",
    "RestoreCachedSlots;",
    (RadialWheelController_RestoreCachedSlots x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RadialWheelController_RestoreCachedSlots(
    RadialWheelController self
);

void ClearInputHints() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "RadialWheelController",
    "ClearInputHints;",
    (RadialWheelController_ClearInputHints x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RadialWheelController_ClearInputHints(
    RadialWheelController self
);

void UpdateInputHints() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "RadialWheelController",
    "UpdateInputHints;",
    (RadialWheelController_UpdateInputHints x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RadialWheelController_UpdateInputHints(
    RadialWheelController self
);

void AddInputHint(game.ui.InputHintData inputHint, bool add) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "RadialWheelController",
    "AddInputHint;script_ref<InputHintData>Bool",
    (RadialWheelController_AddInputHint x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RadialWheelController_AddInputHint(
    RadialWheelController self,
    game.ui.InputHintData inputHint,
    bool add
);

void SendInputHintEvent(game.ui.InputHintData inputHint, bool show) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "RadialWheelController",
    "SendInputHintEvent;script_ref<InputHintData>Bool",
    (RadialWheelController_SendInputHintEvent x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RadialWheelController_SendInputHintEvent(
    RadialWheelController self,
    game.ui.InputHintData inputHint,
    bool show
);

bool OnOpenWheelRequest(QuickSlotButtonHoldStartEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "RadialWheelController",
    "OnOpenWheelRequest",
    (RadialWheelController_OnOpenWheelRequest x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RadialWheelController_OnOpenWheelRequest(
    RadialWheelController self,
    QuickSlotButtonHoldStartEvent? evt
);

bool OnForceRadialWheelShutdown(ForceRadialWheelShutdown evt) RTTI

Generated hook

re.Hooks.Place(
    "RadialWheelController",
    "OnForceRadialWheelShutdown",
    (RadialWheelController_OnForceRadialWheelShutdown x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RadialWheelController_OnForceRadialWheelShutdown(
    RadialWheelController self,
    ForceRadialWheelShutdown? evt
);

bool OnForceRadialWheelRebuild(ForceRadialWheelRebuild evt) RTTI

Generated hook

re.Hooks.Place(
    "RadialWheelController",
    "OnForceRadialWheelRebuild",
    (RadialWheelController_OnForceRadialWheelRebuild x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RadialWheelController_OnForceRadialWheelRebuild(
    RadialWheelController self,
    ForceRadialWheelRebuild? evt
);

bool OnAction(game.input.ScriptListenerAction action, game.input.ScriptListenerActionConsumer consumer) RTTI

Generated hook

re.Hooks.Place(
    "RadialWheelController",
    "OnAction",
    (RadialWheelController_OnAction x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RadialWheelController_OnAction(
    RadialWheelController self,
    game.input.ScriptListenerAction action,
    game.input.ScriptListenerActionConsumer consumer
);

bool OnRadialAngleChanged(Vector4 v) RTTI

Generated hook

re.Hooks.Place(
    "RadialWheelController",
    "OnRadialAngleChanged",
    (RadialWheelController_OnRadialAngleChanged x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RadialWheelController_OnRadialAngleChanged(
    RadialWheelController self,
    Vector4 v
);

bool OnIsInMenuChanged(bool param) RTTI

Generated hook

re.Hooks.Place(
    "RadialWheelController",
    "OnIsInMenuChanged",
    (RadialWheelController_OnIsInMenuChanged x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RadialWheelController_OnIsInMenuChanged(
    RadialWheelController self,
    bool param
);

bool OnCineCamChanged(bool param) RTTI

Generated hook

re.Hooks.Place(
    "RadialWheelController",
    "OnCineCamChanged",
    (RadialWheelController_OnCineCamChanged x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RadialWheelController_OnCineCamChanged(
    RadialWheelController self,
    bool param
);

void HandleEquipmentChange(SPaperdollEquipData data) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "RadialWheelController",
    "HandleEquipmentChange;script_ref<SPaperdollEquipData>",
    (RadialWheelController_HandleEquipmentChange x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RadialWheelController_HandleEquipmentChange(
    RadialWheelController self,
    SPaperdollEquipData data
);

InventoryItemDisplayController? GetController(RadialSlot slot) RTTI

Generated hook

re.Hooks.Place(
    "RadialWheelController",
    "GetController;RadialSlot",
    (RadialWheelController_GetController x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.InventoryItemDisplayController>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RadialWheelController_GetController(
    RadialWheelController self,
    RadialSlot? slot
);

bool CanPlayerCycleCyberware() RTTI

Generated hook

re.Hooks.Place(
    "RadialWheelController",
    "CanPlayerCycleCyberware;",
    (RadialWheelController_CanPlayerCycleCyberware x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RadialWheelController_CanPlayerCycleCyberware(
    RadialWheelController self
);

game.InventoryItemData[] GetValidItemsForMiscSlot(CyclableRadialSlot cyclableSlot) RTTI

bool CanPlayerCycleMisc(CyclableRadialSlot cyclableSlot) RTTI

Generated hook

re.Hooks.Place(
    "RadialWheelController",
    "CanPlayerCycleMisc;CyclableRadialSlot",
    (RadialWheelController_CanPlayerCycleMisc x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RadialWheelController_CanPlayerCycleMisc(
    RadialWheelController self,
    CyclableRadialSlot? cyclableSlot
);

bool CanPlayerCycleSlot(CyclableRadialSlot slot) RTTI

Generated hook

re.Hooks.Place(
    "RadialWheelController",
    "CanPlayerCycleSlot;CyclableRadialSlot",
    (RadialWheelController_CanPlayerCycleSlot x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RadialWheelController_CanPlayerCycleSlot(
    RadialWheelController self,
    CyclableRadialSlot? slot
);

WeakHandle<game.ItemData>[] GetWeapons() RTTI

game.InventoryItemData GetValidCombatCyberware() RTTI

Generated hook

re.Hooks.Place(
    "RadialWheelController",
    "GetValidCombatCyberware;",
    (RadialWheelController_GetValidCombatCyberware x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.InventoryItemData>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RadialWheelController_GetValidCombatCyberware(
    RadialWheelController self
);

game.InventoryItemData GetBaseFists() RTTI

Generated hook

re.Hooks.Place(
    "RadialWheelController",
    "GetBaseFists;",
    (RadialWheelController_GetBaseFists x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.InventoryItemData>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RadialWheelController_GetBaseFists(
    RadialWheelController self
);

WeakHandle<EquipmentSystem> GetEquipmentSystem() RTTI
WeakHandle<game.ItemData> GetItemData(game.ItemID itemID) RTTI

game.InventoryItemData GetInventoryItemData(RadialSlot slot) RTTI

Generated hook

re.Hooks.Place(
    "RadialWheelController",
    "GetInventoryItemData;RadialSlot",
    (RadialWheelController_GetInventoryItemData x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.InventoryItemData>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RadialWheelController_GetInventoryItemData(
    RadialWheelController self,
    RadialSlot? slot
);

game.ItemID GetItemID(RadialSlot slot) RTTI

Generated hook

re.Hooks.Place(
    "RadialWheelController",
    "GetItemID;RadialSlot",
    (RadialWheelController_GetItemID x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.ItemID>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RadialWheelController_GetItemID(
    RadialWheelController self,
    RadialSlot? slot
);

game.Object? GetPlayer() RTTI

Generated hook

re.Hooks.Place(
    "RadialWheelController",
    "GetPlayer;",
    (RadialWheelController_GetPlayer x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.GameObject>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RadialWheelController_GetPlayer(
    RadialWheelController self
);