diff options
Diffstat (limited to 'arm9/src/gf_gfx_loader.c')
| -rw-r--r-- | arm9/src/gf_gfx_loader.c | 349 |
1 files changed, 349 insertions, 0 deletions
diff --git a/arm9/src/gf_gfx_loader.c b/arm9/src/gf_gfx_loader.c new file mode 100644 index 00000000..769c90d9 --- /dev/null +++ b/arm9/src/gf_gfx_loader.c @@ -0,0 +1,349 @@ +#include "global.h"
+#include "filesystem.h"
+#include "NNS_g2d.h"
+#include "gf_gfx_loader.h"
+
+THUMB_FUNC u32 GfGfxLoader_LoadCharData(NarcId narcId, s32 memberNo, struct UnkStruct_02016B94_2 * unkStruct02016B94_2, u32 a3, u32 a4, u32 szByte, BOOL isCompressed, u32 heap_id)
+{
+ NNSG2dCharacterData * pCharData;
+ void * pFile = GfGfxLoader_LoadFromNarc(narcId, memberNo, isCompressed, heap_id, FALSE);
+ if (pFile != NULL)
+ {
+ if (NNS_G2dGetUnpackedBGCharacterData(pFile, &pCharData))
+ {
+ if (szByte == 0)
+ szByte = pCharData->szByte;
+ FUN_02017E14(unkStruct02016B94_2, (u8)a3, pCharData->pRawData, szByte, a4);
+ }
+ FreeToHeap(pFile);
+ }
+ return szByte;
+}
+
+THUMB_FUNC void GfGfxLoader_LoadScrnData(NarcId narcId, s32 memberNo, struct UnkStruct_02016B94_2 * unkStruct02016B94_2, u32 a3, u32 a4, u32 szByte, BOOL isCompressed, u32 heap_id)
+{
+ NNSG2dScreenData * pScreenData;
+ void * pFile = GfGfxLoader_LoadFromNarc(narcId, memberNo, isCompressed, heap_id, TRUE);
+ if (pFile != NULL)
+ {
+ if (NNS_G2dGetUnpackedScreenData(pFile, &pScreenData))
+ {
+ if (szByte == 0)
+ szByte = pScreenData->szByte;
+ if (FUN_0201886C(unkStruct02016B94_2, (u8)a3) != NULL)
+ FUN_02017DFC(unkStruct02016B94_2, (u8)a3, pScreenData->rawData, szByte);
+ FUN_02017CE8(unkStruct02016B94_2, (u8)a3, pScreenData->rawData, szByte, a4);
+ }
+ FreeToHeap(pFile);
+ }
+}
+
+THUMB_FUNC void GfGfxLoader_GXLoadPal(NarcId narcId, s32 memberNo, u32 whichRoutine, u32 baseAddr, u32 szByte, u32 heap_id)
+{
+ GfGfxLoader_GXLoadPalWithSrcOffset(narcId, memberNo, whichRoutine, 0, baseAddr, szByte, heap_id);
+}
+
+THUMB_FUNC void GfGfxLoader_GXLoadPalWithSrcOffset(NarcId narcId, s32 memberNo, u32 whichRoutine, u32 srcOffset, u32 baseAddr, u32 szByte, u32 heap_id)
+{
+ static void (*const load_funcs[])(void *, u32, u32) = {
+ GX_LoadBGPltt,
+ GX_LoadOBJPltt,
+ GX_LoadBGExtPltt,
+ GX_LoadOBJExtPltt,
+ GXS_LoadBGPltt,
+ GXS_LoadOBJPltt,
+ GXS_LoadBGExtPltt,
+ GXS_LoadOBJExtPltt
+ };
+ NNSG2dPaletteData * pPltData;
+ void * pFile = GfGfxLoader_LoadFromNarc(narcId, memberNo, FALSE, heap_id, TRUE);
+ if (pFile != NULL)
+ {
+ if (NNS_G2dGetUnpackedPaletteData(pFile, &pPltData))
+ {
+ pPltData->pRawData = (void *)((u32)pPltData->pRawData + srcOffset);
+ if (szByte == 0)
+ szByte = pPltData->szByte - srcOffset;
+ DC_FlushRange(pPltData->pRawData, szByte);
+ switch (whichRoutine)
+ {
+ case 2:
+ GX_BeginLoadBGExtPltt();
+ load_funcs[whichRoutine](pPltData->pRawData, baseAddr, szByte);
+ GX_EndLoadBGExtPltt();
+ break;
+ case 6:
+ GXS_BeginLoadBGExtPltt();
+ load_funcs[whichRoutine](pPltData->pRawData, baseAddr, szByte);
+ GXS_EndLoadBGExtPltt();
+ break;
+ case 3:
+ GX_BeginLoadOBJExtPltt();
+ load_funcs[whichRoutine](pPltData->pRawData, baseAddr, szByte);
+ GX_EndLoadOBJExtPltt();
+ break;
+ case 7:
+ GXS_BeginLoadOBJExtPltt();
+ load_funcs[whichRoutine](pPltData->pRawData, baseAddr, szByte);
+ GXS_EndLoadOBJExtPltt();
+ break;
+ default:
+ load_funcs[whichRoutine](pPltData->pRawData, baseAddr, szByte);
+ break;
+ }
+ }
+ FreeToHeap(pFile);
+ }
+}
+
+THUMB_FUNC u32 GfGfxLoader_LoadWholePalette(NarcId narcId, s32 memberId, u32 whichRoutine, u32 baseAddr, u32 szByte, BOOL isCompressed, u32 heap_id)
+{
+ static void (*const load_funcs[])(void *, u32, u32) = {
+ GX_LoadOBJ,
+ GXS_LoadOBJ
+ };
+
+ NNSG2dCharacterData* pCharData;
+ void * pFile = GfGfxLoader_LoadFromNarc(narcId, memberId, isCompressed, heap_id, TRUE);
+ if (pFile != NULL)
+ {
+ if (NNS_G2dGetUnpackedCharacterData(pFile, &pCharData))
+ {
+ if (szByte == 0)
+ szByte = pCharData->szByte;
+ DC_FlushRange(pCharData->pRawData, szByte);
+ load_funcs[whichRoutine](pCharData->pRawData, baseAddr, szByte);
+ }
+ FreeToHeap(pFile);
+ }
+ return szByte;
+}
+
+THUMB_FUNC void GfGfxLoader_PartiallyLoadPalette(NarcId narcId, s32 memberId, NNS_G2D_VRAM_TYPE vramType, u32 baseAddr, u32 heap_id, NNSG2dImagePaletteProxy * pPltProxy)
+{
+ void * pFile = GfGfxLoader_LoadFromNarc(narcId, memberId, FALSE, heap_id, TRUE);
+ NNSG2dPaletteData* pPlttData;
+ NNSG2dPaletteCompressInfo* pCompressInfo;
+ if (pFile != NULL)
+ {
+ BOOL isCompressed = NNS_G2dGetUnpackedPaletteCompressInfo(pFile, &pCompressInfo);
+ if (NNS_G2dGetUnpackedPaletteData(pFile, &pPlttData))
+ {
+ if (isCompressed)
+ {
+ NNS_G2dLoadPaletteEx(pPlttData, pCompressInfo, baseAddr, vramType, pPltProxy);
+ }
+ else
+ {
+ NNS_G2dLoadPalette(pPlttData, baseAddr, vramType, pPltProxy);
+ }
+ }
+ FreeToHeap(pFile);
+ }
+}
+
+THUMB_FUNC u32 GfGfxLoader_LoadImageMapping(NarcId narcId, s32 memberId, BOOL isCompressed, u32 whichRoutine, u32 szByte, NNS_G2D_VRAM_TYPE type, u32 baseAddr, u32 heap_id, NNSG2dImageProxy *pImgProxy)
+{
+ static void (*const load_funcs[])(const NNSG2dCharacterData *, u32, NNS_G2D_VRAM_TYPE, NNSG2dImageProxy *) = {
+ NNS_G2dLoadImage1DMapping,
+ NNS_G2dLoadImage2DMapping
+ };
+
+ void * pFile = GfGfxLoader_LoadFromNarc(narcId, memberId, isCompressed, heap_id, TRUE);
+ u32 retSize = 0;
+ NNSG2dCharacterData * pSrcData;
+ if (pFile != NULL)
+ {
+ if (NNS_G2dGetUnpackedCharacterData(pFile, &pSrcData))
+ {
+ if (szByte != 0)
+ pSrcData->szByte = szByte;
+ load_funcs[whichRoutine](pSrcData, baseAddr, type, pImgProxy);
+ retSize = pSrcData->szByte;
+ }
+ FreeToHeap(pFile);
+ }
+ return retSize;
+}
+
+THUMB_FUNC void GfGfxLoader_SetObjCntFlagsAndLoadImageMapping(NarcId narcId, s32 memberId, BOOL isCompressed, u32 whichRoutine, u32 szByte, NNS_G2D_VRAM_TYPE type, u32 baseAddr, u32 heap_id, NNSG2dImageProxy * pImageProxy)
+{
+ static void (*const load_funcs[])(const NNSG2dCharacterData *, u32, NNS_G2D_VRAM_TYPE, NNSG2dImageProxy *) = {
+ NNS_G2dLoadImage1DMapping,
+ NNS_G2dLoadImage2DMapping
+ };
+ NNSG2dCharacterData * pCharacterData;
+ void * pFile = GfGfxLoader_LoadFromNarc(narcId, memberId, isCompressed, heap_id, TRUE);
+ if (pFile != NULL)
+ {
+ if (NNS_G2dGetUnpackedCharacterData(pFile, &pCharacterData))
+ {
+ if (szByte != 0)
+ pCharacterData->szByte = szByte;
+ switch (type)
+ {
+ case NNS_G2D_VRAM_TYPE_2DMAIN:
+ pCharacterData->mapingType = (GXOBJVRamModeChar)(reg_GX_DISPCNT & (REG_GX_DISPCNT_EXOBJ_CH_MASK | REG_GX_DISPCNT_OBJMAP_CH_MASK));
+ break;
+ case NNS_G2D_VRAM_TYPE_2DSUB:
+ pCharacterData->mapingType = (GXOBJVRamModeChar)(reg_GXS_DB_DISPCNT & (REG_GXS_DB_DISPCNT_EXOBJ_MASK | REG_GXS_DB_DISPCNT_OBJMAP_CH_MASK));
+ break;
+ default:
+ ;
+ }
+ load_funcs[whichRoutine](pCharacterData, baseAddr, type, pImageProxy);
+ }
+ FreeToHeap(pFile);
+ }
+}
+
+THUMB_FUNC void * GfGfxLoader_GetCharData(NarcId narcId, s32 memberId, BOOL isCompressed, NNSG2dCharacterData ** ppCharData, u32 heap_id)
+{
+ void * pFile = GfGfxLoader_LoadFromNarc(narcId, memberId, isCompressed, heap_id, FALSE);
+ if (pFile != NULL)
+ {
+ if (!NNS_G2dGetUnpackedBGCharacterData(pFile, ppCharData))
+ {
+ FreeToHeap(pFile);
+ return NULL;
+ }
+ }
+ return pFile;
+}
+
+THUMB_FUNC void * GfGfxLoader_GetScrnData(NarcId narcId, s32 memberId, BOOL isCompressed, NNSG2dScreenData ** ppScrData, u32 heap_id)
+{
+ void * pFile = GfGfxLoader_LoadFromNarc(narcId, memberId, isCompressed, heap_id, FALSE);
+ if (pFile != NULL)
+ {
+ if (!NNS_G2dGetUnpackedScreenData(pFile, ppScrData))
+ {
+ FreeToHeap(pFile);
+ return NULL;
+ }
+ }
+ return pFile;
+}
+
+THUMB_FUNC void * GfGfxLoader_GetPlttData(NarcId narcId, s32 memberId, NNSG2dPaletteData ** ppPltData, u32 heap_id)
+{
+ void * pFile = GfGfxLoader_LoadFromNarc(narcId, memberId, FALSE, heap_id, FALSE);
+ if (pFile != NULL)
+ {
+ if (!NNS_G2dGetUnpackedPaletteData(pFile, ppPltData))
+ {
+ FreeToHeap(pFile);
+ return NULL;
+ }
+ }
+ return pFile;
+}
+
+THUMB_FUNC void * GfGfxLoader_GetCellBank(NarcId narcId, s32 memberId, BOOL isCompressed, NNSG2dCellDataBank ** ppCellBank, u32 heap_id)
+{
+ void * pFile = GfGfxLoader_LoadFromNarc(narcId, memberId, isCompressed, heap_id, FALSE);
+ if (pFile != NULL)
+ {
+ if (!NNS_G2dGetUnpackedCellBank(pFile, ppCellBank))
+ {
+ FreeToHeap(pFile);
+ return NULL;
+ }
+ }
+ return pFile;
+}
+
+THUMB_FUNC void * GfGfxLoader_GetAnimBank(NarcId narcId, s32 memberId, BOOL isCompressed, NNSG2dAnimBankData ** ppAnimBank, u32 heap_id)
+{
+ void * pFile = GfGfxLoader_LoadFromNarc(narcId, memberId, isCompressed, heap_id, FALSE);
+ if (pFile != NULL)
+ {
+ if (!NNS_G2dGetUnpackedAnimBank(pFile, ppAnimBank))
+ {
+ FreeToHeap(pFile);
+ return NULL;
+ }
+ }
+ return pFile;
+}
+
+THUMB_FUNC void * GfGfxLoader_UncompressFromNarc(NarcId narcId, s32 memberId, u32 heap_id)
+{
+ return GfGfxLoader_LoadFromNarc(narcId, memberId, TRUE, heap_id, FALSE);
+}
+
+THUMB_FUNC void * GfGfxLoader_LoadFromNarc(NarcId narcId, s32 memberNo, BOOL isCompressed, u32 heap_id, BOOL allocAtEnd)
+{
+ void * dest;
+ void * dest2;
+ if (isCompressed || allocAtEnd == TRUE)
+ {
+ u32 size = GetNarcMemberSizeByIdPair(narcId, memberNo);
+ dest = AllocFromHeapAtEnd(heap_id, size);
+ }
+ else
+ {
+ u32 size = GetNarcMemberSizeByIdPair(narcId, memberNo);
+ dest = AllocFromHeap(heap_id, size);
+ }
+ if (dest != NULL)
+ {
+ ReadWholeNarcMemberByIdPair(dest, narcId, memberNo);
+ if (isCompressed)
+ {
+ if (allocAtEnd == FALSE)
+ {
+ dest2 = AllocFromHeap(heap_id, (*(u32 *)dest) >> 8);
+ }
+ else
+ {
+ dest2 = AllocFromHeapAtEnd(heap_id, (*(u32 *)dest) >> 8);
+ }
+ if (dest2 != NULL)
+ {
+ MI_UncompressLZ8(dest, dest2);
+ FreeToHeap(dest);
+ }
+ dest = dest2; // UB: if dest2 is NULL, dest is never freed
+ }
+ }
+ return dest;
+}
+
+THUMB_FUNC void * GfGfxLoader_LoadFromNarc_GetSizeOut(NarcId narcId, s32 memberNo, BOOL isCompressed, u32 heap_id, BOOL allocAtEnd, u32 *size_p)
+{
+ void * dest;
+ void * dest2;
+ *size_p = GetNarcMemberSizeByIdPair(narcId, memberNo);
+ if (isCompressed || allocAtEnd == TRUE)
+ {
+ dest = AllocFromHeapAtEnd(heap_id, *size_p);
+ }
+ else
+ {
+ dest = AllocFromHeap(heap_id, *size_p);
+ }
+ if (dest != NULL)
+ {
+ ReadWholeNarcMemberByIdPair(dest, narcId, memberNo);
+ if (isCompressed)
+ {
+ *size_p = (*(u32 *)dest) >> 8;
+ if (allocAtEnd == FALSE)
+ {
+ dest2 = AllocFromHeap(heap_id, *size_p);
+ }
+ else
+ {
+ dest2 = AllocFromHeapAtEnd(heap_id, *size_p);
+ }
+ if (dest2 != NULL)
+ {
+ MI_UncompressLZ8(dest, dest2);
+ FreeToHeap(dest);
+ }
+ dest = dest2; // UB: if dest2 is NULL, dest is never freed
+ }
+ }
+ return dest;
+}
|