baseMod.hpp

#ifndef BASEMOD_HPP
#define BASEMOD_HPP
 
#include "baseMod_c.h"
#include <string>
#include "gearLoader/ggxxacpr.hpp"
 
namespace BaseMod {
 
using HookId = BaseMod_HookId;
using HookContext = BaseMod_HookContext;
using PeakMessageArgs = BaseMod_PeekMessageArgs;
using PeekMessageInfo = BaseMod_PeekMessageInfo;
using GameUpdateInfo = BaseMod_GameUpdateInfo;
using DrawInfo = BaseMod_DrawInfo;
using SaveGameInfo = BaseMod_SaveGameInfo;
 
enum class PushboxDimensionArrayType : int32_t {
    STANDING_WIDTH = BM_PD_STANDING_WIDTH,
    STANDING_HEIGHT_AC = BM_PD_STANDING_HEIGHT_AC,
    STANDING_HEIGHT_PR = BM_PD_STANDING_HEIGHT_PR,
    CROUCHING_WIDTH = BM_PD_CROUCHING_WIDTH,
    CROUCHING_HEIGHT = BM_PD_CROUCHING_HEIGHT,
    AIRBORNE_WIDTH = BM_PD_AIRBORNE_WIDTH,
    AIRBORNE_HEIGHT = BM_PD_AIRBORNE_HEIGHT,
};
enum class ThrowRangeArrayType : int32_t {
    GROUND_AC = BM_TR_GROUND_AC,
    GROUND_PR = BM_TR_GROUND_PR,
    AIR_HORIZONTAL_AC = BM_TR_AIR_HORIZONTAL_AC,
    AIR_HORIZONTAL_PR = BM_TR_AIR_HORIZONTAL_PR,
    AIR_UPPER = BM_TR_AIR_UPPER,    // This array is not split between Accent Core and Plus R
    AIR_LOWER = BM_TR_AIR_LOWER,    // This array is not split between Accent Core and Plus R
};
enum class DrawArrowSpriteDirection : uint32_t {
    LEFT = BM_DASD_LEFT,
    RIGHT = BM_DASD_RIGHT,
    UP = BM_DASD_UP,
    DOWN = BM_DASD_DOWN,
    UP_LEFT = BM_DASD_UP_LEFT,
    UP_RIGHT = BM_DASD_UP_RIGHT,
    DOWN_LEFT = BM_DASD_DOWN_LEFT,
    DOWN_RIGHT = BM_DASD_DOWN_RIGHT,
};
enum class DrawScrollArrowFlags : int32_t {
    NONE = BM_DSAF_NONE,
    UP = BM_DSAF_UP,
    DOWN = BM_DSAF_DOWN,
    BOTH = BM_DSAF_BOTH,
};
 
// Generic functionality for wrapper classes
template<typename T>
class ApiWrapper {
public:
    ApiWrapper() : _ref(nullptr) {}
    ApiWrapper(const T* ref) : _ref(ref) {}
    bool VersionError() {
        return (BASEMOD_API_VERSION_NUM & 0xFF0000) !=
            (reinterpret_cast<CApiBase*>(_ref)->version & 0xFF0000);
    }
    bool IsValid() { return _ref != nullptr; }
    const T* GetCApi() { return _ref; }
protected:
    const T* _ref;
private:
    // All Base Mod C-APIs should fit this format
    struct CApiBase {
        uint32_t size;
        uint32_t version;
    };
};
 
class NativeFunctionsApi : public ApiWrapper<BaseMod_NativeFunctionsApi> {
public:
    void RenderCockpitFontText(std::string text, int32_t x, int32_t y, float z, uint8_t alpha, float size) {
        _ref->RenderCockpitFontText(text.c_str(), x, y, z, alpha, size);
    }

    void RenderMenuText(const char* text, int32_t x, int32_t y, float z, float alpha,
        int32_t* animCounter, int32_t animSpeed, bool ignoreSpriteMask, uint32_t color
    ) {
        _ref->RenderMenuText(text, x, y, z, alpha, animCounter, animSpeed, ignoreSpriteMask, color);
    }

    void RenderMenuTextCenterAligned(const char* text, int32_t x, int32_t y,
        float z, float alpha, uint32_t color, bool ignoreSpriteMask
    ) {
        _ref->RenderMenuTextCenterAligned(text, x, y, z, alpha, color, ignoreSpriteMask);
    }

    void RenderPopUpText(int32_t playerIndex, std::string text) {
        _ref->RenderPopUpText(playerIndex, text.c_str());
    }

    bool PlayCommonSoundEffect(uint32_t id) {
        return _ref->PlayCommonSoundEffect(id);
    }

    void DrawSprite(GGXXACPR_DrawSpriteParams* params, bool ignoreSpriteMask) {
        _ref->DrawSprite(params, ignoreSpriteMask ? 1 : 0);
    }

    void DrawArrowSprite(DrawArrowSpriteDirection direction, int32_t x, int32_t y, int32_t z, uint32_t alpha) {
        _ref->DrawArrowSprite(static_cast<uint32_t>(direction), x, y, z, alpha);
    }

    void DrawTriStrip(ggxxacpr::ColorVertex* vertices, uint32_t numVertices) {
        _ref->DrawTriStrip(vertices, numVertices);
    }

    void DrawQuad(int32_t left, int32_t top, int32_t right, int32_t bottom, int32_t z, uint32_t color) {
        _ref->DrawQuad(left, top, right, bottom, z, color);
    }

    void RegisterSprites(uint32_t spriteId, void* textureDataArray, uint32_t count) {
        _ref->RegisterSprites(spriteId, textureDataArray, count);
    }

    uint32_t GetActiveCommandGrabId(ggxxacpr::Player player) {
        return _ref->GetActiveCommandGrabId(player.getRaw());
    }
};
 
class CharDataApi : public ApiWrapper<BaseMod_CharDataApi> {
public:
    uint16_t* GetPushboxDimensionArray(PushboxDimensionArrayType type) {
        return _ref->GetPushboxDimensionArray(static_cast<int32_t>(type));
    }

    int16_t* GetPushboxAirborneOffsetArray(ggxxacpr::GameVersion gameVer) {
        return _ref->GetPushboxAirborneOffsetArray(static_cast<int32_t>(gameVer));
    }

    int16_t* GetThrowRangeArray(ThrowRangeArrayType type) {
        return _ref->GetThrowRangeArray(static_cast<int32_t>(type));
    }

    uint16_t* GetCommandGrabRangeArray() {
        return _ref->GetCommandGrabRangeArray();
    }
};
 
class GameDataApi : public ApiWrapper<BaseMod_GameDataApi> {
public:
    GameDataApi() :
        ApiWrapper(),
        CharacterData() { }
    GameDataApi(const BaseMod_GameDataApi* ref) :
        ApiWrapper(ref),
        CharacterData(ref->CharacterData) { }

    CharDataApi CharacterData;

    ggxxacpr::Player GetPlayer(int playerIndex) {
        return _ref->GetPlayer(playerIndex);
    }

    ggxxacpr::PlayerInput* GetPlayerInputStructArr() { return _ref->GetPlayerInputStructArr(); }
    ggxxacpr::Camera GetCamera() {
        return _ref->GetCamera();
    }

    bool IsInGame() { return _ref->IsInGame() > 0; }
    ggxxacpr::JobMode GetJobMode() { return static_cast<ggxxacpr::JobMode>(_ref->GetJobMode()); }
    ggxxacpr::GameModeFeatureFlags GetGameModeFeatureFlags() { return static_cast<ggxxacpr::GameModeFeatureFlags>(_ref->GetGameModeFeatureFlags()); }
    ggxxacpr::MenuItem GetMainMenuSelection() { return static_cast<ggxxacpr::MenuItem>(_ref->GetMainMenuSelection()); }
    void* GetD3D9Device() { return _ref->GetD3D9Device(); }
    ggxxacpr::GameVersion GetGameVersion() { return static_cast<ggxxacpr::GameVersion>(_ref->GetGameVersion()); }
    uint32_t GetViewWidth() { return _ref->GetViewWidth(); }
    uint32_t GetViewHeight() { return _ref->GetViewHeight(); }
    ggxxacpr::Entity GetRootEntity() { return ggxxacpr::Entity(_ref->GetRootEntity()); }
    uint32_t GetGlobalThrowFlags() { return _ref->GetGlobalThrowFlags(); }
    int32_t GetPauseState() { return *_ref->GetPauseState(); }
    int32_t GetPauseDisplayState() { return *_ref->GetPauseDisplayState(); }
    ggxxacpr::LocaleState* GetLocaleState() { return _ref->GetLocaleState(); }
};
 
template<typename T>
using PeekMessageHook = void (BASEMOD_CALL *)(T* userData, const HookContext* ctx, const PeekMessageInfo* info);
template<typename T>
using GameUpdateHook = void(BASEMOD_CALL *)(T* userData, const HookContext* ctx, const GameUpdateInfo* info);
template<typename T>
using DrawHook = void(BASEMOD_CALL *)(T* userData, const HookContext* ctx, const DrawInfo* info);
template<typename T>
using SaveGameHook = void(BASEMOD_CALL *)(T* userData, const HookContext* ctx, const SaveGameInfo* info);
 
class HookApi : public ApiWrapper<BaseMod_HookApi> {
public:
    uint32_t RemoveHook(HookId id) {
        return _ref->RemoveHook(id);
    }

    HookId AfterPeekMessage(BaseMod_PeekMessageHook hookFn, void* userData) {
        return _ref->AfterPeekMessage(hookFn, userData);
    }

    template<typename T>
    HookId AfterPeekMessage(PeekMessageHook<T> hookFn, T* userData) {
        return _ref->AfterPeekMessage(
            reinterpret_cast<BaseMod_PeekMessageHook>(hookFn),
            userData);
    }

    HookId BeforeGameUpdate(BaseMod_GameUpdateHook hookFn, void* userData) {
        return _ref->BeforeGameUpdate(hookFn, userData);
    }

    template<typename T>
    HookId BeforeGameUpdate(GameUpdateHook<T> hookFn, T* userData) {
        return _ref->BeforeGameUpdate(
            reinterpret_cast<BaseMod_GameUpdateHook>(hookFn),
            userData);
    }

    HookId AfterGameUpdate(BaseMod_GameUpdateHook hookFn, void* userData) {
        return _ref->AfterGameUpdate(hookFn, userData);
    }

    template<typename T>
    HookId AfterGameUpdate(GameUpdateHook<T> hookFn, T* userData) {
        return _ref->AfterGameUpdate(
            reinterpret_cast<BaseMod_GameUpdateHook>(hookFn),
            userData);
    }

    HookId BeforeEndScene(BaseMod_DrawHook hookFn, void* userData) {
        return _ref->BeforeEndScene(hookFn, userData);
    }

    template<typename T>
    HookId BeforeEndScene(DrawHook<T> hookFn, T* userData) {
        return _ref->BeforeEndScene(
            reinterpret_cast<BaseMod_DrawHook>(hookFn),
            userData);
    }

    HookId BeforePresent(BaseMod_DrawHook hookFn, void* userData) {
        return _ref->BeforePresent(hookFn, userData);
    }

    template<typename T>
    HookId BeforePresent(DrawHook<T> hookFn, T* userData) {
        return _ref->BeforePresent(
            reinterpret_cast<BaseMod_DrawHook>(hookFn),
            userData);
    }

    HookId AfterSaveGame(BaseMod_SaveGameHook hookFn, void* userData) {
        return _ref->AfterSaveGame(hookFn, userData);
    }

    template<typename T>
    HookId AfterSaveGame(SaveGameHook<T> hookFn, T* userData) {
        return _ref->AfterSaveGame(
            reinterpret_cast<BaseMod_SaveGameHook>(hookFn),
            userData
        );
    }
};
 
using MenuAction = BM_MenuAction;
using ValueChangeCallback = BM_ValueChangeCallback;
using CustomMenuHandler = BM_CustomMenuHandler;
using ModMenuEntry = BaseMod_ModMenuEntry;
using MenuDimensions = BaseMod_MenuDimensions;
 
class ModMenuHelperFunctionsApi : public ApiWrapper<BaseMod_ModMenu_HelperFunctionsApi> {
public:
    int32_t SelectionHandler(int32_t currentSelection, uint32_t totalEntries) {
        return _ref->SelectionHandler(currentSelection, totalEntries);
    }

    bool HoldDirectionInputHandler(ggxxacpr::RawControllerInput input) {
        return _ref->HoldDirectionInputHandler(static_cast<uint32_t>(input));
    }

    void DrawEnumSettingUI(const char* label, int32_t xOffset, int32_t y, int32_t isSelected) {
        _ref->DrawEnumSettingUI(label, xOffset, y, isSelected);
    }

    void DrawGaugeSettingUI(int32_t currentValue, int32_t y, int32_t isSelected, int32_t maxValue) {
        _ref->DrawGaugeSettingUI(currentValue, y, isSelected, maxValue);
    }

    void DrawScrollArrow(DrawScrollArrowFlags flags) {
        _ref->DrawScrollArrow(static_cast<int32_t>(flags));
    }

    void SwitchToMainFiber() {
        _ref->SwitchToMainFiber();
    }
};
 
class ModMenuApi : public ApiWrapper<BaseMod_ModMenuApi> {
public:
    ModMenuApi() :
        ApiWrapper(),
        HelperFunctions() { }
    ModMenuApi(const BaseMod_ModMenuApi* ref) :
        ApiWrapper(ref),
        HelperFunctions(ref->HelperFunctions) {}
 
    ModMenuHelperFunctionsApi HelperFunctions;

    MenuDimensions GetDrawableAreaDimensions() {
        auto dim = _ref->GetDrawableAreaDimensions();
        return {dim->left, dim->top, dim->right, dim->bottom};
    }

    uint32_t RegisterMenuTab(const char* title, const ModMenuEntry* entries, uint32_t numEntries) {
        return _ref->RegisterMenuTab(title, entries, numEntries);
    }

    uint32_t RegisterCustomMenuTab(const char* title, CustomMenuHandler handler) {
        return _ref->RegisterCustomMenuTab(title, handler);
    }
};
 
class Api : public ApiWrapper<BaseMod_Api> {
public:
    Api()
        : ApiWrapper()
        , NativeFunctions()
        , GameData()
        , Hooks()
        , ModMenu() { }
    Api(const BaseMod_Api* ref)
        : ApiWrapper(ref)
        , NativeFunctions(ref->NativeFunctions)
        , GameData(ref->GameData)
        , Hooks(ref->Hooks)
        , ModMenu(ref->ModMenu) { }

    NativeFunctionsApi NativeFunctions;
    GameDataApi GameData;
    HookApi Hooks;
    ModMenuApi ModMenu;
};
 
}
 
#endif