mirror/dusklight
1
0
Fork 0
mirror of https://github.com/TwilitRealm/dusklight synced 2026-05-23 22:45:05 -04:00
Code Issues Packages Projects Releases Wiki Activity
Files
29375d2b794656ee0bcdeada19dca87165bc7c60
dusklight/src/JSystem/JUtility/JUTCacheFont.cpp
T
PJB3005 29375d2b79 I apparently missed JUTCacheFont
2026-02-24 16:36:16 +01:00

491 lines
14 KiB
C++
Raw Blame History

#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, ( (u32)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((u32)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();
}
Reference in New Issue View Git Blame Copy Permalink