ac-decomp/include/JSystem/JUtility/JUTFont.h

#ifndef JUTFONT_H
#define JUTFONT_H

#include "types.h"
#include "dolphin/string.h"
#include "dolphin/gx.h"
#include "dolphin/os.h"
#include "JSystem/JUtility/TColor.h"

#ifdef __cplusplus
struct JKRAramBlock;
struct JKRHeap;

struct ResFONT;

struct JUTFont
{
    typedef bool (*IsLeadByte)(int);

    struct TWidth
    {
        u8 w0;
        u8 w1;

        const TWidth &operator=(const TWidth &other)
        {
            w0 = other.w0;
            w1 = other.w1;
            return *this;
        }
    };

    JUTFont();

    virtual ~JUTFont() {}                                                // _08
    virtual void setGX() = 0;                                            // _0C
    virtual void setGX(JUtility::TColor, JUtility::TColor) { setGX(); }; // _10
    virtual f32 drawChar_scale(f32, f32, f32, f32, int, bool) = 0;       // _14
    virtual int getLeading() const = 0;                                  // _18
    virtual int getAscent() const = 0;                                   // _1C
    virtual int getDescent() const = 0;                                  // _20
    virtual int getHeight() const = 0;                                   // _24
    virtual int getWidth() const = 0;                                    // _28
    virtual void getWidthEntry(int, JUTFont::TWidth *) const = 0;        // _2C
    virtual int getCellWidth() const { return getWidth(); };             // _30
    virtual int getCellHeight() const { return getHeight(); };           // _34
    virtual int getFontType() const = 0;                                 // _38
    virtual const ResFONT *getResFont() const = 0;                       // _3C
    virtual bool isLeadByte(int) const = 0;                              // _40

    void initialize_state();
    void setCharColor(JUtility::TColor);
    void setGradColor(JUtility::TColor, JUtility::TColor);
    f32 drawString_size_scale(f32, f32, f32, f32, const char *, u32, bool);

    void drawString(int posX, int posY, const char *str, bool visible) { drawString_size(posX, posY, str, strlen(str), visible); }

    void drawString_size(int posX, int posY, const char *str, u32 len, bool visible)
    {
        drawString_size_scale(posX, posY, getWidth(), getHeight(), str, len, visible);
    }

    void drawString_scale(f32 posX, f32 posY, f32 width, f32 height, const char *str, bool visible)
    {
        drawString_size_scale(posX, posY, width, height, str, strlen(str), visible);
    }

    int getWidth(int i_no) const
    {
        TWidth width;
        getWidthEntry(i_no, &width);
        return width.w0;
    }

    void setFixedWidth(bool fixed, int width) {
        mFixed = fixed;
        mFixedWidth = width;
    }

    bool isValid() const { return mValid; }

    static bool isLeadByte_1Byte(int c) { return false; }
    static bool isLeadByte_2Byte(int c) { return true; }
    static bool isLeadByte_ShiftJIS(int c)
    {
        return ((c >= 0x81) && (c <= 0x9F)) || ((c >= 0xE0) && (c <= 0xFC));
    }

    // _00 = VTBL
    bool mValid;            // _04
    bool mFixed;            // _05
    int mFixedWidth;          // _08
    JUtility::TColor mColor1; // _0C, bottom left
    JUtility::TColor mColor2; // _10, bottom right
    JUtility::TColor mColor3; // _14, top left
    JUtility::TColor mColor4; // _18, top right
};

struct JUTRomFont : public JUTFont
{
    // @fabricatedName
    struct AboutEncoding
    {
        u32 mFontType;                  // _00
        u32 mDataSize;                  // _04
        IsLeadByte mIsLeadByteFunction; // _08
    };

    JUTRomFont();
    JUTRomFont(JKRHeap *);

    virtual ~JUTRomFont();                                                   // _08
    virtual void setGX();                                                    // _0C
    virtual f32 drawChar_scale(f32, f32, f32, f32, int, bool);               // _14
    virtual int getWidth() const { return spFontHeader_->width; };           // _28
    virtual int getLeading() const { return spFontHeader_->leading; };       // _18
    virtual int getAscent() const { return spFontHeader_->ascent; };         // _1C
    virtual int getDescent() const { return spFontHeader_->descent; };       // _20
    virtual int getHeight() const { return getAscent() + getDescent(); };    // _24
    virtual void getWidthEntry(int, JUTFont::TWidth *) const;                // _2C
    virtual int getCellWidth() const { return spFontHeader_->cellWidth; };   // _30
    virtual int getCellHeight() const { return spFontHeader_->cellHeight; }; // _34
    virtual ResFONT *getResFont() const { return nullptr; };                 // _3C
    virtual int getFontType() const { return spAboutEncoding_->mFontType; }; // _38
    virtual bool isLeadByte(int) const;                                      // _40

    void initiate(JKRHeap *);
    void loadImage(JKRHeap *);

    static AboutEncoding *spAboutEncoding_;
    static OSFontHeader *spFontHeader_;
    static u32 suFontHeaderRefered_; // they misspelled referred
    static AboutEncoding saoAboutEncoding_[2];

    // _00     = VTBL
    // _00-_1C = JUTFont
};

struct BlockHeader
{
    const BlockHeader *getNext() const { return reinterpret_cast<const BlockHeader *>(reinterpret_cast<const u8 *>(this) + this->mSize); }
    inline static void advance(const BlockHeader **iterator)
    {
        *iterator = reinterpret_cast<const BlockHeader *>(reinterpret_cast<const u8 *>(*iterator) + (*iterator)->mSize);
    }

    u32 mMagic; // _00
    u32 mSize;  // _04
};

struct ResFONT
{
    // INF1, size: 0x14
    struct InfoBlock : public BlockHeader
    {
        // _00 = BlockHeader
        u16 mFontType;    // _08
        u16 mAscent;      // _0A
        u16 mDescent;     // _0C
        u16 mWidth;       // _0E
        u16 mLeading;     // _10
        u16 mDefaultCode; // _12
    };

    // WID1, size: 0x10
    struct WidthBlock : public BlockHeader
    {
        // _00 = BlockHeader
        u16 mStartCode;               // _08
        u16 mEndCode;                 // _0A
        JUTFont::TWidth mChunkNum[2]; // _0C
    };

    // MAP1, size: 0x14
    struct MapBlock : public BlockHeader
    {
        // _00 = BlockHeader
        u16 mMappingMethod; // _08
        u16 mStartCode;     // _0A
        u16 mEndCode;       // _0C
        u16 mNumEntries;    // _0E
        u16 mLeading;       // _10
    };

    // GLY1, size: 0x20
    struct GlyphBlock : public BlockHeader
    {
        // _00 = BlockHeader
        u16 mStartCode;     // _08
        u16 mEndCode;       // _0A
        u16 mCellWidth;     // _0C
        u16 mCellHeight;    // _0E
        u32 mTextureSize;   // _10
        u16 mTextureFormat; // _14
        u16 mNumRows;       // _16
        u16 mNumColumns;    // _18
        u16 mTextureWidth;  // _1A
        u16 mTextureHeight; // _1C
        u16 mPadding;       // _1E
        u8 mData[];         // _20
    };

    u64 mMagic;        // _00
    u32 mFileSize;     // _08
    u32 mNumBlocks;    // _0C
    u8 mPadding[0x10]; // _10
    u8 mData[];        // _20
};

/**
 * @size{0x70}
 */
struct JUTResFont : public JUTFont
{
    JUTResFont();
    JUTResFont(const ResFONT *, JKRHeap *);

    virtual ~JUTResFont();                                                // _08
    virtual void setGX();                                                 // _0C
    virtual void setGX(JUtility::TColor, JUtility::TColor);               // _10
    virtual f32 drawChar_scale(f32, f32, f32, f32, int, bool);            // _14
    virtual int getDescent() const { return mInfoBlock->mDescent; };      // _20
    virtual int getHeight() const { return getAscent() + getDescent(); }; // _24
    virtual int getAscent() const { return mInfoBlock->mAscent; };        // _1C
    virtual int getWidth() const { return mInfoBlock->mWidth; };          // _28
    virtual void getWidthEntry(int, JUTFont::TWidth *) const;             // _2C
    virtual int getCellWidth() const;                                     // _30
    virtual int getCellHeight() const;                                    // _34
    virtual int getFontType() const { return mInfoBlock->mFontType; };    // _38
    virtual const ResFONT *getResFont() const { return mResource; };      // _3C
    virtual int getLeading() const { return mInfoBlock->mLeading; };      // _18
    virtual bool isLeadByte(int) const;                                   // _40
    virtual void loadImage(int, GXTexMapID);                              // _44
    virtual void setBlock();                                              // _48

    int convertSjis(int, u16 *) const;
    void countBlock();
    void deleteMemBlocks_ResFont();
    int getFontCode(int) const;
    void initialize_state();
    bool initiate(const ResFONT *, JKRHeap *);
    void loadFont(int, GXTexMapID, TWidth *);
    bool protected_initiate(const ResFONT *, JKRHeap *);

    inline void delete_and_initialize()
    {
        deleteMemBlocks_ResFont();
        initialize_state();
    }

    static IsLeadByte const saoAboutEncoding_[3];

    // _00     = VTBL
    // _00-_1C = JUTFont
    int mWidth;                         // _1C
    int mHeight;                        // _20
    GXTexObj _24;                       // _24
    int _44;                            // _44
    const ResFONT *mResource;           // _48
    ResFONT::InfoBlock *mInfoBlock;     // _4C, INF1
    void **mMemBlocks;                  // _50
    ResFONT::WidthBlock **mWidthBlocks; // _54, WID1
    ResFONT::GlyphBlock **mGlyphBlocks; // _58, GLY1
    ResFONT::MapBlock **mMapBlocks;     // _5C, MAP1
    u16 mWidthBlockCount;               // _60
    u16 mGlyphBlockCount;               // _62
    u16 mMapBlockCount;                 // _64
    u16 _66;                            // _66
    u16 mMaxCode;                       // _68
    IsLeadByte *mIsLeadByte;            // _6C
};

struct JUTCacheFont : public JUTResFont
{
    enum EPagingType
    {
        CFPAGETYPE_Unk0 = 0,
        CFPAGETYPE_Unk1 = 1,
    };

    struct TGlyphCacheInfo
    {
        // TODO: the rest of the data members
        TGlyphCacheInfo *mPrev; // _00
        TGlyphCacheInfo *mNext; // _04
        u8 _08[4];              // _08
        u16 _0C;                // _0C
        u16 _0E;                // _0E
        u8 _10[4];              // _10
        u16 _14;                // _14
        u16 _16;                // _16
        u8 _18[8];              // _18
        GXTexObj mGxTexObj;     // _20
    };

    struct TCachePage
    {
        u8 _00[0x8]; // _00, unknown
        s16 _08;     // _08
        u16 _0A;     // _0A
        u8 _0C[0x4]; // _0C, unknown
        u8 *_10;     // _10
        u16 _14;     // _14
        u16 _18;     // _18
        u16 _1C;     // _1C
        u16 _20;     // _20
        u16 _24;     // _24
        u16 _28;     // _28
    };

    JUTCacheFont();
    JUTCacheFont(const ResFONT *, void *, u32, JKRHeap *);
    JUTCacheFont(const ResFONT *, u32, JKRHeap *);

    virtual ~JUTCacheFont();                  // _08
    virtual void loadImage(int, _GXTexMapID); // _44
    virtual void setBlock();                  // _48

    bool allocArea(void *, u32, JKRHeap *);
    bool allocArray(JKRHeap *);
    void deleteMemBlocks_CacheFont();
    bool getMemorySize(const ResFONT *, u16 *, u32 *, u16 *, u32 *, u16 *, u32 *, u32 *);
    void initialize_state();
    bool initiate(const ResFONT *, void *, u32, JKRHeap *);
    bool internal_initiate(const ResFONT *, void *, u32, JKRHeap *);
    void invalidiateAllCache();
    TGlyphCacheInfo *loadCache_char_subroutine(int *, bool);
    void loadCache_string(const char *, bool);
    void prepend(TGlyphCacheInfo *);
    void unlink(TGlyphCacheInfo *);

    // Unused/inlined:
    void determineBlankPage();
    void getGlyphFromAram(TGlyphCacheInfo *, TCachePage *, int *, int *);
    void loadCache_char(int, bool);
    void loadCache_string_size(const char *, u32, bool);
    void unlockCache_all();
    void unlockCache_char(int);
    void unlockCache_string(const char *);
    void unlockCache_string_size(const char *, u32);

    void setPagingType(EPagingType type) { mPagingType = type; }

    static u32 calcCacheSize(u32 param_0, int param_1) { return (ALIGN_NEXT(param_0, 0x20) + 0x40) * param_1; }

    // _00     = VTBL
    // _00-_70 = JUTResFont
    u32 mWidthBlocksSize;     // _70
    u32 mGlyphBlocksSize;     // _74
    u32 mMapBlocksSize;       // _78
    void *_7C;                // _7C
    void *_80;                // _80
    void *_84;                // _84
    u32 mMaxSheetSize;        // _88
    EPagingType mPagingType;  // _8C
    void *mCacheBuffer;       // _90
    u32 _94;                  // _94
    u32 mCachePage;           // _98
    TGlyphCacheInfo *_9C;     // _9C
    TGlyphCacheInfo *_A0;     // _A0
    void *_A4;                // _A4
    u32 _A8;                  // _A8
    JKRAramBlock *mAramBlock; // _AC
    u8 _B0;                   // _B0
    int _B4;                  // _B4
};

extern const ResFONT JUTResFONT_Ascfont_fix12;
#endif

#endif