class game.ui

BackpackMainGameController

game.ui.BackpackMainGameController

67 properties
70 functions

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

Properties

Property	Type	Offset
`commonCraftingMaterialsGrid`	`ink.CompoundWidgetReference`	`0x10`	scripted
`hackingCraftingMaterialsGrid`	`ink.CompoundWidgetReference`	`0x28`	scripted
`filterButtonsGrid`	`ink.CompoundWidgetReference`	`0x40`	scripted
`virtualItemsGrid`	`ink.VirtualCompoundWidgetReference`	`0x58`	scripted
`TooltipsManagerRef`	`ink.WidgetReference`	`0x70`	scripted
`buttonHintsManagerRef`	`ink.WidgetReference`	`0x88`	scripted
`sortingButton`	`ink.WidgetReference`	`0xA0`	scripted
`sortingDropdown`	`ink.WidgetReference`	`0xB8`	scripted
`itemsListScrollAreaContainer`	`ink.WidgetReference`	`0xD0`	scripted
`itemNotificationRoot`	`ink.WidgetReference`	`0xE8`	scripted
`disassembleJunkButton`	`ink.WidgetReference`	`0x100`	scripted
`virtualBackpackItemsListController`	`WeakHandle<ink.GridController>`	`0x118`	scripted
`TooltipsManager`	`WeakHandle<game.ui.TooltipsManager>`	`0x128`	scripted
`buttonHintsController`	`WeakHandle<ButtonHints>`	`0x138`	scripted
`itemTypeSorting`	`game.data.ItemType[]`	`0x148`	scripted
`InventoryManager`	`InventoryDataManagerV2?`	`0x158`	scripted
`player`	`WeakHandle<PlayerPuppet>`	`0x168`	scripted
`itemDropQueueItems`	`game.ItemID[]`	`0x178`	scripted
`itemDropQueue`	`game.ItemModParams[]`	`0x188`	scripted
`junkItems`	`UIInventoryItem?[]`	`0x198`	scripted
`isRefreshUIScheduled`	`bool`	`0x1A8`	scripted
`craftingMaterialsListItems`	`WeakHandle<CrafringMaterialItemController>[]`	`0x1B0`	scripted
`DisassembleCallback`	`UI_CraftingDef?`	`0x1C0`	scripted
`DisassembleBlackboard`	`WeakHandle<game.IBlackboard>`	`0x1D0`	scripted
`DisassembleBBID`	`red.CallbackObject?`	`0x1E0`	scripted
`EquippedCallback`	`UI_EquipmentDef?`	`0x1F0`	scripted
`EquippedBlackboard`	`WeakHandle<game.IBlackboard>`	`0x200`	scripted
`EquippedBBID`	`red.CallbackObject?`	`0x210`	scripted
`InventoryCallback`	`UI_InventoryDef?`	`0x220`	scripted
`InventoryBlackboard`	`WeakHandle<game.IBlackboard>`	`0x230`	scripted
`InventoryItemAddedBBID`	`red.CallbackObject?`	`0x240`	scripted
`InventoryItemRemvoedBBID`	`red.CallbackObject?`	`0x250`	scripted
`InventoryItemQuantityChangedBBID`	`red.CallbackObject?`	`0x260`	scripted
`menuEventDispatcher`	`WeakHandle<ink.MenuEventDispatcher>`	`0x270`	scripted
`activeFilter`	`WeakHandle<BackpackFilterButtonController>`	`0x280`	scripted
`filterSpawnRequests`	`WeakHandle<ink.AsyncSpawnRequest>[]`	`0x290`	scripted
`backpackItemsDataSource`	`ink.ScriptableDataSourceWrapper?`	`0x2A0`	scripted
`backpackItemsDataView`	`BackpackDataView?`	`0x2B0`	scripted
`comparisonResolver`	`InventoryItemPreferredComparisonResolver?`	`0x2C0`	scripted
`backpackInventoryListenerCallback`	`BackpackInventoryListenerCallback?`	`0x2D0`	scripted
`backpackInventoryListener`	`game.InventoryScriptListener?`	`0x2E0`	scripted
`backpackItemsClassifier`	`ItemDisplayTemplateClassifier?`	`0x2F0`	scripted
`backpackItemsPositionProvider`	`ItemPositionProvider?`	`0x300`	scripted
`equipSlotChooserPopupToken`	`ink.GameNotificationToken?`	`0x310`	scripted
`quantityPickerPopupToken`	`ink.GameNotificationToken?`	`0x320`	scripted
`disassembleJunkPopupToken`	`ink.GameNotificationToken?`	`0x330`	scripted
`equipRequested`	`bool`	`0x340`	scripted
`psmBlackboard`	`WeakHandle<game.IBlackboard>`	`0x348`	scripted
`playerState`	`game.PSMVehicle`	`0x358`	scripted
`uiScriptableSystem`	`WeakHandle<UIScriptableSystem>`	`0x360`	scripted
`uiInventorySystem`	`WeakHandle<UIInventoryScriptableSystem>`	`0x370`	scripted
`itemDisplayContext`	`ItemDisplayContextData?`	`0x380`	scripted
`comparedItemDisplayContext`	`ItemDisplayContextData?`	`0x390`	scripted
`confirmationPopupToken`	`ink.GameNotificationToken?`	`0x3A0`	scripted
`lastItemHoverOverEvent`	`ItemDisplayHoverOverEvent?`	`0x3B0`	scripted
`isComparisonDisabled`	`bool`	`0x3C0`	scripted
`immediateNotificationListener`	`BakcpackImmediateNotificationListener?`	`0x3C8`	scripted
`lastDisassembledWidget`	`WeakHandle<InventoryItemDisplayController>`	`0x3D8`	scripted
`cursorData`	`MenuCursorUserData?`	`0x3E8`	scripted
`pressedItemDisplay`	`WeakHandle<InventoryItemDisplayController>`	`0x3F8`	scripted
`delayedOutfitCooldownResetCallbackId`	`game.DelayID`	`0x408`	scripted
`outfitInCooldown`	`bool`	`0x410`	scripted
`outfitCooldownPeroid`	`float`	`0x414`	scripted
`virtualWidgets`	`ink.ScriptWeakHashMap?`	`0x418`	scripted
`allWidgets`	`ink.ScriptWeakHashMap?`	`0x428`	scripted
`itemPreviewPopupToken`	`ink.GameNotificationToken?`	`0x438`	scripted
`afterCloseRequest`	`bool`	`0x448`	scripted

Functions

bool OnInitialize() overrideRTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct BackpackMainGameController_OnInitialize(
    game.ui.BackpackMainGameController self
);

bool OnUninitialize() overrideRTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct BackpackMainGameController_OnUninitialize(
    game.ui.BackpackMainGameController self
);

bool OnPlayerAttach(game.Object playerPuppet) RTTI

Generated hook

re.Hooks.Place(
    "gameuiBackpackMainGameController",
    "OnPlayerAttach",
    (BackpackMainGameController_OnPlayerAttach x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct BackpackMainGameController_OnPlayerAttach(
    game.ui.BackpackMainGameController self,
    game.Object? playerPuppet
);

bool OnPlayerDetach(game.Object playerPuppet) RTTI

Generated hook

re.Hooks.Place(
    "gameuiBackpackMainGameController",
    "OnPlayerDetach",
    (BackpackMainGameController_OnPlayerDetach x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct BackpackMainGameController_OnPlayerDetach(
    game.ui.BackpackMainGameController self,
    game.Object? playerPuppet
);

bool OnPostOnRelease(ink.PointerEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "gameuiBackpackMainGameController",
    "OnPostOnRelease",
    (BackpackMainGameController_OnPostOnRelease x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct BackpackMainGameController_OnPostOnRelease(
    game.ui.BackpackMainGameController self,
    ink.PointerEvent? evt
);

bool OnSetMenuEventDispatcher(WeakHandle<ink.MenuEventDispatcher> menuEventDispatcher) overrideRTTI

Generated hook

re.Hooks.Place(
    "gameuiBackpackMainGameController",
    "OnSetMenuEventDispatcher",
    (BackpackMainGameController_OnSetMenuEventDispatcher x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct BackpackMainGameController_OnSetMenuEventDispatcher(
    game.ui.BackpackMainGameController self,
    WeakHandle<ink.MenuEventDispatcher> menuEventDispatcher
);

bool OnCloseMenu(IScriptable userData) RTTI

Generated hook

re.Hooks.Place(
    "gameuiBackpackMainGameController",
    "OnCloseMenu",
    (BackpackMainGameController_OnCloseMenu x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct BackpackMainGameController_OnCloseMenu(
    game.ui.BackpackMainGameController self,
    IScriptable? userData
);

bool OnBack(IScriptable userData) overrideRTTI

Generated hook

re.Hooks.Place(
    "gameuiBackpackMainGameController",
    "OnBack",
    (BackpackMainGameController_OnBack x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct BackpackMainGameController_OnBack(
    game.ui.BackpackMainGameController self,
    IScriptable? userData
);

void RegisterToBB() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameuiBackpackMainGameController",
    "RegisterToBB;",
    (BackpackMainGameController_RegisterToBB x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct BackpackMainGameController_RegisterToBB(
    game.ui.BackpackMainGameController self
);

void UnregisterFromBB() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameuiBackpackMainGameController",
    "UnregisterFromBB;",
    (BackpackMainGameController_UnregisterFromBB x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct BackpackMainGameController_UnregisterFromBB(
    game.ui.BackpackMainGameController self
);

void SetupVirtualGrid() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameuiBackpackMainGameController",
    "SetupVirtualGrid;",
    (BackpackMainGameController_SetupVirtualGrid x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct BackpackMainGameController_SetupVirtualGrid(
    game.ui.BackpackMainGameController self
);

void ResetVirtualGrid() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameuiBackpackMainGameController",
    "ResetVirtualGrid;",
    (BackpackMainGameController_ResetVirtualGrid x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct BackpackMainGameController_ResetVirtualGrid(
    game.ui.BackpackMainGameController self
);

void SetupDropdown() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameuiBackpackMainGameController",
    "SetupDropdown;",
    (BackpackMainGameController_SetupDropdown x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct BackpackMainGameController_SetupDropdown(
    game.ui.BackpackMainGameController self
);

bool OnDropdownItemClickedEvent(DropdownItemClickedEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "gameuiBackpackMainGameController",
    "OnDropdownItemClickedEvent",
    (BackpackMainGameController_OnDropdownItemClickedEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct BackpackMainGameController_OnDropdownItemClickedEvent(
    game.ui.BackpackMainGameController self,
    DropdownItemClickedEvent? evt
);

void OnBakcpackItemDisplayNotification(ItemDisplayNotificationMessage message, ulong id, WeakHandle<IScriptable>? data) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameuiBackpackMainGameController",
    "OnBakcpackItemDisplayNotification;ItemDisplayNotificationMessageUint64IScriptable",
    (BackpackMainGameController_OnBakcpackItemDisplayNotification x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct BackpackMainGameController_OnBakcpackItemDisplayNotification(
    game.ui.BackpackMainGameController self,
    ItemDisplayNotificationMessage message,
    ulong id,
    WeakHandle<IScriptable>? data
);

void HandleItemQuantityModified(game.ItemID itemID, bool backpackItem) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameuiBackpackMainGameController",
    "HandleItemQuantityModified;ItemIDBool",
    (BackpackMainGameController_HandleItemQuantityModified x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct BackpackMainGameController_HandleItemQuantityModified(
    game.ui.BackpackMainGameController self,
    game.ItemID itemID,
    bool backpackItem
);

void RefreshUI() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameuiBackpackMainGameController",
    "RefreshUI;",
    (BackpackMainGameController_RefreshUI x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct BackpackMainGameController_RefreshUI(
    game.ui.BackpackMainGameController self
);

void RefreshUINextFrame() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameuiBackpackMainGameController",
    "RefreshUINextFrame;",
    (BackpackMainGameController_RefreshUINextFrame x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct BackpackMainGameController_RefreshUINextFrame(
    game.ui.BackpackMainGameController self
);

bool OnRefreshUINextFrame(BackpackUpdateNextFrameEvent e) RTTI

Generated hook

re.Hooks.Place(
    "gameuiBackpackMainGameController",
    "OnRefreshUINextFrame",
    (BackpackMainGameController_OnRefreshUINextFrame x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct BackpackMainGameController_OnRefreshUINextFrame(
    game.ui.BackpackMainGameController self,
    BackpackUpdateNextFrameEvent? e
);

void AddToDropQueue(game.ItemModParams item) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameuiBackpackMainGameController",
    "AddToDropQueue;ItemModParams",
    (BackpackMainGameController_AddToDropQueue x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct BackpackMainGameController_AddToDropQueue(
    game.ui.BackpackMainGameController self,
    game.ItemModParams item
);

game.ItemModParams GetDropQueueItem(game.ItemID itemID) RTTI

Generated hook

re.Hooks.Place(
    "gameuiBackpackMainGameController",
    "GetDropQueueItem;ItemID",
    (BackpackMainGameController_GetDropQueueItem x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.ItemModParams>();
    }
);

[Msgpack.Gen]
public readonly partial record struct BackpackMainGameController_GetDropQueueItem(
    game.ui.BackpackMainGameController self,
    game.ItemID itemID
);

void PopulateInventory() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameuiBackpackMainGameController",
    "PopulateInventory;",
    (BackpackMainGameController_PopulateInventory x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct BackpackMainGameController_PopulateInventory(
    game.ui.BackpackMainGameController self
);

void ClearCraftingMaterials() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameuiBackpackMainGameController",
    "ClearCraftingMaterials;",
    (BackpackMainGameController_ClearCraftingMaterials x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct BackpackMainGameController_ClearCraftingMaterials(
    game.ui.BackpackMainGameController self
);

void PopulateCraftingMaterials() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameuiBackpackMainGameController",
    "PopulateCraftingMaterials;",
    (BackpackMainGameController_PopulateCraftingMaterials x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct BackpackMainGameController_PopulateCraftingMaterials(
    game.ui.BackpackMainGameController self
);

void CreateCraftingMaterialItem(CachedCraftingMaterial craftingMaterial, ink.CompoundWidgetReference gridList) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameuiBackpackMainGameController",
    "CreateCraftingMaterialItem;CachedCraftingMaterialinkCompoundRef",
    (BackpackMainGameController_CreateCraftingMaterialItem x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct BackpackMainGameController_CreateCraftingMaterialItem(
    game.ui.BackpackMainGameController self,
    CachedCraftingMaterial? craftingMaterial,
    ink.CompoundWidgetReference gridList
);

bool OnCraftingMaterialItemSpawned(ink.Widget widget, BackpackCraftingMaterialItemCallbackData callbackData) RTTI

Generated hook

re.Hooks.Place(
    "gameuiBackpackMainGameController",
    "OnCraftingMaterialItemSpawned",
    (BackpackMainGameController_OnCraftingMaterialItemSpawned x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct BackpackMainGameController_OnCraftingMaterialItemSpawned(
    game.ui.BackpackMainGameController self,
    ink.Widget? widget,
    BackpackCraftingMaterialItemCallbackData? callbackData
);

void UpdateCraftingMaterial(game.ItemID materialID, bool? skipAnim) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameuiBackpackMainGameController",
    "UpdateCraftingMaterial;ItemIDBool",
    (BackpackMainGameController_UpdateCraftingMaterial x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct BackpackMainGameController_UpdateCraftingMaterial(
    game.ui.BackpackMainGameController self,
    game.ItemID materialID,
    bool? skipAnim
);

void RefreshFilterButtons(ItemFilterCategory[] filters) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameuiBackpackMainGameController",
    "RefreshFilterButtons;script_ref<array<ItemFilterCategory>>",
    (BackpackMainGameController_RefreshFilterButtons x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct BackpackMainGameController_RefreshFilterButtons(
    game.ui.BackpackMainGameController self,
    ItemFilterCategory[] filters
);

bool OnFilterButtonSpawned(ink.Widget widget, BackpackFilterButtonSpawnedCallbackData callbackData) RTTI

Generated hook

re.Hooks.Place(
    "gameuiBackpackMainGameController",
    "OnFilterButtonSpawned",
    (BackpackMainGameController_OnFilterButtonSpawned x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct BackpackMainGameController_OnFilterButtonSpawned(
    game.ui.BackpackMainGameController self,
    ink.Widget? widget,
    BackpackFilterButtonSpawnedCallbackData? callbackData
);

void InvalidateItemTooltipEvent() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameuiBackpackMainGameController",
    "InvalidateItemTooltipEvent;",
    (BackpackMainGameController_InvalidateItemTooltipEvent x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct BackpackMainGameController_InvalidateItemTooltipEvent(
    game.ui.BackpackMainGameController self
);

bool OnItemDisplayHoverOver(ItemDisplayHoverOverEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "gameuiBackpackMainGameController",
    "OnItemDisplayHoverOver",
    (BackpackMainGameController_OnItemDisplayHoverOver x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct BackpackMainGameController_OnItemDisplayHoverOver(
    game.ui.BackpackMainGameController self,
    ItemDisplayHoverOverEvent? evt
);

void RequestItemInspected(game.ItemID itemID) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameuiBackpackMainGameController",
    "RequestItemInspected;ItemID",
    (BackpackMainGameController_RequestItemInspected x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct BackpackMainGameController_RequestItemInspected(
    game.ui.BackpackMainGameController self,
    game.ItemID itemID
);

bool OnItemDisplayHoverOut(ItemDisplayHoverOutEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "gameuiBackpackMainGameController",
    "OnItemDisplayHoverOut",
    (BackpackMainGameController_OnItemDisplayHoverOut x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct BackpackMainGameController_OnItemDisplayHoverOut(
    game.ui.BackpackMainGameController self,
    ItemDisplayHoverOutEvent? evt
);

void HighlightDisassemblyResults(WeakHandle<UIInventoryItem> inventoryItem) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameuiBackpackMainGameController",
    "HighlightDisassemblyResults;UIInventoryItem",
    (BackpackMainGameController_HighlightDisassemblyResults x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct BackpackMainGameController_HighlightDisassemblyResults(
    game.ui.BackpackMainGameController self,
    WeakHandle<UIInventoryItem> inventoryItem
);

void HideDisassemblyHighlight() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameuiBackpackMainGameController",
    "HideDisassemblyHighlight;",
    (BackpackMainGameController_HideDisassemblyHighlight x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct BackpackMainGameController_HideDisassemblyHighlight(
    game.ui.BackpackMainGameController self
);

IngredientData[] GetDisassemblyResult(WeakHandle<UIInventoryItem> inventoryItem) RTTI

int GetBackpackItemQuantity(WeakHandle<UIInventoryItem> inventoryItem) RTTI

Generated hook

re.Hooks.Place(
    "gameuiBackpackMainGameController",
    "GetBackpackItemQuantity;UIInventoryItem",
    (BackpackMainGameController_GetBackpackItemQuantity x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct BackpackMainGameController_GetBackpackItemQuantity(
    game.ui.BackpackMainGameController self,
    WeakHandle<UIInventoryItem> inventoryItem
);

bool OnSortingButtonClicked(ink.PointerEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "gameuiBackpackMainGameController",
    "OnSortingButtonClicked",
    (BackpackMainGameController_OnSortingButtonClicked x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct BackpackMainGameController_OnSortingButtonClicked(
    game.ui.BackpackMainGameController self,
    ink.PointerEvent? evt
);

bool OnItemDisplayClick(ItemDisplayClickEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "gameuiBackpackMainGameController",
    "OnItemDisplayClick",
    (BackpackMainGameController_OnItemDisplayClick x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct BackpackMainGameController_OnItemDisplayClick(
    game.ui.BackpackMainGameController self,
    ItemDisplayClickEvent? evt
);

bool OnDisassembleJunkButtonClick(ink.PointerEvent e) RTTI

Generated hook

re.Hooks.Place(
    "gameuiBackpackMainGameController",
    "OnDisassembleJunkButtonClick",
    (BackpackMainGameController_OnDisassembleJunkButtonClick x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct BackpackMainGameController_OnDisassembleJunkButtonClick(
    game.ui.BackpackMainGameController self,
    ink.PointerEvent? e
);

void OpenDisassembleJunkConfirmation() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameuiBackpackMainGameController",
    "OpenDisassembleJunkConfirmation;",
    (BackpackMainGameController_OpenDisassembleJunkConfirmation x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct BackpackMainGameController_OpenDisassembleJunkConfirmation(
    game.ui.BackpackMainGameController self
);

bool OnDisassembleJunkPopupClosed(ink.GameNotificationData data) RTTI

Generated hook

re.Hooks.Place(
    "gameuiBackpackMainGameController",
    "OnDisassembleJunkPopupClosed",
    (BackpackMainGameController_OnDisassembleJunkPopupClosed x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct BackpackMainGameController_OnDisassembleJunkPopupClosed(
    game.ui.BackpackMainGameController self,
    ink.GameNotificationData? data
);

UIMenuNotificationType DetermineUIMenuNotificationType() RTTI

Generated hook

re.Hooks.Place(
    "gameuiBackpackMainGameController",
    "DetermineUIMenuNotificationType;",
    (BackpackMainGameController_DetermineUIMenuNotificationType x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.UIMenuNotificationType>();
    }
);

[Msgpack.Gen]
public readonly partial record struct BackpackMainGameController_DetermineUIMenuNotificationType(
    game.ui.BackpackMainGameController self
);

void OpenConfirmationPopup(WeakHandle<UIInventoryItem> inventoryItem) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameuiBackpackMainGameController",
    "OpenConfirmationPopup;UIInventoryItem",
    (BackpackMainGameController_OpenConfirmationPopup x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct BackpackMainGameController_OpenConfirmationPopup(
    game.ui.BackpackMainGameController self,
    WeakHandle<UIInventoryItem> inventoryItem
);

bool OnConfirmationPopupClosed(ink.GameNotificationData data) RTTI

Generated hook

re.Hooks.Place(
    "gameuiBackpackMainGameController",
    "OnConfirmationPopupClosed",
    (BackpackMainGameController_OnConfirmationPopupClosed x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct BackpackMainGameController_OnConfirmationPopupClosed(
    game.ui.BackpackMainGameController self,
    ink.GameNotificationData? data
);

void OpenQuantityPicker(WeakHandle<UIInventoryItem> itemData, QuantityPickerActionType actionType) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameuiBackpackMainGameController",
    "OpenQuantityPicker;UIInventoryItemQuantityPickerActionType",
    (BackpackMainGameController_OpenQuantityPicker x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct BackpackMainGameController_OpenQuantityPicker(
    game.ui.BackpackMainGameController self,
    WeakHandle<UIInventoryItem> itemData,
    QuantityPickerActionType actionType
);

bool OnQuantityPickerPopupClosed(ink.GameNotificationData data) RTTI

Generated hook

re.Hooks.Place(
    "gameuiBackpackMainGameController",
    "OnQuantityPickerPopupClosed",
    (BackpackMainGameController_OnQuantityPickerPopupClosed x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct BackpackMainGameController_OnQuantityPickerPopupClosed(
    game.ui.BackpackMainGameController self,
    ink.GameNotificationData? data
);

void OnQuantityPickerDrop(QuantityPickerPopupCloseData data) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameuiBackpackMainGameController",
    "OnQuantityPickerDrop;QuantityPickerPopupCloseData",
    (BackpackMainGameController_OnQuantityPickerDrop x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct BackpackMainGameController_OnQuantityPickerDrop(
    game.ui.BackpackMainGameController self,
    QuantityPickerPopupCloseData? data
);

void OnQuantityPickerDisassembly(QuantityPickerPopupCloseData data) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameuiBackpackMainGameController",
    "OnQuantityPickerDisassembly;QuantityPickerPopupCloseData",
    (BackpackMainGameController_OnQuantityPickerDisassembly x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct BackpackMainGameController_OnQuantityPickerDisassembly(
    game.ui.BackpackMainGameController self,
    QuantityPickerPopupCloseData? data
);

bool IsEquippable(game.ItemData itemData) RTTI

Generated hook

re.Hooks.Place(
    "gameuiBackpackMainGameController",
    "IsEquippable;gameItemData",
    (BackpackMainGameController_IsEquippable x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct BackpackMainGameController_IsEquippable(
    game.ui.BackpackMainGameController self,
    game.ItemData? itemData
);

bool ScheduleOutfitCooldownReset() RTTI

Generated hook

re.Hooks.Place(
    "gameuiBackpackMainGameController",
    "ScheduleOutfitCooldownReset;",
    (BackpackMainGameController_ScheduleOutfitCooldownReset x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct BackpackMainGameController_ScheduleOutfitCooldownReset(
    game.ui.BackpackMainGameController self
);

void SetOutfitCooldown(bool inCooldown) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameuiBackpackMainGameController",
    "SetOutfitCooldown;Bool",
    (BackpackMainGameController_SetOutfitCooldown x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct BackpackMainGameController_SetOutfitCooldown(
    game.ui.BackpackMainGameController self,
    bool inCooldown
);

void EquipItem(WeakHandle<UIInventoryItem> itemData) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameuiBackpackMainGameController",
    "EquipItem;UIInventoryItem",
    (BackpackMainGameController_EquipItem x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct BackpackMainGameController_EquipItem(
    game.ui.BackpackMainGameController self,
    WeakHandle<UIInventoryItem> itemData
);

void ShowNotification(ScriptGameInstance gameInstance, UIMenuNotificationType type) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameuiBackpackMainGameController",
    "ShowNotification;GameInstanceUIMenuNotificationType",
    (BackpackMainGameController_ShowNotification x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct BackpackMainGameController_ShowNotification(
    game.ui.BackpackMainGameController self,
    ScriptGameInstance gameInstance,
    UIMenuNotificationType type
);

void OpenBackpackEquipSlotChooser(WeakHandle<UIInventoryItem> itemData) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameuiBackpackMainGameController",
    "OpenBackpackEquipSlotChooser;UIInventoryItem",
    (BackpackMainGameController_OpenBackpackEquipSlotChooser x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct BackpackMainGameController_OpenBackpackEquipSlotChooser(
    game.ui.BackpackMainGameController self,
    WeakHandle<UIInventoryItem> itemData
);

bool OnBackpacEquipSlotChooserClosed(ink.GameNotificationData data) RTTI

Generated hook

re.Hooks.Place(
    "gameuiBackpackMainGameController",
    "OnBackpacEquipSlotChooserClosed",
    (BackpackMainGameController_OnBackpacEquipSlotChooserClosed x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct BackpackMainGameController_OnBackpacEquipSlotChooserClosed(
    game.ui.BackpackMainGameController self,
    ink.GameNotificationData? data
);

bool OnItemPreviewPopup(ink.GameNotificationData data) RTTI

Generated hook

re.Hooks.Place(
    "gameuiBackpackMainGameController",
    "OnItemPreviewPopup",
    (BackpackMainGameController_OnItemPreviewPopup x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct BackpackMainGameController_OnItemPreviewPopup(
    game.ui.BackpackMainGameController self,
    ink.GameNotificationData? data
);

bool OnItemFilterClick(ink.PointerEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "gameuiBackpackMainGameController",
    "OnItemFilterClick",
    (BackpackMainGameController_OnItemFilterClick x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct BackpackMainGameController_OnItemFilterClick(
    game.ui.BackpackMainGameController self,
    ink.PointerEvent? evt
);

bool OnItemFilterHoverOver(ink.PointerEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "gameuiBackpackMainGameController",
    "OnItemFilterHoverOver",
    (BackpackMainGameController_OnItemFilterHoverOver x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct BackpackMainGameController_OnItemFilterHoverOver(
    game.ui.BackpackMainGameController self,
    ink.PointerEvent? evt
);

bool OnItemFilterHoverOut(ink.PointerEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "gameuiBackpackMainGameController",
    "OnItemFilterHoverOut",
    (BackpackMainGameController_OnItemFilterHoverOut x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct BackpackMainGameController_OnItemFilterHoverOut(
    game.ui.BackpackMainGameController self,
    ink.PointerEvent? evt
);

bool OnCraftingMaterialHoverOver(ink.PointerEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "gameuiBackpackMainGameController",
    "OnCraftingMaterialHoverOver",
    (BackpackMainGameController_OnCraftingMaterialHoverOver x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct BackpackMainGameController_OnCraftingMaterialHoverOver(
    game.ui.BackpackMainGameController self,
    ink.PointerEvent? evt
);

bool OnCraftingMaterialHoverOut(ink.PointerEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "gameuiBackpackMainGameController",
    "OnCraftingMaterialHoverOut",
    (BackpackMainGameController_OnCraftingMaterialHoverOut x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct BackpackMainGameController_OnCraftingMaterialHoverOut(
    game.ui.BackpackMainGameController self,
    ink.PointerEvent? evt
);

bool OnItemDisplayPress(ItemDisplayPressEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "gameuiBackpackMainGameController",
    "OnItemDisplayPress",
    (BackpackMainGameController_OnItemDisplayPress x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct BackpackMainGameController_OnItemDisplayPress(
    game.ui.BackpackMainGameController self,
    ItemDisplayPressEvent? evt
);

bool OnItemDisplayHold(ItemDisplayHoldEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "gameuiBackpackMainGameController",
    "OnItemDisplayHold",
    (BackpackMainGameController_OnItemDisplayHold x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct BackpackMainGameController_OnItemDisplayHold(
    game.ui.BackpackMainGameController self,
    ItemDisplayHoldEvent? evt
);

void OnInventoryRequestTooltip(WeakHandle<UIInventoryItem> itemData, WeakHandle<ink.Widget> widget, DEBUG_IconErrorInfo iconErrorInfo)

RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameuiBackpackMainGameController",
    "OnInventoryRequestTooltip;UIInventoryIteminkWidgetDEBUG_IconErrorInfo",
    (BackpackMainGameController_OnInventoryRequestTooltip x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct BackpackMainGameController_OnInventoryRequestTooltip(
    game.ui.BackpackMainGameController self,
    WeakHandle<UIInventoryItem> itemData,
    WeakHandle<ink.Widget> widget,
    DEBUG_IconErrorInfo? iconErrorInfo
);

void NewShowItemHints(WeakHandle<UIInventoryItem> itemData) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameuiBackpackMainGameController",
    "NewShowItemHints;UIInventoryItem",
    (BackpackMainGameController_NewShowItemHints x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct BackpackMainGameController_NewShowItemHints(
    game.ui.BackpackMainGameController self,
    WeakHandle<UIInventoryItem> itemData
);

void SetInventoryItemButtonHintsHoverOver(game.InventoryItemData displayingData) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameuiBackpackMainGameController",
    "SetInventoryItemButtonHintsHoverOver;script_ref<InventoryItemData>",
    (BackpackMainGameController_SetInventoryItemButtonHintsHoverOver x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct BackpackMainGameController_SetInventoryItemButtonHintsHoverOver(
    game.ui.BackpackMainGameController self,
    game.InventoryItemData displayingData
);

void UpdateFavouriteHint(bool state) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameuiBackpackMainGameController",
    "UpdateFavouriteHint;Bool",
    (BackpackMainGameController_UpdateFavouriteHint x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct BackpackMainGameController_UpdateFavouriteHint(
    game.ui.BackpackMainGameController self,
    bool state
);

void SetInventoryItemButtonHintsHoverOut() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameuiBackpackMainGameController",
    "SetInventoryItemButtonHintsHoverOut;",
    (BackpackMainGameController_SetInventoryItemButtonHintsHoverOut x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct BackpackMainGameController_SetInventoryItemButtonHintsHoverOut(
    game.ui.BackpackMainGameController self
);

void SetWarningMessage(string message) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameuiBackpackMainGameController",
    "SetWarningMessage;script_ref<String>",
    (BackpackMainGameController_SetWarningMessage x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct BackpackMainGameController_SetWarningMessage(
    game.ui.BackpackMainGameController self,
    string message
);