dusklight/src/JSystem/JUtility/JUTCacheFont.cpp

#include "JSystem/JSystem.h" // IWYU pragma: keep

#include "JSystem/JUtility/JUTCacheFont.h"
#include "JSystem/JUtility/JUTException.h"
#include "JSystem/JUtility/JUTAssert.h"
#include "JSystem/JUtility/JUTConsole.h"
#include "JSystem/JKernel/JKRAram.h"
#include <dolphin/gx.h>
#include <stdint.h>

JUTCacheFont::JUTCacheFont(ResFONT const* p_fontRes, u32 cacheSize, JKRHeap* p_heap) {
    initialize_state();
    JUTResFont::initialize_state();
    JUTFont::initialize_state();
    initiate(p_fontRes, NULL, cacheSize, p_heap);
}

JUTCacheFont::~JUTCacheFont() {
    if (mValid) {
        delete_and_initialize();
        JUTResFont::delete_and_initialize();

        JUTFont::initialize_state();
    }
}

void JUTCacheFont::deleteMemBlocks_CacheFont() {
    if (field_0xb0 != 0) {
        delete[] mCacheBuffer;
    }

    JKRFreeToAram(field_0xac);
    delete mInf1Ptr;
    delete mMemBlocks;
    delete field_0x7c;
    delete field_0x80;
    delete field_0x84;
}

void JUTCacheFont::initialize_state() {
    field_0xb0 = 0;
    mCacheBuffer = NULL;

    field_0xac = NULL;
    mInf1Ptr = NULL;
    field_0x7c = NULL;
    field_0x80 = NULL;
    field_0x84 = NULL;
    mMemBlocks = NULL;

    mPagingType = PAGE_TYPE_0;
    mMaxSheetSize = 0;

    mCacheBuffer = NULL;
    field_0x9c = NULL;
    field_0xa0 = NULL;
}

int JUTCacheFont::getMemorySize(ResFONT const* p_font, u16* o_widCount, u32* o_widSize,
                                u16* o_glyCount, u32* o_glySize, u16* o_mapCount, u32* o_mapSize,
                                u32* o_glyTexSize) {
    if (p_font == NULL) {
        return 0;
    }

    u16 widBlockCount = 0;
    u16 glyBlockCount = 0;
    u16 mapBlockCount = 0;
    u32 totalWidSize = 0;
    u32 totalGlySize = 0;
    u32 totalMapSize = 0;
    u32 maxGlyTexSize = 0;
    u32 glyTexSize;

    u8* fontInf = (u8*)p_font->data;
    for (int i = 0; i < (int)p_font->numBlocks; i++) {
        u32 blkMagic = ((BlockHeader*)fontInf)->magic;
        u32 blkSize  = ((BlockHeader*)fontInf)->size;
        switch (blkMagic) {
        case 'INF1':
            break;
        case 'WID1':
            totalWidSize += blkSize;
            widBlockCount++;
            break;
        case 'GLY1':
            totalGlySize += blkSize;
            glyTexSize = ((ResFONT::GLY1*)fontInf)->textureSize;
            glyBlockCount++;
            if (glyTexSize > maxGlyTexSize) {
                maxGlyTexSize = glyTexSize;
            }
            break;
        case 'MAP1':
            totalMapSize += blkSize;
            mapBlockCount++;
            break;
        default:
            JUTReportConsole("JUTCacheFont: Unknown data block\n");
            break;
        }

        fontInf += blkSize;
    }

    if (o_widCount != NULL) {
        *o_widCount = widBlockCount;
    }

    if (o_glyCount != NULL) {
        *o_glyCount = glyBlockCount;
    }

    if (o_mapCount != NULL) {
        *o_mapCount = mapBlockCount;
    }

    if (o_widSize != NULL) {
        *o_widSize = totalWidSize;
    }

    if (o_glySize != NULL) {
        *o_glySize = totalGlySize;
    }

    if (o_mapSize != NULL) {
        *o_mapSize = totalMapSize;
    }

    if (o_glyTexSize != NULL) {
        *o_glyTexSize = maxGlyTexSize;
    }

    return 1;
}

int JUTCacheFont::initiate(ResFONT const* p_fontRes, void* param_1, u32 param_2, JKRHeap* p_heap) {
    if (!internal_initiate(p_fontRes, param_1, param_2, p_heap)) {
        deleteMemBlocks_CacheFont();
        deleteMemBlocks_ResFont();
        JUTFont::initialize_state();
        mValid = false;
        return 0;
    }

    return 1;
}

bool JUTCacheFont::internal_initiate(ResFONT const* p_fontRes, void* param_1, u32 param_2,
                                     JKRHeap* param_3) {
    delete_and_initialize();
    JUTResFont::delete_and_initialize();
    JUTFont::initialize_state();

    if (p_fontRes == NULL) {
        return false;
    }

    mResFont = p_fontRes;
    mValid = true;
    getMemorySize(p_fontRes, &mWid1BlockNum, &mTotalWidSize, &mGly1BlockNum, &mTotalGlySize,
                  &mMap1BlockNum, &mTotalMapSize, &mMaxSheetSize);

    if (!allocArea(param_1, param_2, param_3)) {
        return false;
    } else if (!allocArray(param_3)) {
        return false;
    }

    setBlock();
    return true;
}

bool JUTCacheFont::allocArea(void* cacheBuffer, u32 param_1, JKRHeap* heap) {
    mInf1Ptr = (ResFONT::INF1*)new (heap, 0) ResFONT();
    if (mInf1Ptr == NULL) {
        return false;
    }

    if (mTotalWidSize != 0) {
        field_0x7c = new (heap, 0) u8[mTotalWidSize];
        if (field_0x7c == NULL) {
            return false;
        }
    }

    if (mGly1BlockNum != 0) {
        field_0x80 = new (heap, 0) ResFONT::GLY1[mGly1BlockNum];
        if (field_0x80 == NULL) {
            return false;
        }

        field_0xac = JKRAllocFromAram(mTotalGlySize - (mGly1BlockNum * sizeof(ResFONT::GLY1)), JKRAramHeap::HEAD);
        if (field_0xac == NULL) {
            return false;
        }
    }

    if (mTotalMapSize != 0) {
        field_0x84 = new (heap, 0) u8[mTotalMapSize];
        if (field_0x84 == NULL) {
            return false;
        }
    }

    field_0x94 = mMaxSheetSize + 0x40;
    mCachePage = param_1 / field_0x94;
    u32 v1 = field_0x94 * mCachePage;
    if (mCachePage == 0) {
        return false;
    }

    if (cacheBuffer != NULL) {
        JUT_ASSERT(352, ( (uintptr_t)cacheBuffer & 0x1f ) == 0);
        mCacheBuffer = cacheBuffer;
        field_0xb0 = 0;
    } else {
        mCacheBuffer = new (heap, 0x20) u8[v1];
        if (mCacheBuffer == NULL) {
            return false;
        }
        field_0xb0 = 1;
    }

    invalidiateAllCache();
    return true;
}

bool JUTCacheFont::allocArray(JKRHeap* param_0) {
    mMemBlocks = (void**)new (param_0, 0) u32[mWid1BlockNum + mGly1BlockNum + mMap1BlockNum];
    if (mMemBlocks == NULL) {
        return false;
    }

    void** blocks = mMemBlocks;
    if (mWid1BlockNum) {
        mpWidthBlocks = new (blocks) ResFONT::WID1*[mWid1BlockNum];
        blocks = blocks + mWid1BlockNum;
    }
    if (mGly1BlockNum) {
        mpGlyphBlocks = new (blocks) ResFONT::GLY1*[mGly1BlockNum];
        blocks = blocks + mGly1BlockNum;
        for (int i = 0; i < mGly1BlockNum; i++) {
            mpGlyphBlocks[i] = (ResFONT::GLY1*)((u8*)mCacheBuffer + (field_0x94 * i));
        }
    }
    if (mMap1BlockNum) {
        mpMapBlocks = new (blocks) ResFONT::MAP1*[mMap1BlockNum];
    }
    return true;
}

void JUTCacheFont::setBlock() {
    int widthNum = 0;
    int gylphNum = 0;
    int mapNum = 0;
    u8* pWidth = (u8*)field_0x7c;
    ResFONT::GLY1* piVar5 = (ResFONT::GLY1*)field_0x80;
    ResFONT::MAP1* pMap = (ResFONT::MAP1*)field_0x84;
    u32 aramAddress = field_0xac->getAddress();
    mMaxCode = 0xffff;
    const u8* pData = (const u8*)mResFont->data;

    for (int i = 0; i < (int)mResFont->numBlocks; i++) {
        u32 blkMagic = ((BlockHeader*)pData)->magic;
        u32 blkSize  = ((BlockHeader*)pData)->size;
        u32 u;
        switch (blkMagic) {
        case 'INF1':
            memcpy(mInf1Ptr, pData, 0x20);
            u = mInf1Ptr->fontType;
            JUT_ASSERT(448, u < suAboutEncoding_);
            mIsLeadByte = &JUTResFont::saoAboutEncoding_[u];
            break;
        case 'WID1':
            memcpy(pWidth, pData, blkSize);
            mpWidthBlocks[widthNum] = (ResFONT::WID1*)pWidth;
            widthNum++;
            pWidth += blkSize;
            break;
        case 'GLY1': {
            memcpy(piVar5, pData, 0x20);
            JKRAramBlock* iVar1;
            iVar1 = JKRMainRamToAram((u8*)pData + 0x20, aramAddress, blkSize - 0x20,
                                     EXPAND_SWITCH_UNKNOWN0, 0, NULL, 0xffffffff, NULL);
            if (iVar1 == NULL) {
                JUTException::panic("JUTCacheFont.cpp", 0x1dd,
                                    "trouble occurred in JKRMainRamToAram.");
            }
            piVar5->magic = aramAddress;
            if (piVar5->textureSize > mMaxSheetSize) {
                mMaxSheetSize = piVar5->textureSize;
            }
            mpGlyphBlocks[gylphNum] = piVar5;
            gylphNum++;
            piVar5++;
            aramAddress += blkSize - 0x20;
            break;
        }
        case 'MAP1':
            memcpy(pMap, pData, blkSize);
            mpMapBlocks[mapNum] = pMap;
            if (mMaxCode > mpMapBlocks[mapNum]->startCode) {
                mMaxCode = mpMapBlocks[mapNum]->startCode;
            }
            mapNum++;
            pMap = (ResFONT::MAP1*)((u8*)pMap + blkSize);
            break;
        default:
            JUTReportConsole("Unknown data block\n");
            break;
        }

        pData = pData + blkSize;
    }
}

JUTCacheFont::TGlyphCacheInfo* JUTCacheFont::determineBlankPage() {
    TGlyphCacheInfo* pVar1;
    if (field_0xa4 != NULL) {
        pVar1 = field_0xa4;
        field_0xa4 = pVar1->mNext;
        if (pVar1->mNext == NULL) {
            field_0xa8 = 0;
        } else {
            pVar1->mNext->mPrev = NULL;
        }
        return pVar1;
    }

    pVar1 = field_0xa0;
    while (pVar1 != NULL) {
        TGlyphCacheInfo* prev = pVar1->mPrev;
        if (pVar1->field_0x1e == 0) {
            unlink(pVar1);
            field_0xb4++;
            return pVar1;
        }
        pVar1 = prev;
    }

    return NULL;
}

void JUTCacheFont::getGlyphFromAram(JUTCacheFont::TGlyphCacheInfo* param_0,
                                    JUTCacheFont::TCachePage* pCachePage, int* param_2, int* param_3) {
    TGlyphCacheInfo* pGylphCacheInfo = pCachePage;
    int* r30 = param_2;
    memcpy(pGylphCacheInfo, param_0, sizeof(TGlyphCacheInfo));
    prepend(pGylphCacheInfo);
    int iVar3 = pGylphCacheInfo->field_0x16 * pGylphCacheInfo->field_0x18;
    int iVar2 = *r30 / iVar3;
    pGylphCacheInfo->field_0x8 += iVar2 * iVar3;
    u16 local_30 = pGylphCacheInfo->field_0x8 + iVar3 - 1;
    pGylphCacheInfo->field_0xa = pGylphCacheInfo->field_0xa < local_30 ? pGylphCacheInfo->field_0xa : local_30;
    *param_3 = iVar2;
    *r30 -= iVar2 * iVar3;
    u8* result =
        JKRAramToMainRam((uintptr_t) param_0->mPrev + pGylphCacheInfo->field_0x10 * iVar2, pCachePage->mImage, pGylphCacheInfo->field_0x10, EXPAND_SWITCH_UNKNOWN0, 0, NULL, 0xffffffff, NULL);
    JUT_ASSERT(624, result);
    GXInitTexObj(&pCachePage->mTexObj, pCachePage->mImage, pGylphCacheInfo->mWidth, pGylphCacheInfo->mHeight,
                 (GXTexFmt)pGylphCacheInfo->mTexFormat, GX_CLAMP, GX_CLAMP, GX_FALSE);
    GXInitTexObjLOD(&pCachePage->mTexObj, GX_LINEAR, GX_LINEAR, 0.0f, 0.0f, 0.0f, GX_FALSE, GX_FALSE,
                    GX_ANISO_1);
}

void JUTCacheFont::loadImage(int param_0, _GXTexMapID texMapId) {
    TCachePage* cachePage = loadCache_char_subroutine(&param_0, false);
    if (cachePage != NULL) {
        mWidth = cachePage->field_0xc * (param_0 % (int)cachePage->field_0x16);
        mHeight = cachePage->field_0xe * (param_0 / cachePage->field_0x16);
        GXLoadTexObj(getTexObj(cachePage), texMapId);
        if (mPagingType == PAGE_TYPE_1) {
            unlink(cachePage);
            prepend(cachePage);
        }
    }
}

JUTCacheFont::TCachePage* JUTCacheFont::loadCache_char_subroutine(int* param_0, bool param_1) {
    TCachePage* rv = NULL;
    int* r29 = param_0;
    for (TCachePage* pCachePage = (TCachePage*)field_0x9c; pCachePage != NULL;
         pCachePage = (TCachePage*)pCachePage->mNext)
    {
        if (pCachePage->field_0x8 <= *r29 && *r29 <= pCachePage->field_0xa) {
            rv = pCachePage;
            *r29 -= pCachePage->field_0x8;
            break;
        }
    }

    if (rv == NULL) {
        rv = NULL;
        int i = 0;
        for (; i < mGly1BlockNum; i++) {
            if (mpGlyphBlocks[i]->startCode <= *r29 && *r29 <= mpGlyphBlocks[i]->endCode) {
                *r29 -= mpGlyphBlocks[i]->startCode;
                break;
            }
        }
        if (i < mGly1BlockNum) {
            TCachePage* pBlankPage = (TCachePage*)determineBlankPage();
            if (pBlankPage == NULL) {
                return NULL;
            }
            int texPageIdx;
            getGlyphFromAram((JUTCacheFont::TGlyphCacheInfo*)mpGlyphBlocks[i], pBlankPage, r29,
                             &texPageIdx);
            mTexPageIdx = texPageIdx;
            field_0x66 = i;
            rv = pBlankPage;
        } else {
            return NULL;
        }
    }
    if (param_1) {
        rv->field_0x1e = 1;
    }
    return rv;
}

void JUTCacheFont::invalidiateAllCache() {
    int* cacheBuffer = (int*)mCacheBuffer;
    for (int i = 0; i < mCachePage; i++) {
        *cacheBuffer = i == 0 ? 0 : (intptr_t)cacheBuffer - field_0x94;
        cacheBuffer[1] = i == mCachePage - 1 ? 0 : (intptr_t)cacheBuffer + field_0x94;
        cacheBuffer = (int*)((intptr_t)cacheBuffer + field_0x94);
    }
    field_0xa8 = (intptr_t)cacheBuffer - field_0x94;
    field_0xa4 = (TGlyphCacheInfo*)mCacheBuffer;
    field_0x9c = NULL;
    field_0xa0 = NULL;
}

void JUTCacheFont::unlink(JUTCacheFont::TGlyphCacheInfo* cacheInfo) {
    if (cacheInfo->mPrev == NULL) {
        field_0x9c = cacheInfo->mNext;
    } else {
        cacheInfo->mPrev->mNext = cacheInfo->mNext;
    }

    if (cacheInfo->mNext == NULL) {
        field_0xa0 = cacheInfo->mPrev;
    } else {
        cacheInfo->mNext->mPrev = cacheInfo->mPrev;
    }
}

void JUTCacheFont::prepend(JUTCacheFont::TGlyphCacheInfo* cacheInfo) {
    TGlyphCacheInfo* oldHead = field_0x9c;
    field_0x9c = cacheInfo;
    cacheInfo->mPrev = NULL;
    cacheInfo->mNext = oldHead;

    if (oldHead == NULL) {
        field_0xa0 = cacheInfo;
    } else {
        oldHead->mPrev = cacheInfo;
    }
}

ResFONT* JUTResFont::getResFont() const {
    return (ResFONT*)mResFont;
}

int JUTResFont::getFontType() const {
    return mInf1Ptr->fontType;
}

int JUTResFont::getLeading() const {
    return mInf1Ptr->leading;
}

s32 JUTResFont::getWidth() const {
    return mInf1Ptr->width;
}

s32 JUTResFont::getAscent() const {
    return mInf1Ptr->ascent;
}

s32 JUTResFont::getDescent() const {
    return mInf1Ptr->descent;
}

s32 JUTResFont::getHeight() const {
    return getAscent() + getDescent();
}