sl_cpp.h

Go to the documentation of this file.

#pragma once
 
#include <coreinit/mcp.h>
#include <coreinit/memdefaultheap.h>
#include <nn/result.h>
#include <wut.h>
 
#ifdef __cplusplus
 
namespace nn::sl {
    typedef enum MediaType {
        NN_SL_MEDIA_TYPE_MLC  = 0x00,
        NN_SL_MEDIA_TYPE_SLC  = 0x01,
        NN_SL_MEDIA_TYPE_ODD  = 0x02,
        NN_SL_MEDIA_TYPE_USB  = 0x03,
        NN_SL_MEDIA_TYPE_HFIO = 0x04,
    } MediaType;
 
    typedef struct WUT_PACKED LaunchInfo {
        uint64_t titleId;
        MCPAppType appType;
        MediaType mediaType;
        char parameter[0x800];
    } LaunchInfo;
    WUT_CHECK_OFFSET(LaunchInfo, 0x00, titleId);
    WUT_CHECK_OFFSET(LaunchInfo, 0x08, appType);
    WUT_CHECK_OFFSET(LaunchInfo, 0x0C, mediaType);
    WUT_CHECK_SIZE(LaunchInfo, 0x810);
 
    typedef struct WUT_PACKED LaunchInfoDatabaseEntry {
        uint64_t id;
        LaunchInfo launchInfo;
    } LaunchInfoDatabaseEntry;
    WUT_CHECK_SIZE(LaunchInfoDatabaseEntry, 0x818);
    WUT_CHECK_OFFSET(LaunchInfoDatabaseEntry, 0x0, id);
    WUT_CHECK_OFFSET(LaunchInfoDatabaseEntry, 0x8, launchInfo);
 
    // This struct has a variable length, the hash is always expected at the end
    typedef struct WUT_PACKED LaunchInfoDatabaseHeader {
        uint32_t version; // 1
        uint32_t magic;   // "LIDB"
        uint32_t maxEntries;
        uint32_t entryCount;
        uint64_t currentId;                 // start at 0x1000000000000000
        LaunchInfoDatabaseEntry entries[0]; // Dynamic, actually this array should be entries[maxEntries]
        char sha1Hash[20];
    } LaunchInfoDatabaseHeader;
    WUT_CHECK_SIZE(LaunchInfoDatabaseHeader, 0x2C);
    WUT_CHECK_OFFSET(LaunchInfoDatabaseHeader, 0x0, version);
    WUT_CHECK_OFFSET(LaunchInfoDatabaseHeader, 0x4, magic);
    WUT_CHECK_OFFSET(LaunchInfoDatabaseHeader, 0x8, maxEntries);
    WUT_CHECK_OFFSET(LaunchInfoDatabaseHeader, 0xC, entryCount);
    WUT_CHECK_OFFSET(LaunchInfoDatabaseHeader, 0x10, currentId);
    WUT_CHECK_OFFSET(LaunchInfoDatabaseHeader, 0x18, entries);
    WUT_CHECK_OFFSET(LaunchInfoDatabaseHeader, 0x18, sha1Hash);
 
    struct WUT_PACKED IconInfo {
        uint8_t data[65580]; // tga
        char name[0x80];
    };
    WUT_CHECK_SIZE(IconInfo, 0x100ac);
    WUT_CHECK_OFFSET(IconInfo, 0, data);
    WUT_CHECK_OFFSET(IconInfo, 0x1002c, name);
 
    struct WUT_PACKED AccountUUID {
        char uuid[10];
    };
    WUT_CHECK_SIZE(AccountUUID, 10);
 
    struct DRCImagePaletteColor {
        uint8_t b;
        uint8_t g;
        uint8_t r;
        uint8_t a;
    };
    WUT_CHECK_SIZE(DRCImagePaletteColor, 4);
    WUT_CHECK_OFFSET(DRCImagePaletteColor, 0, b);
    WUT_CHECK_OFFSET(DRCImagePaletteColor, 1, g);
    WUT_CHECK_OFFSET(DRCImagePaletteColor, 2, r);
    WUT_CHECK_OFFSET(DRCImagePaletteColor, 3, a);
 
    struct DRCImagePalette {
        DRCImagePaletteColor values[0x100];
    };
    WUT_CHECK_SIZE(DRCImagePalette, 0x400);
    WUT_CHECK_OFFSET(DRCImagePalette, 0, values);
 
    struct WUT_PACKED TransferableInfo {
        uint8_t numAccounts;
        uint8_t defaultAccountIndex;
        AccountUUID uuids[12];
        WUT_PADDING_BYTES(0x48);
        uint8_t isNetworkAccount[12];
        uint8_t isPasswordCacheEnabled[12];
        uint64_t titleIds[10];
        uint8_t isOnDisc[10];
        uint64_t killerNotificationsTitleId;
        uint32_t serialId;
        WUT_PADDING_BYTES(192);
        struct {
            DRCImagePalette palette;
            uint8_t pixelIndex[206][412]; // index of color in palette
        } accountSceneImage;
        struct {
            DRCImagePalette palette;
            uint8_t pixelIndex[129][1630]; // index of color in palette
        } quickStartScene1;
        struct {
            DRCImagePalette palette;
            uint8_t pixelIndex[85][854]; // index of color in palette
        } quickStartScene2;
        struct {
            DRCImagePalette palette; // this is actually unused. The quick start menu uses the button color palette for the main image as well.
            uint8_t pixel[400][854]; // index of color in (button) palette
        } killerNotificationMain;
        struct {
            DRCImagePalette palette;
            uint8_t pixelIndex[160][487]; // index of color in palette
        } killerNotificationButton;
    };
    WUT_CHECK_SIZE(TransferableInfo, 0xc1934);
    WUT_CHECK_OFFSET(TransferableInfo, 0x00, numAccounts);
    WUT_CHECK_OFFSET(TransferableInfo, 0x01, defaultAccountIndex);
    WUT_CHECK_OFFSET(TransferableInfo, 0x02, uuids);
    WUT_CHECK_OFFSET(TransferableInfo, 0xC2, isNetworkAccount);
    WUT_CHECK_OFFSET(TransferableInfo, 0xCE, isPasswordCacheEnabled);
    WUT_CHECK_OFFSET(TransferableInfo, 0xda, titleIds);
    WUT_CHECK_OFFSET(TransferableInfo, 0x12a, isOnDisc);
    WUT_CHECK_OFFSET(TransferableInfo, 0x134, killerNotificationsTitleId);
    WUT_CHECK_OFFSET(TransferableInfo, 0x13C, serialId);
    WUT_CHECK_OFFSET(TransferableInfo, 0x200, accountSceneImage);
    WUT_CHECK_OFFSET(TransferableInfo, 0x15188, quickStartScene1);
    WUT_CHECK_OFFSET(TransferableInfo, 0x48ae6, quickStartScene2);
    WUT_CHECK_OFFSET(TransferableInfo, 0x5aa74, killerNotificationMain);
    WUT_CHECK_OFFSET(TransferableInfo, 0xae4d4, killerNotificationButton);
 
    struct WUT_PACKED TitleInfo {
        uint64_t titleId;
        MCPAppType appType;
        MediaType mediaType;
        WUT_UNKNOWN_BYTES(0x10);
    };
    WUT_CHECK_SIZE(TitleInfo, 0x20);
    WUT_CHECK_OFFSET(TitleInfo, 0x00, titleId);
    WUT_CHECK_OFFSET(TitleInfo, 0x08, appType);
    WUT_CHECK_OFFSET(TitleInfo, 0x0C, mediaType);
 
    struct WUT_PACKED TitleMetaInfo {
        bool isPreOrder;
        WUT_PADDING_BYTES(3);
    };
    WUT_CHECK_SIZE(TitleMetaInfo, 0x4);
    WUT_CHECK_OFFSET(TitleMetaInfo, 0x00, isPreOrder);
 
    struct WUT_PACKED WhiteList {
        MCPAppType titleTypes[50];
        uint32_t titleTypeCount;
        WUT_PADDING_BYTES(4);
        uint64_t titleIds[50];
        uint32_t titleIdCount;
    };
    WUT_CHECK_SIZE(WhiteList, 0x264);
    WUT_CHECK_OFFSET(WhiteList, 0x00, titleTypes);
    WUT_CHECK_OFFSET(WhiteList, 0xC8, titleTypeCount);
    WUT_CHECK_OFFSET(WhiteList, 0xD0, titleIds);
    WUT_CHECK_OFFSET(WhiteList, 0x260, titleIdCount);
 
    struct WUT_PACKED Account {
        char uuid[0x10];
        uint32_t isNetworkAccount;
        uint8_t isPasswordCacheEnabled;
        uint8_t age;
        WUT_PADDING_BYTES(2);
        uint32_t gender;
        uint32_t simpleAddressId;
        uint8_t isMailAddressValidated;
        WUT_PADDING_BYTES(1);
        uint16_t bday_year;
        uint8_t bday_month;
        uint8_t bday_day;
        WUT_PADDING_BYTES(2);
    };
    WUT_CHECK_SIZE(Account, 0x28);
    WUT_CHECK_OFFSET(Account, 0x00, uuid);
    WUT_CHECK_OFFSET(Account, 0x10, isNetworkAccount);
    WUT_CHECK_OFFSET(Account, 0x14, isPasswordCacheEnabled);
    WUT_CHECK_OFFSET(Account, 0x15, age);
    WUT_CHECK_OFFSET(Account, 0x18, gender);
    WUT_CHECK_OFFSET(Account, 0x1C, simpleAddressId);
    WUT_CHECK_OFFSET(Account, 0x20, isMailAddressValidated);
    WUT_CHECK_OFFSET(Account, 0x22, bday_year);
    WUT_CHECK_OFFSET(Account, 0x24, bday_month);
    WUT_CHECK_OFFSET(Account, 0x25, bday_day);
 
    struct WUT_PACKED AccountInfo {
        uint8_t account_index[12];
        WUT_UNKNOWN_BYTES(4);
        uint32_t num_of_accounts;
        Account accounts[12];
    };
    WUT_CHECK_SIZE(AccountInfo, 0x1f4);
    WUT_CHECK_OFFSET(AccountInfo, 0, account_index);
    WUT_CHECK_OFFSET(AccountInfo, 0x10, num_of_accounts);
    WUT_CHECK_OFFSET(AccountInfo, 0x14, accounts);
 
    struct WUT_PACKED Setting {
        struct {
            bool enabled;
            bool pushEnabled;
            bool adEnabled;
            bool drcLedEnable;
            uint16_t pushInterval;
            WUT_PADDING_BYTES(2);
            uint32_t pushTimeSlot;
        } caffeine;
        bool pushAutoDelivery;
        WUT_PADDING_BYTES(3);
        uint32_t edmStandbyModeLength;
        uint32_t language;
        uint32_t prodArea;
    };
    WUT_CHECK_SIZE(Setting, 0x1C);
    WUT_CHECK_OFFSET(Setting, 0x0, caffeine.enabled);
    WUT_CHECK_OFFSET(Setting, 0x01, caffeine.pushEnabled);
    WUT_CHECK_OFFSET(Setting, 0x02, caffeine.adEnabled);
    WUT_CHECK_OFFSET(Setting, 0x03, caffeine.drcLedEnable);
    WUT_CHECK_OFFSET(Setting, 0x04, caffeine.pushInterval);
    WUT_CHECK_OFFSET(Setting, 0x08, caffeine.pushTimeSlot);
    WUT_CHECK_OFFSET(Setting, 0x0C, pushAutoDelivery);
    WUT_CHECK_OFFSET(Setting, 0x10, edmStandbyModeLength);
    WUT_CHECK_OFFSET(Setting, 0x14, language);
    WUT_CHECK_OFFSET(Setting, 0x18, prodArea);
 
    struct KillerNotificationTransferRecord {
        WUT_UNKNOWN_BYTES(0x18);
    };
    WUT_CHECK_SIZE(KillerNotificationTransferRecord, 0x18);
 
    typedef enum Region {
        REGION_JPN = 0,
        REGION_USA = 1,
        REGION_EUR = 2
    } Region;
 
    enum TransferMode {
        TRANSFER_MODE_UNKWN_1 = 1,
        TRANSFER_MODE_UNKWN_2 = 2,
        TRANSFER_MODE_UNKWN_3 = 3,
    };
 
    enum Language {
        Japanese           = 0,
        English            = 1,
        French             = 2,
        German             = 3,
        Italian            = 4,
        Spanish            = 5,
        SimplifiedChinese  = 6,
        Korean             = 7,
        Dutch              = 8,
        Portuguese         = 9,
        Russian            = 10,
        TraditionalChinese = 11,
    };
 
    enum SeekOrigin {
        SeekSet = 0
    };
 
    void
    GetDefaultDatabasePath(char *, int size, uint64_t titleId) asm("GetDefaultDatabasePath__Q2_2nn2slFPcUiUL");
 
    void
    GetDefaultDatabasePath(char *, int size) asm("GetDefaultDatabasePath__Q2_2nn2slFPcUi");
 
    void
    GetDefaultKillerNotificationTransferRecordPath(char *, int size, uint64_t titleId, const char *) asm("GetDefaultKillerNotificationTransferRecordPath__Q2_2nn2slFPcUiUL");
 
    void Initialize(MEMAllocFromDefaultHeapExFn, MEMFreeToDefaultHeapFn) asm("Initialize__Q2_2nn2slFPFUiT1_PvPFPv_v");
 
    void
    Finalize() asm("Finalize__Q2_2nn2slFv");
 
    void
    FinalizeForEcoProcess() asm("FinalizeForEcoProcess__Q2_2nn2slFv");
 
    void
    InitializeForEcoProcess(MEMAllocFromDefaultHeapExFn allocFn, MEMFreeToDefaultHeapFn freeFn) asm("InitializeForEcoProcess__Q2_2nn2slFPFUiT1_PvPFPv_v");
 
}; // namespace nn::sl
 
#endif