diff --git a/configure.py b/configure.py index b65e75a3c..a53d992ab 100644 --- a/configure.py +++ b/configure.py @@ -651,7 +651,7 @@ config.libs = [ "JAudio", [ Object(Matching, "JSystem/JAudio/JASCalc.cpp"), - Object(NonMatching, "JSystem/JAudio/JASAiCtrl.cpp"), + Object(Matching, "JSystem/JAudio/JASAiCtrl.cpp"), Object(NonMatching, "JSystem/JAudio/JASDvdThread.cpp"), Object(Matching, "JSystem/JAudio/JASCallback.cpp"), Object(Matching, "JSystem/JAudio/JASRate.cpp"), diff --git a/include/JSystem/JAudio/JASDSPInterface.h b/include/JSystem/JAudio/JASDSPInterface.h index 69b279176..027c40c2c 100644 --- a/include/JSystem/JAudio/JASDSPInterface.h +++ b/include/JSystem/JAudio/JASDSPInterface.h @@ -91,7 +91,7 @@ namespace JASystem { /* 0x78 */ short field_0x78[4]; /* 0x80 */ short field_0x80[20]; /* 0xA8 */ short field_0xa8[4]; - /* 0xB8 */ short field_0xb0[16]; + /* 0xB8 */ u16 field_0xb0[16]; /* 0xD0 */ u8 field_0xd0[0x100 - 0xd0]; /* 0x100 */ u16 field_0x100; /* 0x102 */ u16 field_0x102; diff --git a/include/JSystem/JParticle/JPAEmitter.h b/include/JSystem/JParticle/JPAEmitter.h index c2f6cad2d..3f37f1358 100644 --- a/include/JSystem/JParticle/JPAEmitter.h +++ b/include/JSystem/JParticle/JPAEmitter.h @@ -22,30 +22,44 @@ class JPAFieldBlock; class JPADataBlockLinkInfo { public: - JPAFieldBlock * getField() { return mpFieldBlock; } - u8 getFieldNum() { return mFieldNum; } - JPADynamicsBlock * getDynamics() { return mpDynamicsBlock; } - JPASweepShape * getSweepShape() { return mpSweepShape; } - u8 getKeyNum() { return mKeyNum; } - JPAKeyBlock * getKey() { return mpKeyBlock; } - JPAExtraShape * getExtraShape() { return mpExtraShape; } - u32 * getTextureDataBase() { return mpTextureDataBase; } - JPAExTexShape * getExTexShape() { return mpExTexShape; } - JPABaseShape * getBaseShape() { return mpBaseShape; } + JPADataBlockLinkInfo() { + dynBlock = NULL; + bspBlock = NULL; + espBlock = NULL; + sspBlock = NULL; + etxBlock = NULL; + keyBlocks = NULL; + fldBlocks = NULL; + texDataBase = NULL; + fldNum = NULL; + mTextureNum = NULL; + keyNum = 0; + } + + JPAFieldBlock ** getField() { return fldBlocks; } + u8 getFieldNum() { return fldNum; } + JPADynamicsBlock * getDynamics() { return dynBlock; } + JPASweepShape * getSweepShape() { return sspBlock; } + u8 getKeyNum() { return keyNum; } + JPAKeyBlock ** getKey() { return keyBlocks; } + JPAExtraShape * getExtraShape() { return espBlock; } + u32 * getTextureDataBase() { return texDataBase; } + JPAExTexShape * getExTexShape() { return etxBlock; } + JPABaseShape * getBaseShape() { return bspBlock; } u8 getTextureNum() { return mTextureNum; } public: - /* 0x00 */ JPADynamicsBlock * mpDynamicsBlock; - /* 0x04 */ JPABaseShape * mpBaseShape; - /* 0x08 */ JPAExtraShape * mpExtraShape; - /* 0x0C */ JPASweepShape * mpSweepShape; - /* 0x10 */ JPAExTexShape * mpExTexShape; - /* 0x14 */ JPAKeyBlock * mpKeyBlock; - /* 0x18 */ JPAFieldBlock * mpFieldBlock; - /* 0x1C */ u32 * mpTextureDataBase; - /* 0x20 */ u8 mFieldNum; + /* 0x00 */ JPADynamicsBlock * dynBlock; + /* 0x04 */ JPABaseShape * bspBlock; + /* 0x08 */ JPAExtraShape * espBlock; + /* 0x0C */ JPASweepShape * sspBlock; + /* 0x10 */ JPAExTexShape * etxBlock; + /* 0x14 */ JPAKeyBlock ** keyBlocks; + /* 0x18 */ JPAFieldBlock ** fldBlocks; + /* 0x1C */ u32 * texDataBase; + /* 0x20 */ u8 fldNum; /* 0x21 */ u8 mTextureNum; - /* 0x22 */ u8 mKeyNum; + /* 0x22 */ u8 keyNum; /* 0x23 */ u8 field_0x23; }; diff --git a/include/JSystem/JParticle/JPAEmitterLoader.h b/include/JSystem/JParticle/JPAEmitterLoader.h new file mode 100644 index 000000000..709d289e7 --- /dev/null +++ b/include/JSystem/JParticle/JPAEmitterLoader.h @@ -0,0 +1,23 @@ +#ifndef JPAEMITTERLOADER_H +#define JPAEMITTERLOADER_H + +#include "dolphin/gx/GX.h" + +class JPADataBlockLinkInfo; +class JPAEmitterResource; +class JPATextureResource; +class JKRHeap; + +class JPAEmitterArchiveLoaderDataBase { +public: + static void load(const u8*, JKRHeap*, JPAEmitterResource**, JPATextureResource**); +}; + +struct JPAEmitterData { + JPAEmitterData() : pLinkInfoArray(NULL) {} + /* 0x00 */ JPADataBlockLinkInfo** pLinkInfoArray; + /* 0x04 */ u16 infoNum; + /* 0x06 */ u16 userIndex; +}; + +#endif /* JPAEMITTERLOADER_H */ diff --git a/include/JSystem/JParticle/JPAResourceManager.h b/include/JSystem/JParticle/JPAResourceManager.h new file mode 100644 index 000000000..72db5170a --- /dev/null +++ b/include/JSystem/JParticle/JPAResourceManager.h @@ -0,0 +1,48 @@ +#ifndef JPARESOURCEMANAGER_H +#define JPARESOURCEMANAGER_H + +#include "dolphin/gx/GX.h" +#include "JSystem/JParticle/JPATexture.h" + +class JKRHeap; +class JPATexture; +struct JPAEmitterData; +struct ResTIMG; + +class JPATextureResource { +public: + JPATextureResource(u32, JKRHeap*); + void registration(JPATexture*); + +public: + /* 0x00 */ JPADefaultTexture defaultTex; + /* 0x24 */ u32 registNum; + /* 0x28 */ u32 maxNum; + /* 0x2C */ JPATexture** pTexResArray; +}; + +class JPAEmitterResource { +public: + JPAEmitterResource(u32, JKRHeap*); + void registration(JPAEmitterData*, u16); + JPAEmitterData * getByUserIndex(u16); + BOOL checkUserIndexDuplication(u16); + +public: + /* 0x00 */ u32 registNum; + /* 0x04 */ u32 maxNum; + /* 0x08 */ JPAEmitterData** pEmtrResArray; +}; + +class JPAResourceManager { +public: + JPAResourceManager(const void*, JKRHeap*); + const ResTIMG* swapTexture(const ResTIMG*, const char*); + +public: + /* 0x00 */ JKRHeap * pHeap; + /* 0x04 */ JPAEmitterResource * pEmtrRes; + /* 0x08 */ JPATextureResource * pTexRes; +}; + +#endif /* JPARESOURCEMANAGER_H */ diff --git a/include/JSystem/JParticle/JPATexture.h b/include/JSystem/JParticle/JPATexture.h index 5093f8716..167192587 100644 --- a/include/JSystem/JParticle/JPATexture.h +++ b/include/JSystem/JParticle/JPATexture.h @@ -37,6 +37,7 @@ public: }; struct JPADefaultTexture { + JPADefaultTexture() : imgBuf(NULL) {} void initialize(JKRHeap *); u8 * imgBuf; GXTexObj mTexObj; diff --git a/src/JSystem/JAudio/JASAiCtrl.cpp b/src/JSystem/JAudio/JASAiCtrl.cpp index 079b9cb2a..d745ca406 100644 --- a/src/JSystem/JAudio/JASAiCtrl.cpp +++ b/src/JSystem/JAudio/JASAiCtrl.cpp @@ -15,6 +15,12 @@ #include "dolphin/os/OSCache.h" #include "dolphin/os/OSInterrupt.h" +namespace JASystem { + namespace HardStream { + void main(); + } +}; + /* 8027AE30-8027AE5C .text init__Q28JASystem6KernelFv */ void JASystem::Kernel::init() { resetCallback(); @@ -100,7 +106,7 @@ void JASystem::Kernel::updateDac() { if (!lastRspMadep && vframeWorkRunning == 0) { vframeWork(); } - //HardStream::main(); + HardStream::main(); if (dacCallbackFunc) { dacCallbackFunc(lastRspMadep, gDacSize / 2); } diff --git a/src/JSystem/JAudio/JASCalc.cpp b/src/JSystem/JAudio/JASCalc.cpp index ce10627d6..93ecbddf9 100644 --- a/src/JSystem/JAudio/JASCalc.cpp +++ b/src/JSystem/JAudio/JASCalc.cpp @@ -63,7 +63,6 @@ void JASystem::Calc::bcopyfast(const u32* src, u32* dest, u32 size) { /* 8027AB68-8027AC68 .text bcopy__Q28JASystem4CalcFPCvPvUl */ void JASystem::Calc::bcopy(const void* src, void* dest, u32 size) { - /* Nonmatching */ u32 *usrc; u32 *udest; @@ -106,7 +105,6 @@ void JASystem::Calc::bcopy(const void* src, void* dest, u32 size) { /* 8027AC68-8027AD38 .text bzerofast__Q28JASystem4CalcFPvUl */ void JASystem::Calc::bzerofast(void* dest, u32 size) { - /* Nonmatching */ JUT_ASSERT(387, (reinterpret_cast(dest) & 0x03) == 0); JUT_ASSERT(388, (size & 0x0f) == 0); u32* udest = (u32*)dest; @@ -120,7 +118,6 @@ void JASystem::Calc::bzerofast(void* dest, u32 size) { /* 8027AD38-8027AE30 .text bzero__Q28JASystem4CalcFPvUl */ void JASystem::Calc::bzero(void* dest, u32 size) { - /* Nonmatching */ u32 *udest; u8 *bdest = (u8 *)dest; if ((size & 0x1f) == 0 && (reinterpret_cast(dest) & 0x1f) == 0) { diff --git a/src/JSystem/JAudio/JASChannel.cpp b/src/JSystem/JAudio/JASChannel.cpp index bedbefae6..f22220b96 100644 --- a/src/JSystem/JAudio/JASChannel.cpp +++ b/src/JSystem/JAudio/JASChannel.cpp @@ -13,7 +13,6 @@ /* 8028B3E8-8028B5A4 .text init__Q28JASystem8TChannelFv */ void JASystem::TChannel::init() { - /* Nonmatching */ field_0x28 = 0; field_0x2c = 0; field_0x30 = 0; @@ -291,19 +290,17 @@ f32 JASystem::TChannel::calcPan(const Driver::PanMatrix_*, const Driver::PanMatr /* 8028CC90-8028CD90 .text updateJcToDSPInit__Q28JASystem8TChannelFv */ void JASystem::TChannel::updateJcToDSPInit() { /* Nonmatching */ + JASystem::DSPInterface::DSPBuffer * pBuffer = field_0x20->field_0xc; + if (pBuffer->field_0xb0[0] == 0xFFFF) { + pBuffer->initAutoMixer(); + pBuffer->setMixerInitDelayMax(field_0x4->field_0x60); + } } /* 8028CD90-8028CEA8 .text updateAutoMixer__Q28JASystem8TChannelFffff */ void JASystem::TChannel::updateAutoMixer(f32 param_1, f32 param_2, f32 param_3, f32 param_4) { - /* Nonmatching */ - f32 f31 = 0.0f; - if (param_1 > f31) { - f31 = 1.0f; - if (param_1 >= f31) { - f31 = param_1; - } - } - field_0x20->field_0xc->setAutoMixer(f31 * Driver::getAutoLevel(), param_2 * 127.5f, param_4 * 127.5f, param_3 * 127.5f, field_0xb0[1]); + f32 level = param_1 <= 0.0f ? 0.0f : param_1 >= 1.0f ? 1.0f : param_1; + field_0x20->field_0xc->setAutoMixer(level * Driver::getAutoLevel(), param_2 * 127.5f, param_4 * 127.5f, param_3 * 127.5f, field_0xb0[1]); } /* 8028CEA8-8028D128 .text updateMixer__Q28JASystem8TChannelFffff */ diff --git a/src/JSystem/JAudio/JASChannelMgr.cpp b/src/JSystem/JAudio/JASChannelMgr.cpp index bfd2a836d..b55ec9f19 100644 --- a/src/JSystem/JAudio/JASChannelMgr.cpp +++ b/src/JSystem/JAudio/JASChannelMgr.cpp @@ -69,14 +69,13 @@ void JASystem::TChannelMgr::stopAllRelease() { /* 8028D558-8028D5D0 .text initAllocChannel__Q28JASystem11TChannelMgrFUl */ void JASystem::TChannelMgr::initAllocChannel(u32 param_1) { - /* Nonmatching */ if (field_0x0) { OSReport("----- Warning JCSにボイスが %d 残っているのでグローバルに返却します\n", field_0x0); TGlobalChannel::releaseAll(this); } init(); TGlobalChannel::alloc(this, param_1); - field_0x70 = param_1 != 0; + field_0x70 = (param_1 != 0) ? 1 : 0; } /* 8028D5D0-8028D778 .text getLogicalChannel__Q28JASystem11TChannelMgrFUl */ diff --git a/src/JSystem/JAudio/dsptask.c b/src/JSystem/JAudio/dsptask.c index fa9bd5c97..61407e70f 100644 --- a/src/JSystem/JAudio/dsptask.c +++ b/src/JSystem/JAudio/dsptask.c @@ -513,13 +513,17 @@ void DspBoot(void (*param_1)(void*)) { } /* 8028E960-8028EA48 .text DSPSendCommands2__FPUlUlPFUs_v */ -int DSPSendCommands2(u32* param_1, u32 param_2, void (*param_3)(u16)) { +int DSPSendCommands2(u32* param_1, u32 param_2, void (*callBack)(u16)) { /* Nonmatching */ - while (Dsp_Running_Check() == 0); + s32 startWorkStatus; + BOOL interruptFlag; + s32 i; - BOOL status = OSDisableInterrupts(); + while (Dsp_Running_Check() == 0) {}; + + interruptFlag = OSDisableInterrupts(); if (DSPCheckMailToDSP()) { - OSRestoreInterrupts(status); + OSRestoreInterrupts(interruptFlag); return -1; } @@ -527,21 +531,20 @@ int DSPSendCommands2(u32* param_1, u32 param_2, void (*param_3)(u16)) { DSPAssertInt(); while(DSPCheckMailToDSP() != 0); - if (param_1 == 0) { + if (param_2 == 0) { param_2 = 1; } - int startWorkStatus; - if (param_3 != NULL) { - startWorkStatus = DspStartWork(param_1[0], param_3); + if (callBack != NULL) { + startWorkStatus = DspStartWork(param_1[0], callBack); } - for (int i = 0; i < param_2; i++) { + for (i = 0; i < param_2; i++) { DSPSendMailToDSP(param_1[i]); while (DSPCheckMailToDSP() != 0); } - OSRestoreInterrupts(status); + OSRestoreInterrupts(interruptFlag); return startWorkStatus; } @@ -555,7 +558,6 @@ static TaskWorkStruct taskwork[16]; /* 8028EA60-8028EA8C .text DspInitWork__Fv */ void DspInitWork() { - /* Nonmatching */ for (int i = 0; i < 16; i++) { taskwork[i].field_0x4 = NULL; } diff --git a/src/JSystem/JParticle/JPAEmitter.cpp b/src/JSystem/JParticle/JPAEmitter.cpp index 4c07cdfb2..aa890945e 100644 --- a/src/JSystem/JParticle/JPAEmitter.cpp +++ b/src/JSystem/JParticle/JPAEmitter.cpp @@ -99,7 +99,6 @@ void JPABaseEmitter::calcEmitterInfo() { /* 8025D294-8025D3C0 .text calc__14JPABaseEmitterFv */ void JPABaseEmitter::calc() { - /* Nonmatching */ emtrInfo.mVolumeEmitCount = 0; if (!checkStatus(JPAEmtrStts_StopCalc)) { calcKey(); diff --git a/src/JSystem/JParticle/JPAEmitterLoader.cpp b/src/JSystem/JParticle/JPAEmitterLoader.cpp index 957e5a3fe..c7802101d 100644 --- a/src/JSystem/JParticle/JPAEmitterLoader.cpp +++ b/src/JSystem/JParticle/JPAEmitterLoader.cpp @@ -4,14 +4,144 @@ // #include "JSystem/JParticle/JPAEmitterLoader.h" -#include "dolphin/types.h" +#include "JSystem/JParticle/JPAEmitter.h" +#include "JSystem/JParticle/JPAResourceManager.h" +#include "JSystem/JUtility/JUTAssert.h" +#include "JSystem/JKernel/JKRHeap.h" + +#include "JSystem/JParticle/JPADynamicsBlock.h" +#include "JSystem/JParticle/JPABaseShape.h" +#include "JSystem/JParticle/JPAExtraShape.h" +#include "JSystem/JParticle/JPASweepShape.h" +#include "JSystem/JParticle/JPAExTexShape.h" +#include "JSystem/JParticle/JPAKeyBlock.h" +#include "JSystem/JParticle/JPAFieldBlock.h" + +class JPAEmitterArchiveLoader_v10 { +public: + void load(); + +public: + /* 0x00 */ JKRHeap* pHeap; + /* 0x04 */ const u8* pData; + /* 0x08 */ JPAEmitterResource* mpEmtrRes; + /* 0x0C */ JPATextureResource* mpTexRes; +}; /* 802590B4-8025917C .text load__31JPAEmitterArchiveLoaderDataBaseFPCUcP7JKRHeapPP18JPAEmitterResourcePP18JPATextureResource */ -void JPAEmitterArchiveLoaderDataBase::load(const unsigned char*, JKRHeap*, JPAEmitterResource**, JPATextureResource**) { - /* Nonmatching */ +void JPAEmitterArchiveLoaderDataBase::load(const u8* data, JKRHeap* heap, JPAEmitterResource** dstEmtrRes, JPATextureResource** dstTexRes) { + u32 magic = ((const u32*)data)[0]; + + if (magic == 'JPAC') { + u32 version = ((const u32*)data)[1]; + if (version == '1-00') { + JPAEmitterArchiveLoader_v10 loader; + loader.pHeap = heap; + loader.pData = data; + loader.mpEmtrRes = NULL; + loader.mpTexRes = NULL; + loader.load(); + *dstEmtrRes = loader.mpEmtrRes; + *dstTexRes = loader.mpTexRes; + } else { + JUT_WARN(201, "%s", "This is WRONG Version File\n"); + } + } else { + JUT_WARN(202, "%s", "This is WRONG File\n"); + } } +struct JPAEmitterArchiveData_v10 { + /* 0x00 */ u32 magic; + /* 0x04 */ u32 size; + /* 0x08 */ u16 emtrResNum; + /* 0x0A */ u16 texResNum; +}; + /* 8025917C-8025991C .text load__27JPAEmitterArchiveLoader_v10Fv */ void JPAEmitterArchiveLoader_v10::load() { - /* Nonmatching */ + const JPAEmitterArchiveData_v10* header = (const JPAEmitterArchiveData_v10*)pData; + mpEmtrRes = new(pHeap, 0) JPAEmitterResource(header->emtrResNum, pHeap); + mpTexRes = new(pHeap, 0) JPATextureResource(header->texResNum, pHeap); + + u32 offs = 0x20; + for (u32 i = 0; i < header->emtrResNum; i++) { + JPAEmitterData* pEmtrRes = new(pHeap, 0) JPAEmitterData(); + JUT_ASSERT(234, pEmtrRes); + + JPADataBlockLinkInfo* pLinkInfo = new(pHeap, 0) JPADataBlockLinkInfo(); + JUT_ASSERT(238, pLinkInfo); + + pEmtrRes->infoNum = 1; + pEmtrRes->pLinkInfoArray = new(pHeap, 0) JPADataBlockLinkInfo*[pEmtrRes->infoNum]; + JUT_ASSERT(243, pEmtrRes->pLinkInfoArray); + pEmtrRes->pLinkInfoArray[0] = pLinkInfo; + + pLinkInfo->keyNum = pData[offs + 0x14]; + pLinkInfo->keyBlocks = (JPAKeyBlock**) (pLinkInfo->keyNum != 0 ? new(pHeap, 0) JPAKeyBlockArc*[pLinkInfo->keyNum] : NULL); + JUT_ASSERT(250, pLinkInfo->keyBlocks || pLinkInfo->keyNum == 0); + + pLinkInfo->fldNum = pData[offs + 0x15]; + pLinkInfo->fldBlocks = (JPAFieldBlock**) (pLinkInfo->fldNum != 0 ? new(pHeap, 0) JPAFieldBlockArc*[pLinkInfo->fldNum] : NULL); + JUT_ASSERT(256, pLinkInfo->fldBlocks || pLinkInfo->fldNum == 0); + + pLinkInfo->mTextureNum = pData[offs + 0x16]; + pLinkInfo->texDataBase = NULL; + + u32 fld_cntr = 0; + u32 key_cntr = 0; + u32 blockOffs = offs + 0x20; + for (u32 j = 0; j < *((u32*)(pData + offs + 0x0C)); j++) { + const u8* block = (const u8*)(pData + blockOffs); + u32 size = ((u32*)block)[1]; + switch (((u32*)block)[0]) { + case 'FLD1': + pLinkInfo->fldBlocks[fld_cntr] = (JPAFieldBlock*) new(pHeap, 0) JPAFieldBlockArc(pData + blockOffs); + JUT_ASSERT(274, pLinkInfo->fldBlocks[fld_cntr]); + fld_cntr++; + break; + case 'KFA1': + pLinkInfo->keyBlocks[key_cntr] = (JPAKeyBlock*) new(pHeap, 0) JPAKeyBlockArc(pData + blockOffs); + JUT_ASSERT(278, pLinkInfo->keyBlocks[key_cntr]); + key_cntr++; + break; + case 'BEM1': + pLinkInfo->dynBlock = (JPADynamicsBlock*) new(pHeap, 0) JPADynamicsBlockArc(pData + blockOffs); + JUT_ASSERT(284, pLinkInfo->dynBlock); + break; + case 'BSP1': + pLinkInfo->bspBlock = (JPABaseShape*) new(pHeap, 0) JPABaseShapeArc(pData + blockOffs, pHeap); + JUT_ASSERT(288, pLinkInfo->bspBlock); + break; + case 'ESP1': + pLinkInfo->espBlock = (JPAExtraShape*) new(pHeap, 0) JPAExtraShapeArc(pData + blockOffs); + JUT_ASSERT(292, pLinkInfo->espBlock); + break; + case 'SSP1': + pLinkInfo->sspBlock = (JPASweepShape*) new(pHeap, 0) JPASweepShapeArc(pData + blockOffs); + JUT_ASSERT(296, pLinkInfo->sspBlock); + break; + case 'ETX1': + pLinkInfo->etxBlock = (JPAExTexShape*) new(pHeap, 0) JPAExTexShapeArc(pData + blockOffs); + JUT_ASSERT(300, pLinkInfo->etxBlock); + break; + case 'TDB1': + pLinkInfo->texDataBase = (u32*)(block + 0x0c); + break; + } + + blockOffs += size; + } + + mpEmtrRes->registration(pEmtrRes, *(u16*)(pData + 0x18)); + offs = blockOffs; + } + + for (u32 i = 0; i < header->texResNum; i++) { + u32 size = *(u32*)(pData + offs + 0x04); + JPATextureArc * pTex = new(pHeap, 0) JPATextureArc(pData + offs); + JUT_ASSERT(319, pTex); + mpTexRes->registration(pTex); + offs += size; + } } diff --git a/src/JSystem/JParticle/JPAResourceManager.cpp b/src/JSystem/JParticle/JPAResourceManager.cpp index 7b696e877..59c32af62 100644 --- a/src/JSystem/JParticle/JPAResourceManager.cpp +++ b/src/JSystem/JParticle/JPAResourceManager.cpp @@ -4,44 +4,88 @@ // #include "JSystem/JParticle/JPAResourceManager.h" -#include "dolphin/types.h" +#include "JSystem/JParticle/JPAEmitterLoader.h" +#include "JSystem/JKernel/JKRHeap.h" +#include "JSystem/JUtility/JUTAssert.h" +#include "JSystem/JUtility/JUTTexture.h" +#include "MSL_C/string.h" /* 80258CAC-80258D54 .text __ct__18JPATextureResourceFUlP7JKRHeap */ -JPATextureResource::JPATextureResource(unsigned long, JKRHeap*) { - /* Nonmatching */ +JPATextureResource::JPATextureResource(u32 num, JKRHeap* heap) { + registNum = 0; + maxNum = num; + pTexResArray = new(heap, 0) JPATexture*[maxNum]; + JUT_ASSERT(24, pTexResArray); + defaultTex.initialize(heap); } /* 80258D54-80258DE4 .text registration__18JPATextureResourceFP10JPATexture */ -void JPATextureResource::registration(JPATexture*) { - /* Nonmatching */ +void JPATextureResource::registration(JPATexture* res) { + JUT_ASSERT(76, registNum < maxNum); + pTexResArray[registNum] = res; + registNum++; +} + +static void dummy() { + OSReport("pTexResArray[registNum]"); } /* 80258DE4-80258E70 .text __ct__18JPAEmitterResourceFUlP7JKRHeap */ -JPAEmitterResource::JPAEmitterResource(unsigned long, JKRHeap*) { - /* Nonmatching */ +JPAEmitterResource::JPAEmitterResource(u32 num, JKRHeap* heap) { + registNum = 0; + maxNum = num; + pEmtrResArray = new(heap, 0) JPAEmitterData*[maxNum]; + JUT_ASSERT(93, pEmtrResArray); } /* 80258E70-80258F18 .text registration__18JPAEmitterResourceFP14JPAEmitterDataUs */ -void JPAEmitterResource::registration(JPAEmitterData*, unsigned short) { - /* Nonmatching */ +void JPAEmitterResource::registration(JPAEmitterData* res, u16 userIndex) { + JUT_ASSERT(107, registNum < maxNum); + if (registNum < maxNum) { + res->userIndex = userIndex; + pEmtrResArray[registNum] = res; + } + registNum++; } /* 80258F18-80258F5C .text getByUserIndex__18JPAEmitterResourceFUs */ -void JPAEmitterResource::getByUserIndex(unsigned short) { - /* Nonmatching */ +JPAEmitterData * JPAEmitterResource::getByUserIndex(u16 userIndex) { + for (u32 i = 0; i < registNum; i++) { + JPAEmitterData * data = pEmtrResArray[i]; + if (data->userIndex == userIndex) + return data; + } + return NULL; } /* 80258F5C-80258FA0 .text checkUserIndexDuplication__18JPAEmitterResourceFUs */ -void JPAEmitterResource::checkUserIndexDuplication(unsigned short) { - /* Nonmatching */ +BOOL JPAEmitterResource::checkUserIndexDuplication(u16 userIndex) { + for (u32 i = 0; i < registNum; i++) { + JPAEmitterData * data = pEmtrResArray[i]; + if (data->userIndex == userIndex) + return TRUE; + } + return FALSE; } /* 80258FA0-80258FF4 .text __ct__18JPAResourceManagerFPCvP7JKRHeap */ -JPAResourceManager::JPAResourceManager(const void*, JKRHeap*) { - /* Nonmatching */ +JPAResourceManager::JPAResourceManager(const void* data, JKRHeap* heap) { + pHeap = heap != NULL ? heap : JKRHeap::getCurrentHeap(); + JPAEmitterArchiveLoaderDataBase::load((const u8*)data, pHeap, &pEmtrRes, &pTexRes); } /* 80258FF4-802590B4 .text swapTexture__18JPAResourceManagerFPC7ResTIMGPCc */ -void JPAResourceManager::swapTexture(const ResTIMG*, const char*) { - /* Nonmatching */ +const ResTIMG* JPAResourceManager::swapTexture(const ResTIMG* timg, const char* name) { + const ResTIMG * oldTimg = NULL; + + for (u32 i = 0; i < pTexRes->registNum; i++) { + if (strcmp(name, pTexRes->pTexResArray[i]->getName()) == 0) { + JUTTexture* tex = pTexRes->pTexResArray[i]->getJUTTexture(); + oldTimg = tex->getTexInfo(); + tex->storeTIMG(timg, (u8)0); + break; + } + } + + return oldTimg; }