From 64fa1ce43ea98488b24ab07cdd02b8f53134caf4 Mon Sep 17 00:00:00 2001 From: SwareJonge <41187958+SwareJonge@users.noreply.github.com> Date: Sat, 11 Jan 2025 23:31:02 +0100 Subject: [PATCH] make JPArticle equivalent by using TPs implementation --- configure.py | 2 +- include/JSystem/JParticle/JPABlock.h | 7 +- include/JSystem/JParticle/JPAEmitter.h | 2 +- include/JSystem/JParticle/JPAField.h | 5 +- include/JSystem/JParticle/JPAList.h | 21 + include/JSystem/JParticle/JPAResource.h | 56 +- include/JSystem/JParticle/JPAShape.h | 81 +- libs/JSystem/JParticle/JPADynamicsBlock.cpp | 4 +- libs/JSystem/JParticle/JPAEmitter.cpp | 10 +- libs/JSystem/JParticle/JPAEmitterManager.cpp | 8 +- libs/JSystem/JParticle/JPAFieldBlock.cpp | 420 ++-- libs/JSystem/JParticle/JPAParticle.cpp | 4 +- libs/JSystem/JParticle/JPAResource.cpp | 1949 +++++++++-------- libs/JSystem/JParticle/JPAResourceLoader.cpp | 4 - libs/JSystem/JParticle/JPAResourceManager.cpp | 4 +- libs/JSystem/JParticle/JPATexture.cpp | 4 +- 16 files changed, 1331 insertions(+), 1250 deletions(-) diff --git a/configure.py b/configure.py index 479c7e85..7c132c73 100755 --- a/configure.py +++ b/configure.py @@ -953,7 +953,7 @@ def MatchingFor(*versions): Object(Matching, "JSystem/JParticle/JPAKeyBlock.cpp"), Object(Matching, "JSystem/JParticle/JPAMath.cpp"), Object(Matching, "JSystem/JParticle/JPAParticle.cpp"), - Object(NonMatching, "JSystem/JParticle/JPAResource.cpp"), + Object(Matching, "JSystem/JParticle/JPAResource.cpp"), Object(Matching, "JSystem/JParticle/JPAResourceLoader.cpp"), Object(Matching, "JSystem/JParticle/JPAResourceManager.cpp"), Object(Matching, "JSystem/JParticle/JPATexture.cpp") diff --git a/include/JSystem/JParticle/JPABlock.h b/include/JSystem/JParticle/JPABlock.h index b5cf574a..0cff9802 100644 --- a/include/JSystem/JParticle/JPABlock.h +++ b/include/JSystem/JParticle/JPABlock.h @@ -4,9 +4,11 @@ #include "JSystem/JGeometry.h" #include "types.h" +#include "JSystem/JParticle/JPAField.h" + struct JKRHeap; struct JPAEmitterWorkData; -struct JPAFieldBase; +struct JPABaseParticle; typedef void JPAVolumeFunc(JPAEmitterWorkData *); @@ -188,6 +190,9 @@ struct JPAFieldBlock mSpeed = getMagOrig(); } + void prepare(JPAEmitterWorkData *work) { pFld->prepare(work, this); } + void calc(JPAEmitterWorkData *work, JPABaseParticle *ptcl) { pFld->calc(work, this, ptcl); } + const Data *mData; // _00 JPAFieldBase *pFld; // _04 f32 mFadeInRate; // _08 diff --git a/include/JSystem/JParticle/JPAEmitter.h b/include/JSystem/JParticle/JPAEmitter.h index 4b869c6c..83913bb1 100644 --- a/include/JSystem/JParticle/JPAEmitter.h +++ b/include/JSystem/JParticle/JPAEmitter.h @@ -146,7 +146,7 @@ struct JPABaseEmitter void initFlag(u32 flag) { mFlags = flag; } void setFlag(u32 flag) { mFlags |= flag; } bool checkStatus(u32 flag) const { return mFlags & flag; } - void resetFlag(u32 flag) { mFlags &= ~flag; } + void clearStatus(u32 flag) { mFlags &= ~flag; } inline void setScale(f32 scale) { diff --git a/include/JSystem/JParticle/JPAField.h b/include/JSystem/JParticle/JPAField.h index f7f8ce23..c66dece7 100644 --- a/include/JSystem/JParticle/JPAField.h +++ b/include/JSystem/JParticle/JPAField.h @@ -3,9 +3,10 @@ #include #include "JSystem/JGeometry.h" -#include "JSystem/JParticle/JPABlock.h" #include "JSystem/JParticle/JPAResource.h" +struct JPAFieldBlock; + struct JPAFieldBase { virtual ~JPAFieldBase() {} // _08 (weak) @@ -129,4 +130,4 @@ struct JPAFieldVortex : public JPAFieldBase f32 _20; // _20 }; -#endif \ No newline at end of file +#endif diff --git a/include/JSystem/JParticle/JPAList.h b/include/JSystem/JParticle/JPAList.h index f463ea2e..0a234d98 100644 --- a/include/JSystem/JParticle/JPAList.h +++ b/include/JSystem/JParticle/JPAList.h @@ -130,6 +130,27 @@ struct JPAList return ret; } + + JPANode* erase(JPANode* node) { + if (node->mNext != NULL && node->mPrev != NULL) { + node->mPrev->mNext = node->mNext; + node->mNext->mPrev = node->mPrev; + mNum--; + } else if (node->mNext != NULL) { + node->mNext->mPrev = NULL; + mFirst = node->mNext; + mNum--; + } else if (node->mPrev != NULL) { + node->mPrev->mNext = NULL; + mLast = node->mPrev; + mNum--; + } else { + mLast = NULL; + mFirst = NULL; + mNum--; + } + return node; + } }; #endif diff --git a/include/JSystem/JParticle/JPAResource.h b/include/JSystem/JParticle/JPAResource.h index fa99f7c3..78713bfb 100644 --- a/include/JSystem/JParticle/JPAResource.h +++ b/include/JSystem/JParticle/JPAResource.h @@ -5,8 +5,8 @@ #include "JSystem/JKernel/JKRHeap.h" #include "JSystem/JParticle/JPATexture.h" -typedef void JPAFunctionA(struct JPAEmitterWorkData *); -typedef void JPAFunctionB(struct JPAEmitterWorkData *, struct JPABaseParticle *); +typedef void (*JPAEmitterFunc)(struct JPAEmitterWorkData *); +typedef void (*JPAParticleFunc)(struct JPAEmitterWorkData *, struct JPABaseParticle *); struct JPABaseShape; struct JPAExtraShape; @@ -46,32 +46,32 @@ struct JPAResource u16 getTexIdx(u8 idx) { return texIdxTbl[idx]; } u16 getUsrIdx() const { return mUsrIdx; } - JPAFunctionA **mCalcEmitterFuncList; // _00 - JPAFunctionA **mDrawEmitterFuncList; // _04 - JPAFunctionA **mDrawEmitterChildFuncList; // _08 - JPAFunctionB **mCalcParticleFuncList; // _0C - JPAFunctionB **mDrawParticleFuncList; // _10 - JPAFunctionB **mCalcParticleChildFuncList; // _14 - JPAFunctionB **mDrawParticleChildFuncList; // _18 - JPABaseShape *pBsp; // _1C - JPAExtraShape *pEsp; // _20 - JPAChildShape *pCsp; // _24 - JPAExTexShape *pEts; // _28 - JPADynamicsBlock *pDyn; // _2C - JPAFieldBlock **ppFld; // _30 - JPAKeyBlock **ppKey; // _34 - u16 *texIdxTbl ; // _38 - u16 mUsrIdx; // _3C - u8 fldNum; // _3E - u8 keyNum; // _3F - u8 texNum; // _40 - u8 mCalcEmitterFuncListNum; // _41 - u8 mDrawEmitterFuncListNum; // _42 - u8 mDrawEmitterChildFuncListNum; // _43 - u8 mCalcParticleFuncListNum; // _44 - u8 mDrawParticleFuncListNum; // _45 - u8 mCalcParticleChildFuncListNum; // _46 - u8 mDrawParticleChildFuncListNum; // _47 + JPAEmitterFunc *mCalcEmitterFuncList; // _00 + JPAEmitterFunc *mDrawEmitterFuncList; // _04 + JPAEmitterFunc *mDrawEmitterChildFuncList; // _08 + JPAParticleFunc *mCalcParticleFuncList; // _0C + JPAParticleFunc *mDrawParticleFuncList; // _10 + JPAParticleFunc *mCalcParticleChildFuncList; // _14 + JPAParticleFunc *mDrawParticleChildFuncList; // _18 + JPABaseShape *pBsp; // _1C + JPAExtraShape *pEsp; // _20 + JPAChildShape *pCsp; // _24 + JPAExTexShape *pEts; // _28 + JPADynamicsBlock *pDyn; // _2C + JPAFieldBlock **ppFld; // _30 + JPAKeyBlock **ppKey; // _34 + u16 *texIdxTbl ; // _38 + u16 mUsrIdx; // _3C + u8 fldNum; // _3E + u8 keyNum; // _3F + u8 texNum; // _40 + u8 mCalcEmitterFuncListNum; // _41 + u8 mDrawEmitterFuncListNum; // _42 + u8 mDrawEmitterChildFuncListNum; // _43 + u8 mCalcParticleFuncListNum; // _44 + u8 mDrawParticleFuncListNum; // _45 + u8 mCalcParticleChildFuncListNum; // _46 + u8 mDrawParticleChildFuncListNum; // _47 }; /** diff --git a/include/JSystem/JParticle/JPAShape.h b/include/JSystem/JParticle/JPAShape.h index 51261fe3..865998b4 100644 --- a/include/JSystem/JParticle/JPAShape.h +++ b/include/JSystem/JParticle/JPAShape.h @@ -2,6 +2,7 @@ #define _JSYSTEM_JPA_JPASHAPE_H #include +#include #include "JSystem/JKernel/JKRHeap.h" #include "types.h" @@ -82,18 +83,20 @@ struct JPABaseShape u32 getProjType() const { return ((pBsd->mFlags >> 24) & 0x01); } u32 getTilingS() const { return (pBsd->mFlags >> 25) & 0x01; } u32 getTilingT() const { return (pBsd->mFlags >> 26) & 0x01; } - bool isGlblClrAnm() const { return !!(pBsd->mFlags & 0x00001000); } - bool isGlblTexAnm() const { return !!(pBsd->mFlags & 0x00004000); } - bool isPrjTex() const { return !!(pBsd->mFlags & 0x00100000); } - bool isDrawFwdAhead() const { return !!(pBsd->mFlags & 0x00200000); } - bool isDrawPrntAhead() const { return !!(pBsd->mFlags & 0x00400000); } - bool isClipOn() const { return !!(pBsd->mFlags & 0x00800000); } - bool isTexCrdAnm() const { return !!(pBsd->mFlags & 0x01000000); } - bool isNoDrawParent() const { return !!(pBsd->mFlags & 0x08000000); } - bool isNoDrawChild() const { return !!(pBsd->mFlags & 0x10000000); } - - bool isPrmAnm() const { return !!(pBsd->mClrFlg & 0x02); } - bool isEnvAnm() const { return !!(pBsd->mClrFlg & 0x08); } + BOOL isNoDrawParent() const { return ((pBsd->mFlags >> 27) & 1); } + BOOL isNoDrawChild() const { return ((pBsd->mFlags >> 28) & 1); } + + BOOL isPrjTex() const { return (pBsd->mFlags & 0x00100000); } + BOOL isTexCrdAnm() const { return (pBsd->mFlags & 0x01000000); } + BOOL isGlblClrAnm() const { return (pBsd->mFlags & 0x00001000); } + u32 isGlblTexAnm() const { return (pBsd->mFlags & 0x00004000) ; } // fakematch most likely + BOOL isDrawFwdAhead() const { return (pBsd->mFlags & 0x00200000); } + BOOL isDrawPrntAhead() const { return (pBsd->mFlags & 0x00400000); } + BOOL isClipOn() const { return (pBsd->mFlags & 0x00800000); } + + BOOL isTexAnm() const { return (pBsd->mTexFlg & 0x01); } + BOOL isPrmAnm() const { return (pBsd->mClrFlg & 0x02); } + BOOL isEnvAnm() const { return (pBsd->mClrFlg & 0x08); } u8 getClrAnmType() const { return (pBsd->mClrFlg >> 4) & 0x07; } s32 getClrAnmMaxFrm() const { return pBsd->mClrAnmFrmMax; } void getPrmClr(GXColor *dst) { *dst = pBsd->mClrPrm; } @@ -101,7 +104,6 @@ struct JPABaseShape void getEnvClr(GXColor *dst) { *dst = pBsd->mClrEnv; } void getEnvClr(s16 idx, GXColor *dst) const { *dst = mEnvClrAnmTbl[idx]; } - bool isTexAnm() const { return !!(pBsd->mTexFlg & 0x01); } u8 getTexAnmType() const { return (pBsd->mTexFlg >> 2) & 0x07; } s64 getTexIdx() const { return (u8)pBsd->mTexIdx; } u8 getTexIdx(u8 idx) const { return mTexIdxAnimTbl[idx]; } @@ -195,11 +197,17 @@ struct JPAChildShape f32 getAlphaInhRate() const { return mData->mInheritAlpha; } f32 getGravity() const { return mData->mGravity; } - bool isFieldAffected() const { return mData->mFlags & 0x200000; } - bool isScaleInherited() const { return mData->mFlags & 0x10000; } - bool isColorInherited() const { return mData->mFlags & 0x40000; } - bool isAlphaInherited() const { return mData->mFlags & 0x20000; } - bool isRotateOn() const { return mData->mFlags & 0x1000000; } + u32 getType() const { return (mData->mFlags >> 0) & 0x0F; } + u32 getBasePlaneType() const { return (mData->mFlags >> 10) & 0x01; } + + BOOL isScaleInherited() const { return mData->mFlags & 0x10000; } + BOOL isAlphaInherited() const { return mData->mFlags & 0x20000; } + BOOL isColorInherited() const { return mData->mFlags & 0x40000; } + BOOL isClipOn() const { return mData->mFlags & 0x100000; } + BOOL isFieldAffected() const { return mData->mFlags & 0x200000; } + BOOL isScaleOutOn() const { return mData->mFlags & 0x400000; } + BOOL isAlphaOutOn() const { return mData->mFlags & 0x800000; } + BOOL isRotateOn() const { return mData->mFlags & 0x1000000; } const JPAChildShapeData *mData; // _00 }; @@ -210,7 +218,7 @@ struct JPAExTexShapeData u32 mSize; // _04 u32 mFlags; // _08 - f32 mIndTexMtx[2][3]; // _0C + Mtx23 mIndTexMtx; // _0C s8 mExpScale; // _24 s8 mIndTexIdx; // _25 s8 mSecTexIdx; // _26 @@ -226,12 +234,12 @@ struct JPAExTexShape // Unused/inlined: void init_jpa(const u8 *, JKRHeap *); - const f32 *getIndTexMtx() const { return &mData->mIndTexMtx[0][0]; } - s32 getExpScale() const { return mData->mExpScale; } + const Mtx23 &getIndTexMtx() const { return mData->mIndTexMtx; } + const s8 getExpScale() const { return mData->mExpScale; } u8 getIndTexIdx() const { return mData->mIndTexIdx; } u8 getSecTexIdx() const { return mData->mSecTexIdx; } - bool isUseIndirect() const { return !!(mData->mFlags & 0x01); } - bool isUseSecTex() const { return !!(mData->mFlags & 0x0100); } + BOOL isUseIndirect() const { return (mData->mFlags & 0x01); } + BOOL isUseSecTex() const { return (mData->mFlags & 0x0100); } const JPAExTexShapeData *mData; // _00 }; @@ -307,17 +315,26 @@ struct JPAExtraShape f32 getAlphaIncRate() const { return mAlphaIncRate; } f32 getAlphaDecRate() const { return mAlphaDecRate; } - bool isEnableScaleAnm() const { return mData->mFlags & 0x1; } - bool isEnableAlphaFlick() const { return mData->mFlags & 0x20000; } - bool isEnableRotateAnm() const { return mData->mFlags & 0x1000000; } + u32 getScaleAnmTypeX() const { return (mData->mFlags >> 8) & 3; } + u32 getScaleAnmTypeY() const { return (mData->mFlags >> 10) & 3; } + u32 getScaleCenterX() const { return (mData->mFlags >> 12) & 3; } + u32 getScaleCenterY() const { return (mData->mFlags >> 14) & 3; } + + BOOL isEnableAlphaAnm() const { return mData->mFlags & 0x10000; } + BOOL isEnableAlphaFlick() const { return mData->mFlags & 0x20000; } + BOOL isEnableRotateAnm() const { return mData->mFlags & 0x1000000; } + + BOOL isEnableScaleAnm() const { return mData->mFlags & 1; } + BOOL isScaleXYDiff() const { return mData->mFlags & 2; } + const JPAExtraShapeData *mData; // _00 - f32 mAlphaIncRate; // _04 - f32 mAlphaDecRate; // _08 - f32 mScaleIncRateX; // _0C - f32 mScaleIncRateY; // _10 - f32 mScaleDecRateX; // _14 - f32 mScaleDecRateY; // _18 + f32 mAlphaIncRate; // _04 + f32 mAlphaDecRate; // _08 + f32 mScaleIncRateX; // _0C + f32 mScaleIncRateY; // _10 + f32 mScaleDecRateX; // _14 + f32 mScaleDecRateY; // _18 }; // In JPABaseShape.cpp: diff --git a/libs/JSystem/JParticle/JPADynamicsBlock.cpp b/libs/JSystem/JParticle/JPADynamicsBlock.cpp index 1c2a25e2..5eeae7cd 100644 --- a/libs/JSystem/JParticle/JPADynamicsBlock.cpp +++ b/libs/JSystem/JParticle/JPADynamicsBlock.cpp @@ -228,8 +228,8 @@ void JPADynamicsBlock::create(JPAEmitterWorkData* work) work->mEmitter->mRateStepTimer -= (work->mEmitter->mRateStep + 1); work->mEmitter->setFlag(JPAEMIT_RateStepEmit); } else { - work->mEmitter->resetFlag(JPAEMIT_RateStepEmit); + work->mEmitter->clearStatus(JPAEMIT_RateStepEmit); } - work->mEmitter->resetFlag(JPAEMIT_FirstEmit); + work->mEmitter->clearStatus(JPAEMIT_FirstEmit); } diff --git a/libs/JSystem/JParticle/JPAEmitter.cpp b/libs/JSystem/JParticle/JPAEmitter.cpp index d3d3e6ca..e1410878 100644 --- a/libs/JSystem/JParticle/JPAEmitter.cpp +++ b/libs/JSystem/JParticle/JPAEmitter.cpp @@ -7,7 +7,7 @@ JPAEmitterCallBack::~JPAEmitterCallBack() { } -void JPABaseEmitter::init(JPAEmitterManager* manager, JPAResource* resource) +void JPABaseEmitter::init(JPAEmitterManager *manager, JPAResource *resource) { mManager = manager; mResource = resource; @@ -54,7 +54,7 @@ void JPABaseEmitter::init(JPAEmitterManager* manager, JPAResource* resource) mRateStepTimer = 0; } -JPABaseParticle* JPABaseEmitter::createParticle() +JPABaseParticle *JPABaseEmitter::createParticle() { if (mPtclPool->mNum != 0) { JPANode* node = mPtclPool->pop_front(); @@ -72,7 +72,7 @@ JPABaseParticle* JPABaseEmitter::createParticle() return nullptr; } -JPABaseParticle* JPABaseEmitter::createChild(JPABaseParticle* parent) +JPABaseParticle *JPABaseEmitter::createChild(JPABaseParticle *parent) { if (mPtclPool->mNum != 0) { JPANode* node = mPtclPool->pop_front(); @@ -136,7 +136,7 @@ bool JPABaseEmitter::processTermination() return false; } -void JPABaseEmitter::calcEmitterGlobalPosition(JGeometry::TVec3f* p1) const +void JPABaseEmitter::calcEmitterGlobalPosition(JGeometry::TVec3f *pos) const { Mtx mtx; PSMTXScale(mtx, mGlobalScl.x, mGlobalScl.y, mGlobalScl.z); @@ -144,7 +144,7 @@ void JPABaseEmitter::calcEmitterGlobalPosition(JGeometry::TVec3f* p1) const mtx[0][3] = mGlobalTrs.x; mtx[1][3] = mGlobalTrs.y; mtx[2][3] = mGlobalTrs.z; - PSMTXMultVec(mtx, (Vec*)&mLocalTrs, (Vec*)p1); + PSMTXMultVec(mtx, &mLocalTrs, pos); } void JPABaseEmitter::getEmitterAxisX(JGeometry::TVec3*) const diff --git a/libs/JSystem/JParticle/JPAEmitterManager.cpp b/libs/JSystem/JParticle/JPAEmitterManager.cpp index 24d80627..203b0723 100644 --- a/libs/JSystem/JParticle/JPAEmitterManager.cpp +++ b/libs/JSystem/JParticle/JPAEmitterManager.cpp @@ -6,9 +6,9 @@ JPAEmitterManager::JPAEmitterManager(u32 ptclNum_, u32 emtrNum_, JKRHeap *heap, u8 groups, u8 resnum) { emtrNum = emtrNum_; - ptclNum = ptclNum_; - gidMax = groups; - ridMax = resnum; + ptclNum = ptclNum_; + gidMax = groups; + ridMax = resnum; #line 40 JUT_ASSERT(emtrNum && ptclNum && gidMax && ridMax); @@ -40,7 +40,7 @@ JPAEmitterManager::JPAEmitterManager(u32 ptclNum_, u32 emtrNum_, JKRHeap *heap, JUT_ASSERT(pWd); } -JPABaseEmitter *JPAEmitterManager::createSimpleEmitterID(const JGeometry::TVec3f& pos, u16 resID, u8 group_id, u8 res_mgr_id, +JPABaseEmitter *JPAEmitterManager::createSimpleEmitterID(const JGeometry::TVec3f &pos, u16 resID, u8 group_id, u8 res_mgr_id, JPAEmitterCallBack *ecback, JPAParticleCallBack *pcback) { #line 88 JUT_ASSERT(group_id < gidMax); diff --git a/libs/JSystem/JParticle/JPAFieldBlock.cpp b/libs/JSystem/JParticle/JPAFieldBlock.cpp index 7a484919..6aa23bd7 100644 --- a/libs/JSystem/JParticle/JPAFieldBlock.cpp +++ b/libs/JSystem/JParticle/JPAFieldBlock.cpp @@ -5,290 +5,290 @@ #include "JSystem/JUtility/JUTAssert.h" #include "types.h" -void JPAFieldBase::calcAffect(JPAFieldBlock* block, JPABaseParticle* particle) +void JPAFieldBase::calcAffect(JPAFieldBlock *block, JPABaseParticle *particle) { - JGeometry::TVec3f vec = _04; - if (!particle->checkStatus(0x4) && block->checkStatus(0x8 | 0x30 | 0x40)) { - vec.scale(calcFadeAffect(block, particle->mTime)); - } - - switch (block->getAddType()) { - case 0: - particle->mVelType0.add(vec); - break; - case 1: - particle->mVelType1.add(vec); - break; - case 2: - particle->mVelType2.add(vec); - break; - } + JGeometry::TVec3f vec = _04; + if (!particle->checkStatus(0x4) && block->checkStatus(0x8 | 0x30 | 0x40)) { + vec.scale(calcFadeAffect(block, particle->mTime)); + } + + switch (block->getAddType()) { + case 0: + particle->mVelType0.add(vec); + break; + case 1: + particle->mVelType1.add(vec); + break; + case 2: + particle->mVelType2.add(vec); + break; + } } -f32 JPAFieldBase::calcFadeAffect(JPAFieldBlock* block, f32 time) const +f32 JPAFieldBase::calcFadeAffect(JPAFieldBlock *block, f32 time) const { - f32 fadeAffect = 1.0f; - if ((block->checkStatus(0x8) && time < block->getEnTime()) || (block->checkStatus(0x10) && time >= block->getDisTime())) { - fadeAffect = 0.0f; + f32 fadeAffect = 1.0f; + if ((block->checkStatus(0x8) && time < block->getEnTime()) || (block->checkStatus(0x10) && time >= block->getDisTime())) { + fadeAffect = 0.0f; - } else if (block->checkStatus(0x40) && time >= block->getFadeOutTime()) { - fadeAffect = (block->getDisTime() - time) * block->getFadeOutRate(); + } else if (block->checkStatus(0x40) && time >= block->getFadeOutTime()) { + fadeAffect = (block->getDisTime() - time) * block->getFadeOutRate(); - } else if (block->checkStatus(0x20) && time < block->getFadeInTime()) { - fadeAffect = (time - block->getEnTime()) * block->getFadeInRate(); - } + } else if (block->checkStatus(0x20) && time < block->getFadeInTime()) { + fadeAffect = (time - block->getEnTime()) * block->getFadeInRate(); + } - return fadeAffect; + return fadeAffect; } -void JPAFieldGravity::prepare(JPAEmitterWorkData* workData, JPAFieldBlock* block) +void JPAFieldGravity::prepare(JPAEmitterWorkData *workData, JPAFieldBlock *block) { - if (block->checkStatus(2)) { - _04.scale(block->getMag(), block->getDir()); - } else { - PSMTXMultVecSR(workData->mRotationMtx, (Vec*)&block->getDir(), (Vec*)&_04); - _04.scale(block->getMag()); - } + if (block->checkStatus(2)) { + _04.scale(block->getMag(), block->getDir()); + } else { + PSMTXMultVecSR(workData->mRotationMtx, (Vec*)&block->getDir(), (Vec*)&_04); + _04.scale(block->getMag()); + } } -void JPAFieldGravity::calc(JPAEmitterWorkData* workData, JPAFieldBlock* block, JPABaseParticle* particle) { calcAffect(block, particle); } +void JPAFieldGravity::calc(JPAEmitterWorkData *workData, JPAFieldBlock *block, JPABaseParticle *particle) { calcAffect(block, particle); } -void JPAFieldAir::prepare(JPAEmitterWorkData* workData, JPAFieldBlock* block) +void JPAFieldAir::prepare(JPAEmitterWorkData *workData, JPAFieldBlock *block) { - JGeometry::TVec3f normVec; - normVec.normalize(block->getDir()); - if (block->checkStatus(2)) { - _04.scale(block->getMag(), normVec); - } else { - PSMTXMultVecSR(workData->mRotationMtx, (Vec*)&normVec, (Vec*)&_04); - _04.scale(block->getMag()); - } + JGeometry::TVec3f normVec; + normVec.normalize(block->getDir()); + if (block->checkStatus(2)) { + _04.scale(block->getMag(), normVec); + } else { + PSMTXMultVecSR(workData->mRotationMtx, (Vec*)&normVec, (Vec*)&_04); + _04.scale(block->getMag()); + } } -void JPAFieldAir::calc(JPAEmitterWorkData* workData, JPAFieldBlock* block, JPABaseParticle* particle) +void JPAFieldAir::calc(JPAEmitterWorkData *workData, JPAFieldBlock *block, JPABaseParticle *particle) { - calcAffect(block, particle); - if (block->checkStatus(4)) { - f32 len = particle->mVelType1.length(); - if (len > block->getMagRndm()) { - particle->mVelType1.scale(block->getMagRndm() / len); - } - } + calcAffect(block, particle); + if (block->checkStatus(4)) { + f32 len = particle->mVelType1.length(); + if (len > block->getMagRndm()) { + particle->mVelType1.scale(block->getMagRndm() / len); + } + } } void JPAFieldMagnet::prepare(JPAEmitterWorkData* data, JPAFieldBlock* block) { - _10.sub(block->getPos(), data->mEmitterPos); - PSMTXMultVecSR(data->mRotationMtx, (Vec*)&_10, (Vec*)&_10); + _10.sub(block->getPos(), data->mEmitterPos); + PSMTXMultVecSR(data->mRotationMtx, (Vec*)&_10, (Vec*)&_10); } -void JPAFieldMagnet::calc(JPAEmitterWorkData* workData, JPAFieldBlock* block, JPABaseParticle* particle) +void JPAFieldMagnet::calc(JPAEmitterWorkData *workData, JPAFieldBlock *block, JPABaseParticle *particle) { - _04.sub(_10, particle->mLocalPosition); - _04.setLength(block->getMag()); - calcAffect(block, particle); + _04.sub(_10, particle->mLocalPosition); + _04.setLength(block->getMag()); + calcAffect(block, particle); } void JPAFieldNewton::prepare(JPAEmitterWorkData* data, JPAFieldBlock* block) { - _10.sub(block->getPos(), data->mEmitterPos); - PSMTXMultVecSR(data->mRotationMtx, (Vec*)&_10, (Vec*)&_10); - _1C = block->getVal1() * block->getVal1(); + _10.sub(block->getPos(), data->mEmitterPos); + PSMTXMultVecSR(data->mRotationMtx, (Vec*)&_10, (Vec*)&_10); + _1C = block->getVal1() * block->getVal1(); } -void JPAFieldNewton::calc(JPAEmitterWorkData* workData, JPAFieldBlock* block, JPABaseParticle* particle) +void JPAFieldNewton::calc(JPAEmitterWorkData *workData, JPAFieldBlock *block, JPABaseParticle *particle) { - _04.sub(_10, particle->mLocalPosition); - f32 sq = _04.squared(); - if (sq > _1C) { - _04.setLength((_1C * (10.0f * block->getMag())) / sq); - } else { - _04.setLength(10.0f * block->getMag()); - } - - calcAffect(block, particle); + _04.sub(_10, particle->mLocalPosition); + f32 sq = _04.squared(); + if (sq > _1C) { + _04.setLength((_1C * (10.0f * block->getMag())) / sq); + } else { + _04.setLength(10.0f * block->getMag()); + } + + calcAffect(block, particle); } -void JPAFieldVortex::prepare(JPAEmitterWorkData* workData, JPAFieldBlock* block) +void JPAFieldVortex::prepare(JPAEmitterWorkData *workData, JPAFieldBlock *block) { - PSMTXMultVecSR(workData->mGlobalRot, (Vec*)&block->getDir(), (Vec*)&_10); - _10.normalize(); - _1C = block->getPos().z * block->getPos().z; - _20 = 1.0f / _1C; + PSMTXMultVecSR(workData->mGlobalRot, (Vec*)&block->getDir(), (Vec*)&_10); + _10.normalize(); + _1C = block->getPos().z * block->getPos().z; + _20 = 1.0f / _1C; } -void JPAFieldVortex::calc(JPAEmitterWorkData* workData, JPAFieldBlock* block, JPABaseParticle* particle) +void JPAFieldVortex::calc(JPAEmitterWorkData *workData, JPAFieldBlock *block, JPABaseParticle *particle) { - JGeometry::TVec3f vec; - vec.scale(_10.dot(particle->mLocalPosition), _10); - vec.sub(particle->mLocalPosition, vec); - - f32 sq = vec.squared(); - if (sq > _1C) - sq = block->getMagRndm(); - else { + JGeometry::TVec3f vec; + vec.scale(_10.dot(particle->mLocalPosition), _10); + vec.sub(particle->mLocalPosition, vec); + + f32 sq = vec.squared(); + if (sq > _1C) + sq = block->getMagRndm(); + else { sq = sq * _20; f32 sqMag = sq * block->getMagRndm(); sq = (1.0f - sq) * block->getMag() + sqMag; } - + - vec.normalize(); - _04.cross(vec, _10); - _04.scale(sq); + vec.normalize(); + _04.cross(vec, _10); + _04.scale(sq); - calcAffect(block, particle); + calcAffect(block, particle); } -void JPAFieldConvection::prepare(JPAEmitterWorkData* workData, JPAFieldBlock* block) +void JPAFieldConvection::prepare(JPAEmitterWorkData *workData, JPAFieldBlock *block) { - JGeometry::TVec3f vec1; // 0x14 - JGeometry::TVec3f vec2; // 0x8 - - vec2.cross(block->getPos(), block->getDir()); - vec1.cross(block->getDir(), vec2); - PSMTXMultVecSR(workData->mGlobalRot, (Vec*)&vec1, (Vec*)&_10); - PSMTXMultVecSR(workData->mGlobalRot, (Vec*)&block->getDir(), (Vec*)&_1C); - PSMTXMultVecSR(workData->mGlobalRot, (Vec*)&vec2, (Vec*)&_28); - _10.normalize(); - _1C.normalize(); - _28.normalize(); + JGeometry::TVec3f vec1; // 0x14 + JGeometry::TVec3f vec2; // 0x8 + + vec2.cross(block->getPos(), block->getDir()); + vec1.cross(block->getDir(), vec2); + PSMTXMultVecSR(workData->mGlobalRot, (Vec*)&vec1, (Vec*)&_10); + PSMTXMultVecSR(workData->mGlobalRot, (Vec*)&block->getDir(), (Vec*)&_1C); + PSMTXMultVecSR(workData->mGlobalRot, (Vec*)&vec2, (Vec*)&_28); + _10.normalize(); + _1C.normalize(); + _28.normalize(); } -void JPAFieldConvection::calc(JPAEmitterWorkData* workData, JPAFieldBlock* block, JPABaseParticle* particle) +void JPAFieldConvection::calc(JPAEmitterWorkData *workData, JPAFieldBlock *block, JPABaseParticle *particle) { - JGeometry::TVec3f vec1; // 0x20 - JGeometry::TVec3f vec2; // 0x14 - JGeometry::TVec3f vec3; // 0x8 - - vec1.scale(_10.dot(particle->mLocalPosition), _10); - vec3.scale(_28.dot(particle->mLocalPosition), _28); - vec1.add(vec3); - vec1.setLength(vec1, block->getVal1()); - vec2.sub(particle->mLocalPosition, vec1); - vec3.cross(_1C, vec1); - _04.cross(vec3, vec2); - _04.setLength(block->getMag()); - - calcAffect(block, particle); + JGeometry::TVec3f vec1; // 0x20 + JGeometry::TVec3f vec2; // 0x14 + JGeometry::TVec3f vec3; // 0x8 + + vec1.scale(_10.dot(particle->mLocalPosition), _10); + vec3.scale(_28.dot(particle->mLocalPosition), _28); + vec1.add(vec3); + vec1.setLength(vec1, block->getVal1()); + vec2.sub(particle->mLocalPosition, vec1); + vec3.cross(_1C, vec1); + _04.cross(vec3, vec2); + _04.setLength(block->getMag()); + + calcAffect(block, particle); } -void JPAFieldRandom::calc(JPAEmitterWorkData* workData, JPAFieldBlock* block, JPABaseParticle* particle) +void JPAFieldRandom::calc(JPAEmitterWorkData *workData, JPAFieldBlock *block, JPABaseParticle *particle) { - if (!particle->mAge || (block->getCycle() && particle->mAge % block->getCycle() == 0)) { - JPABaseEmitter* emitter = workData->mEmitter; - _04.set(emitter->getRandZH(), emitter->getRandZH(), emitter->getRandZH()); - _04.scale(block->getMag()); - calcAffect(block, particle); - } + if (!particle->mAge || (block->getCycle() && particle->mAge % block->getCycle() == 0)) { + JPABaseEmitter* emitter = workData->mEmitter; + _04.set(emitter->getRandZH(), emitter->getRandZH(), emitter->getRandZH()); + _04.scale(block->getMag()); + calcAffect(block, particle); + } } -void JPAFieldDrag::calc(JPAEmitterWorkData* workData, JPAFieldBlock* block, JPABaseParticle* particle) +void JPAFieldDrag::calc(JPAEmitterWorkData *workData, JPAFieldBlock *block, JPABaseParticle *particle) { - if (!particle->checkStatus(4)) { - f32 fadeAffect = calcFadeAffect(block, particle->mTime); - particle->mDrag *= 1.0f - fadeAffect * (1.0f - block->getMag()); - } else { - particle->mDrag *= block->getMag(); - } + if (!particle->checkStatus(4)) { + f32 fadeAffect = calcFadeAffect(block, particle->mTime); + particle->mDrag *= 1.0f - fadeAffect * (1.0f - block->getMag()); + } else { + particle->mDrag *= block->getMag(); + } } -void JPAFieldSpin::prepare(JPAEmitterWorkData* workData, JPAFieldBlock* block) +void JPAFieldSpin::prepare(JPAEmitterWorkData *workData, JPAFieldBlock *block) { - JGeometry::TVec3f vec; - PSMTXMultVecSR(workData->mGlobalRot, (Vec*)&block->getDir(), (Vec*)&vec); - vec.normalize(); - Mtx mtx; - PSMTXRotAxisRad(mtx, (Vec*)&vec, block->getMag()); - _10.set(mtx[0][0], mtx[1][0], mtx[2][0]); - _1C.set(mtx[0][1], mtx[1][1], mtx[2][1]); - _28.set(mtx[0][2], mtx[1][2], mtx[2][2]); + JGeometry::TVec3f vec; + PSMTXMultVecSR(workData->mGlobalRot, (Vec*)&block->getDir(), (Vec*)&vec); + vec.normalize(); + Mtx mtx; + PSMTXRotAxisRad(mtx, (Vec*)&vec, block->getMag()); + _10.set(mtx[0][0], mtx[1][0], mtx[2][0]); + _1C.set(mtx[0][1], mtx[1][1], mtx[2][1]); + _28.set(mtx[0][2], mtx[1][2], mtx[2][2]); } -void JPAFieldSpin::calc(JPAEmitterWorkData* workData, JPAFieldBlock* block, JPABaseParticle* particle) +void JPAFieldSpin::calc(JPAEmitterWorkData *workData, JPAFieldBlock *block, JPABaseParticle *particle) { - Mtx mtx; - mtx[0][0] = _10.x; - mtx[1][0] = _10.y; - mtx[2][0] = _10.z; - mtx[0][1] = _1C.x; - mtx[1][1] = _1C.y; - mtx[2][1] = _1C.z; - mtx[0][2] = _28.x; - mtx[1][2] = _28.y; - mtx[2][2] = _28.z; - mtx[0][3] = mtx[1][3] = mtx[2][3] = 0.0f; - Vec outVec; - PSMTXMultVecSR(mtx, (Vec*)&particle->mLocalPosition, &outVec); - _04.set(outVec.x - particle->mLocalPosition.x, outVec.y - particle->mLocalPosition.y, outVec.z - particle->mLocalPosition.z); - calcAffect(block, particle); + Mtx mtx; + mtx[0][0] = _10.x; + mtx[1][0] = _10.y; + mtx[2][0] = _10.z; + mtx[0][1] = _1C.x; + mtx[1][1] = _1C.y; + mtx[2][1] = _1C.z; + mtx[0][2] = _28.x; + mtx[1][2] = _28.y; + mtx[2][2] = _28.z; + mtx[0][3] = mtx[1][3] = mtx[2][3] = 0.0f; + Vec outVec; + PSMTXMultVecSR(mtx, (Vec*)&particle->mLocalPosition, &outVec); + _04.set(outVec.x - particle->mLocalPosition.x, outVec.y - particle->mLocalPosition.y, outVec.z - particle->mLocalPosition.z); + calcAffect(block, particle); } -JPAFieldBlock::JPAFieldBlock(const u8* data, JKRHeap* heap) +JPAFieldBlock::JPAFieldBlock(const u8 *data, JKRHeap *heap) { - mData = reinterpret_cast(data); - init(heap); + mData = reinterpret_cast(data); + init(heap); } void JPAFieldBlock::init_jpa(const u8*, JKRHeap*) { - // UNUSED FUNCTION + // UNUSED FUNCTION } void JPAFieldBlock::init(JKRHeap* heap) { - mFadeInRate = getFadeInTime() - getEnTime(); - if (mFadeInRate == 0.0f) { - mFadeInRate = 1.0f; - } else { - mFadeInRate = 1.0f / mFadeInRate; - } - - mFadeOutRate = getDisTime() - getFadeOutTime(); - if (mFadeOutRate == 0.0f) { - mFadeOutRate = 1.0f; - } else { - mFadeOutRate = 1.0f / mFadeOutRate; - } - - getPosOrig(&mOffset); - getDirOrig(&mVelocity); - mSpeed = getMagOrig(); - - switch (getType()) { - case JPAFIELD_Gravity: - pFld = new (heap, 0) JPAFieldGravity; - break; - case JPAFIELD_Air: - pFld = new (heap, 0) JPAFieldAir; - break; - case JPAFIELD_Magnet: - pFld = new (heap, 0) JPAFieldMagnet; - break; - case JPAFIELD_Newton: - pFld = new (heap, 0) JPAFieldNewton; - break; - case JPAFIELD_Vortex: - pFld = new (heap, 0) JPAFieldVortex; - break; - case JPAFIELD_Random: - pFld = new (heap, 0) JPAFieldRandom; - break; - case JPAFIELD_Drag: - pFld = new (heap, 0) JPAFieldDrag; - break; - case JPAFIELD_Convection: - pFld = new (heap, 0) JPAFieldConvection; - break; - case JPAFIELD_Spin: - pFld = new (heap, 0) JPAFieldSpin; - break; - default: - pFld = nullptr; + mFadeInRate = getFadeInTime() - getEnTime(); + if (mFadeInRate == 0.0f) { + mFadeInRate = 1.0f; + } else { + mFadeInRate = 1.0f / mFadeInRate; + } + + mFadeOutRate = getDisTime() - getFadeOutTime(); + if (mFadeOutRate == 0.0f) { + mFadeOutRate = 1.0f; + } else { + mFadeOutRate = 1.0f / mFadeOutRate; + } + + getPosOrig(&mOffset); + getDirOrig(&mVelocity); + mSpeed = getMagOrig(); + + switch (getType()) { + case JPAFIELD_Gravity: + pFld = new (heap, 0) JPAFieldGravity; + break; + case JPAFIELD_Air: + pFld = new (heap, 0) JPAFieldAir; + break; + case JPAFIELD_Magnet: + pFld = new (heap, 0) JPAFieldMagnet; + break; + case JPAFIELD_Newton: + pFld = new (heap, 0) JPAFieldNewton; + break; + case JPAFIELD_Vortex: + pFld = new (heap, 0) JPAFieldVortex; + break; + case JPAFIELD_Random: + pFld = new (heap, 0) JPAFieldRandom; + break; + case JPAFIELD_Drag: + pFld = new (heap, 0) JPAFieldDrag; + break; + case JPAFIELD_Convection: + pFld = new (heap, 0) JPAFieldConvection; + break; + case JPAFIELD_Spin: + pFld = new (heap, 0) JPAFieldSpin; + break; + default: + pFld = nullptr; #line 483 JUT_WARNING_F2("JPA : WRONG ID (%d) in field data\n", getType()); - break; - } + break; + } #line 485 JUT_ASSERT(pFld != 0); } diff --git a/libs/JSystem/JParticle/JPAParticle.cpp b/libs/JSystem/JParticle/JPAParticle.cpp index dcf55524..23075526 100644 --- a/libs/JSystem/JParticle/JPAParticle.cpp +++ b/libs/JSystem/JParticle/JPAParticle.cpp @@ -20,7 +20,7 @@ void JPABaseParticle::init_p(JPAEmitterWorkData *workData) mLifeTime = (f32)emitter->mLifeTime * (1.0f - dynamicsBlock->mData->mLifeTimeRndm * emitter->mRandom.getRandF32()); mTime = 0.0f; initStatus(0); - PSMTXMultVecSR(workData->mGlobalSR, (Vec*)&workData->mVolumePos, (Vec*)&mLocalPosition); + PSMTXMultVecSR(workData->mGlobalSR, &workData->mVolumePos, &mLocalPosition); if (emitter->checkDynFlag(8)) { setStatus(0x20); } @@ -69,7 +69,7 @@ void JPABaseParticle::init_p(JPAEmitterWorkData *workData) mVelType1.mul(emitter->mLocalScl); } - PSMTXMultVecSR(workData->mGlobalRot, (Vec*)&mVelType1, (Vec*)&mVelType1); + PSMTXMultVecSR(workData->mGlobalRot, &mVelType1, &mVelType1); mVelType0.zero(); mMoment = 1.0f - (dynamicsBlock->getMomentRndm() * emitter->getRandF32()); mDrag = 1.0f; diff --git a/libs/JSystem/JParticle/JPAResource.cpp b/libs/JSystem/JParticle/JPAResource.cpp index 5d33ec00..fc90edf6 100644 --- a/libs/JSystem/JParticle/JPAResource.cpp +++ b/libs/JSystem/JParticle/JPAResource.cpp @@ -4,655 +4,713 @@ #include "JSystem/JParticle/JPAMath.h" #include "JSystem/JParticle/JPAShape.h" #include "JSystem/JUtility/JUTAssert.h" +#include "macros.h" -// this might be a group of smaller arrays -// it for sure is -u8 jpa_pos[] +// this most likely is some struct +u8 jpa_pos[0x160] ALIGN(32) = { 00, 00, 00, 0x32, 00, 00, 0x32, 0xCE, 00, 00, 0xCE, 00, 0xE7, 00, 00, 0x19, 00, 00, 0x19, 0xCE, 00, 0xE7, - 0xCE, 00, 0xCE, 00, 00, 00, 00, 00, 00, 0xCE, 00, 0xCE, 0xCE, 00, 00, 0x19, 00, 0x32, 0x19, 00, 0x32, 0xE7, - 00, 00, 0xE7, 00, 0xE7, 0x19, 00, 0x19, 0x19, 00, 0x19, 0xE7, 00, 0xE7, 0xE7, 00, 0xCE, 0x19, 00, 00, 0x19, 00, - 00, 0xE7, 00, 0xCE, 0xE7, 00, 00, 0x32, 00, 0x32, 0x32, 00, 0x32, 00, 00, 00, 00, 00, 0xE7, 0x32, 00, 0x19, - 0x32, 00, 0x19, 00, 00, 0xE7, 00, 00, 0xCE, 0x32, 00, 00, 0x32, 00, 00, 00, 00, 0xCE, 00, 00, 00, 00, - 00, 0x32, 00, 00, 0x32, 00, 0x32, 00, 00, 0x32, 0xE7, 00, 00, 0x19, 00, 00, 0x19, 00, 0x32, 0xE7, 00, 0x32, - 0xCE, 00, 00, 00, 00, 00, 00, 00, 0x32, 0xCE, 00, 0x32, 00, 00, 0xE7, 0x32, 00, 0xE7, 0x32, 00, 0x19, 00, - 00, 0x19, 0xE7, 00, 0xE7, 0x19, 00, 0xE7, 0x19, 00, 0x19, 0xE7, 00, 0x19, 0xCE, 00, 0xE7, 00, 00, 0xE7, 00, 00, - 0x19, 0xCE, 00, 0x19, 00, 00, 0xCE, 0x32, 00, 0xCE, 0x32, 00, 00, 00, 00, 00, 0xE7, 00, 0xCE, 0x19, 00, 0xCE, - 0x19, 00, 00, 0xE7, 00, 00, 0xCE, 00, 0xCE, 00, 00, 0xCE, 00, 00, 00, 0xCE, 00, 00, 00, 00, 00, 00, - 00, 0x32, 00, 0xCE, 0x32, 00, 0xCE, 00, 00, 00, 0xE7, 00, 00, 0x19, 00, 0xCE, 0x19, 00, 0xCE, 0xE7, 00, 00, - 0xCE, 00, 00, 00, 00, 0xCE, 00, 00, 0xCE, 0xCE, 00, 0x19, 00, 00, 0x19, 0x32, 00, 0xE7, 0x32, 00, 0xE7, 00, - 00, 0x19, 0xE7, 00, 0x19, 0x19, 00, 0xE7, 0x19, 00, 0xE7, 0xE7, 00, 0x19, 0xCE, 00, 0x19, 00, 00, 0xE7, 00, 00, - 0xE7, 0xCE, 00, 0x32, 00, 00, 0x32, 0x32, 00, 00, 0x32, 00, 00, 00, 00, 0x32, 0xE7, 00, 0x32, 0x19, 00, 00, - 0x19, 00, 00, 0xE7, 00, 0x32, 0xCE, 00, 0x32, 00, 00, 00, 00, 00, 00, 0xCE, 00, 00, 00, 00, 00, 00, - 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00 }; - -u8 jpa_crd[] = { 0, 0, 1, 0, 1, 1, 0, 1, 0, 0, 2, 0, 2, 1, 0, 1, 0, 0, 1, 0, 1, 2, 0, 2, 0, 0, 2, 0, 2, 2, 0, 2 }; + 0xCE, 00, 0xCE, 00, 00, 00, 00, 00, 00, 0xCE, 00, 0xCE, 0xCE, 00, 00, 0x19, 00, 0x32, 0x19, 00, 0x32, 0xE7, + 00, 00, 0xE7, 00, 0xE7, 0x19, 00, 0x19, 0x19, 00, 0x19, 0xE7, 00, 0xE7, 0xE7, 00, 0xCE, 0x19, 00, 00, 0x19, 00, + 00, 0xE7, 00, 0xCE, 0xE7, 00, 00, 0x32, 00, 0x32, 0x32, 00, 0x32, 00, 00, 00, 00, 00, 0xE7, 0x32, 00, 0x19, + 0x32, 00, 0x19, 00, 00, 0xE7, 00, 00, 0xCE, 0x32, 00, 00, 0x32, 00, 00, 00, 00, 0xCE, 00, 00, 00, 00, + 00, 0x32, 00, 00, 0x32, 00, 0x32, 00, 00, 0x32, 0xE7, 00, 00, 0x19, 00, 00, 0x19, 00, 0x32, 0xE7, 00, 0x32, + 0xCE, 00, 00, 00, 00, 00, 00, 00, 0x32, 0xCE, 00, 0x32, 00, 00, 0xE7, 0x32, 00, 0xE7, 0x32, 00, 0x19, 00, + 00, 0x19, 0xE7, 00, 0xE7, 0x19, 00, 0xE7, 0x19, 00, 0x19, 0xE7, 00, 0x19, 0xCE, 00, 0xE7, 00, 00, 0xE7, 00, 00, + 0x19, 0xCE, 00, 0x19, 00, 00, 0xCE, 0x32, 00, 0xCE, 0x32, 00, 00, 00, 00, 00, 0xE7, 00, 0xCE, 0x19, 00, 0xCE, + 0x19, 00, 00, 0xE7, 00, 00, 0xCE, 00, 0xCE, 00, 00, 0xCE, 00, 00, 00, 0xCE, 00, 00, 00, 00, 00, 00, + 00, 0x32, 00, 0xCE, 0x32, 00, 0xCE, 00, 00, 00, 0xE7, 00, 00, 0x19, 00, 0xCE, 0x19, 00, 0xCE, 0xE7, 00, 00, + 0xCE, 00, 00, 00, 00, 0xCE, 00, 00, 0xCE, 0xCE, 00, 0x19, 00, 00, 0x19, 0x32, 00, 0xE7, 0x32, 00, 0xE7, 00, + 00, 0x19, 0xE7, 00, 0x19, 0x19, 00, 0xE7, 0x19, 00, 0xE7, 0xE7, 00, 0x19, 0xCE, 00, 0x19, 00, 00, 0xE7, 00, 00, + 0xE7, 0xCE, 00, 0x32, 00, 00, 0x32, 0x32, 00, 00, 0x32, 00, 00, 00, 00, 0x32, 0xE7, 00, 0x32, 0x19, 00, 00, + 0x19, 00, 00, 0xE7, 00, 0x32, 0xCE, 00, 0x32, 00, 00, 00, 00, 00, 00, 0xCE, 00, 00, 00, 00, 00, 00, + 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00 }; + +u8 jpa_crd[32] = { 0, 0, 1, 0, 1, 1, 0, 1, 0, 0, 2, 0, 2, 1, 0, 1, 0, 0, 1, 0, 1, 2, 0, 2, 0, 0, 2, 0, 2, 2, 0, 2 }; JPAResource::JPAResource() { - mDrawEmitterChildFuncList = nullptr; - mDrawEmitterFuncList = nullptr; - mCalcEmitterFuncList = nullptr; - mDrawParticleChildFuncList = nullptr; - mCalcParticleChildFuncList = nullptr; - mDrawParticleFuncList = nullptr; - mCalcParticleFuncList = nullptr; - pBsp = nullptr; - pEsp = nullptr; - pCsp = nullptr; - pEts = nullptr; - pDyn = nullptr; - ppFld = nullptr; - ppKey = nullptr; - texIdxTbl = nullptr; - mDrawParticleChildFuncListNum = 0; - mCalcParticleChildFuncListNum = 0; - mDrawParticleFuncListNum = 0; - mCalcParticleFuncListNum = 0; - mDrawEmitterChildFuncListNum = 0; - mDrawEmitterFuncListNum = 0; - mCalcEmitterFuncListNum = 0; - texNum = 0; - keyNum = 0; - fldNum = 0; - mUsrIdx = 0; + mDrawEmitterChildFuncList = nullptr; + mDrawEmitterFuncList = nullptr; + mCalcEmitterFuncList = nullptr; + mDrawParticleChildFuncList = nullptr; + mCalcParticleChildFuncList = nullptr; + mDrawParticleFuncList = nullptr; + mCalcParticleFuncList = nullptr; + pBsp = nullptr; + pEsp = nullptr; + pCsp = nullptr; + pEts = nullptr; + pDyn = nullptr; + ppFld = nullptr; + ppKey = nullptr; + texIdxTbl = nullptr; + mDrawParticleChildFuncListNum = 0; + mCalcParticleChildFuncListNum = 0; + mDrawParticleFuncListNum = 0; + mCalcParticleFuncListNum = 0; + mDrawEmitterChildFuncListNum = 0; + mDrawEmitterFuncListNum = 0; + mCalcEmitterFuncListNum = 0; + texNum = 0; + keyNum = 0; + fldNum = 0; + mUsrIdx = 0; } -/** - * @note Address: 0x8009565C - * @note Size: 0x1540 - */ -void JPAResource::init(JKRHeap* heap) + // pBsp->isGlblTexAnm(); is typed u32, which i guess is a fakematch + // it's more likely some member or another temp is u32 instead of int +void JPAResource::init(JKRHeap *heap) { - JPAExtraShape* exShape = pEsp; - const JPABaseShapeData* shpData = pBsp->pBsd; - - u32 shpFlags = shpData->mFlags; - u8 clrFlag = shpData->mClrFlg; - u8 texFlag = shpData->mTexFlg; - u8 isGlblClrAnm = shpFlags & 0x1000; - u8 isGlblTexAnm = shpFlags & 0x4000; - u8 isTexCrdAnm = shpFlags & 0x1000000; - u8 isPrjTex = shpFlags & 0x100000; - - bool exShapeSet1 = false; - if (exShape && exShape->mData->mFlags & 1) { - exShapeSet1 = true; - } - - bool exShapeSet2 = false; - if (exShape && exShape->mData->mFlags & 0x10000) { - exShapeSet2 = true; - } - - bool exShapeSet3 = false; - if (exShape && (exShape->mData->mFlags & 0x10000) && (exShape->mData->mFlags & 0x20000)) { - exShapeSet3 = true; - } - - bool exShapeSet4 = false; - if (exShape && exShape->mData->mFlags & 0x1000000) { - exShapeSet4 = true; - } - - bool exShapeSet5 = false; - if (exShapeSet4 || (pCsp && pCsp->mData->mFlags & 0x1000000)) { - exShapeSet5 = true; - } - - u8 shpType = shpFlags & 0xf; - bool test = true; - if (shpType != 5 && shpType != 6) { - test = false; - } - // skipping some dumb stuff for now - - if (isGlblTexAnm && (texFlag & 1)) { - mCalcEmitterFuncListNum++; - } - if (isGlblClrAnm) { - if (clrFlag & 2) { - mCalcEmitterFuncListNum++; - } - if (clrFlag & 8) { - mCalcEmitterFuncListNum++; - } - if ((clrFlag & 2) || (clrFlag & 8)) { - mCalcEmitterFuncListNum++; - } - } - if (mCalcParticleFuncListNum) { - mCalcEmitterFuncList = (JPAFunctionA**)heap->alloc(mCalcParticleChildFuncListNum * 4, 4); - } - - int idx = 0; - if (isGlblTexAnm && (texFlag & 1)) { - switch (pBsp->getTexAnmType()) { - case 0: - mCalcEmitterFuncList[0] = JPACalcTexIdxNormal; - break; - case 1: - mCalcEmitterFuncList[0] = JPACalcTexIdxRepeat; - break; - case 2: - mCalcEmitterFuncList[0] = JPACalcTexIdxReverse; - break; - case 3: - mCalcEmitterFuncList[0] = JPACalcTexIdxMerge; - break; - case 4: - mCalcEmitterFuncList[0] = JPACalcTexIdxRandom; - break; - } - idx = 1; - } - - if (isGlblClrAnm) { - int i = idx; - if (clrFlag & 2) { - i = idx + 1; - mCalcParticleChildFuncList[idx] = JPACalcPrm; - } - idx = i; - if (clrFlag & 8) { - idx = i + 1; - mCalcParticleChildFuncList[idx] = JPACalcEnv; - } - if ((clrFlag & 2) || (clrFlag & 8)) { - switch (pBsp->getTexAnmType()) { - case 0: - mCalcEmitterFuncList[idx] = JPACalcTexIdxNormal; - break; - case 1: - mCalcEmitterFuncList[idx] = JPACalcTexIdxRepeat; - break; - case 2: - mCalcEmitterFuncList[idx] = JPACalcTexIdxReverse; - break; - case 3: - mCalcEmitterFuncList[idx] = JPACalcTexIdxMerge; - break; - case 4: - mCalcEmitterFuncList[idx] = JPACalcTexIdxRandom; - break; - } - } - } - - // determin number of particle callbacks - if (!isGlblTexAnm && (texFlag & 1)) { - mCalcParticleFuncListNum++; - } - if ((!test) && (exShapeSet2 || exShapeSet3)) { - mCalcParticleFuncListNum++; - } - if (isGlblClrAnm) { - if (clrFlag & 2) { - mCalcParticleFuncListNum++; - } - if (clrFlag & 8) { - mCalcParticleFuncListNum++; - } - if (clrFlag & 2 || clrFlag & 8) { - mCalcParticleFuncListNum++; - } - } else { - mCalcParticleFuncListNum++; - } - if (exShapeSet1) { - if (pBsp->getType() != 0) { - u32 type = pBsp->getType(); - if (!(type & 2)) { - mCalcParticleFuncListNum++; - } else if (!(type >> 8 & 3) && !(type >> 10 & 3)) { - mCalcParticleFuncListNum++; - } else { - mCalcParticleFuncListNum++; - mCalcParticleFuncListNum++; - } - } - mCalcParticleFuncListNum++; - mCalcParticleFuncListNum++; - } - // allocate particle callbacks - if (mCalcParticleChildFuncListNum != 0) { - mCalcParticleFuncList = (JPAFunctionB**)heap->alloc(mCalcParticleFuncListNum * 4, 4); - } - - // set particle callback functions - idx = 0; - if (!isGlblTexAnm && (texFlag & 1)) { - switch (pBsp->getTexAnmType()) { - case 0: - mCalcParticleFuncList[0] = JPACalcTexIdxNormal; - break; - case 1: - mCalcParticleFuncList[0] = JPACalcTexIdxRepeat; - break; - case 2: - mCalcParticleFuncList[0] = JPACalcTexIdxReverse; - break; - case 3: - mCalcParticleFuncList[0] = JPACalcTexIdxMerge; - break; - case 4: - mCalcParticleFuncList[0] = JPACalcTexIdxRandom; - break; - } - idx = 1; - } - - { - int i = idx; - if (!test && (exShapeSet2 || exShapeSet3)) { - if (exShapeSet3) { - i = idx + 1; - mCalcParticleFuncList[idx] = JPACalcAlphaFlickAnm; - } else { - idx = i + 1; - mCalcParticleFuncList[idx] = JPACalcAlphaAnm; - } - } - - if (!isGlblClrAnm) { - int i = idx; - if (clrFlag & 2) { - i = idx + 1; - mCalcParticleFuncList[idx] = JPACalcPrm; - } - idx = i; - if (clrFlag & 8) { - idx = i + 1; - mCalcParticleFuncList[idx] = JPACalcEnv; - } - if ((clrFlag & 2) || (clrFlag & 8)) { - switch (pBsp->getTexAnmType()) { - case 0: - mCalcParticleFuncList[idx] = JPACalcClrIdxNormal; - break; - case 1: - mCalcParticleFuncList[idx] = JPACalcClrIdxRepeat; - break; - case 2: - mCalcParticleFuncList[idx] = JPACalcClrIdxReverse; - break; - case 3: - mCalcParticleFuncList[idx] = JPACalcClrIdxMerge; - break; - case 4: - mCalcParticleFuncList[idx] = JPACalcClrIdxRandom; - break; - } - } - } else { - mCalcParticleFuncList[idx] = JPACalcColorCopy; - } - } - - if (exShapeSet1) { - if (pBsp->getType()) { - if (pBsp->pBsd->mFlags & 2) { - mCalcParticleFuncList[idx] = JPACalcScaleY; - switch (pBsp->getTexAnmType()) { - case 0: - mCalcParticleFuncList[idx] = JPACalcScaleAnmNormal; - break; - case 1: - mCalcParticleFuncList[idx] = JPACalcScaleAnmRepeatY; - break; - case 2: - mCalcParticleFuncList[idx] = JPACalcScaleAnmReverseY; - break; - } - } else { - mCalcParticleFuncList[idx] = JPACalcScaleCopy; - } - idx += 2; - } - mCalcParticleFuncList[idx] = JPACalcScaleX; - switch (pBsp->getTexAnmType()) { - case 0: - mCalcParticleFuncList[idx] = JPACalcScaleAnmNormal; - break; - case 1: - mCalcParticleFuncList[idx] = JPACalcScaleAnmRepeatX; - break; - case 2: - mCalcParticleFuncList[idx] = JPACalcScaleAnmReverseX; - break; - } - } - - if (pCsp && pCsp->mData->mFlags & 0x40000) { - mCalcParticleChildFuncListNum++; - } - if (pCsp && pCsp->mData->mFlags & 0x80000) { - mCalcParticleChildFuncListNum++; - } - if (mCalcParticleChildFuncListNum) { - mCalcParticleChildFuncList = (JPAFunctionB**)heap->alloc(mCalcParticleChildFuncListNum * 4, 4); - } - idx = 0; - if (pCsp && pCsp->mData->mFlags & 0x40000) { - idx = 1; - mCalcParticleChildFuncList[0] = JPACalcChildScaleOut; - } - if (pCsp && pCsp->mData->mFlags & 0x80000) { - idx = 1; - mCalcParticleChildFuncList[0] = JPACalcChildAlphaOut; - } - - if (test) { - mDrawEmitterFuncListNum++; - } - mDrawEmitterFuncListNum++; - if (pEts) { - mDrawEmitterFuncListNum++; - } - if (isGlblTexAnm || !(texFlag & 1)) { - mDrawEmitterFuncListNum++; - } - mDrawEmitterFuncListNum++; - if (!test) { - mDrawEmitterFuncListNum++; - if (!exShapeSet1) { - mDrawEmitterFuncListNum++; - } - } - if (isGlblClrAnm || (!(clrFlag & 2) && !exShapeSet2) || !(clrFlag & 8)) { - mDrawEmitterFuncListNum++; - } - if (mDrawEmitterFuncListNum) { - mDrawEmitterFuncList = (JPAFunctionA**)heap->alloc(mDrawEmitterFuncListNum * 4, 4); - } - - if (test) { - if (pBsp->getType() == 5) { - idx = 1; - mDrawEmitterFuncList[0] = JPADrawStripe; - } else { - idx = 1; - mDrawEmitterFuncList[0] = JPADrawStripeX; - } - } - mDrawEmitterFuncList[0] = JPADrawEmitterCallBackB; - if (pEts) { - mDrawEmitterFuncList[idx + 1] = JPALoadExTex; - } - if (!(texFlag & 1)) { - mDrawEmitterFuncList[idx + 1] = JPALoadTex; - } else if (isGlblTexAnm) { - mDrawEmitterFuncList[idx + 1] = JPALoadTexAnm; - } - - if (!test) { - mDrawEmitterFuncList[idx] = JPAGenTexCrdMtxIdt; - } else if (isPrjTex) { - mDrawEmitterFuncList[idx] = JPAGenTexCrdMtxPrj; - } else if (test) { - mDrawEmitterFuncList[idx] = JPAGenCalcTexCrdMtxAnm; - } else if (isTexCrdAnm) { - mDrawEmitterFuncList[idx] = JPAGenTexCrdMtxAnm; - } else { - mDrawEmitterFuncList[idx] = JPAGenTexCrdMtxIdt; - } - - if (!test) { - mDrawEmitterFuncList[idx + 1] = JPALoadPosMtxCam; - if (!exShapeSet1) { - if (exShapeSet2) { - mDrawEmitterFuncList[idx] = JPASetPointSize; - } else { - mDrawEmitterFuncList[idx] = JPASetLineWidth; - } - } - } - - if (!test) { - mDrawEmitterFuncList[idx + 1] = JPALoadPosMtxCam; - if (!exShapeSet1) { - if (exShapeSet2) { - mDrawEmitterFuncList[idx] = JPASetPointSize; - } else { - mDrawEmitterFuncList[idx] = JPASetLineWidth; - } - } - } - - if (isGlblClrAnm == 0) { - if ((clrFlag & 2) || exShapeSet2) { - if (!(clrFlag & 8)) { - mDrawEmitterFuncList[idx] = JPARegistEnv; - } - } else if (!(clrFlag & 8)) { - mDrawEmitterFuncList[idx] = JPARegistPrmEnv; - } else { - mDrawEmitterFuncList[idx] = JPARegistPrm; - } - } else if (test || !exShapeSet2) { - mDrawEmitterFuncList[idx] = JPARegistPrmEnv; - } else if (exShapeSet2) { - mDrawEmitterFuncList[idx] = JPARegistEnv; - } - - if (shpFlags && test) { - mDrawEmitterChildFuncListNum++; - } - mDrawEmitterChildFuncListNum++; - if (test) { - mDrawEmitterChildFuncListNum++; - } - if (pCsp && !(pCsp->mData->mFlags & 0x80000) && !(pCsp->mData->mFlags & 0x20000) - && !(pCsp->mData->mFlags & 0x40000)) { - mDrawEmitterChildFuncListNum++; - } - if (mDrawEmitterChildFuncListNum) { - mDrawEmitterChildFuncList = (JPAFunctionA**)heap->alloc(mDrawEmitterChildFuncListNum * 4, 4); - } - idx = 0; - if (shpFlags && test) { - if ((pCsp->mData->mFlags & 0xf) == 5) { - idx = 1; - mDrawEmitterChildFuncList[0] = JPADrawStripe; - } else { - idx = 1; - mDrawEmitterChildFuncList[0] = JPADrawStripeX; - } - } - mDrawEmitterChildFuncList[idx] = JPADrawEmitterCallBackB; - if (test) { - mDrawEmitterChildFuncList[idx] = JPALoadPosMtxCam; - } - if (pCsp && !(pCsp->mData->mFlags & 0x800000) && !(pCsp->mData->mFlags & 0x200000) - && !(pCsp->mData->mFlags & 0x400000)) { - mDrawEmitterChildFuncList[idx] = JPARegistChildPrmEnv; - } - - if (test) { - mDrawParticleFuncListNum++; - } - mDrawParticleFuncListNum++; - if (!isGlblTexAnm && (texFlag & 1)) { - mDrawParticleFuncListNum++; - } - if ((!test && exShapeSet1) || (isTexCrdAnm && !isPrjTex)) { - mDrawParticleFuncListNum++; - } - if (!isGlblClrAnm && (clrFlag & 2) || (clrFlag & 8) || exShapeSet2 || (isGlblClrAnm && exShapeSet2) && !test) { - mDrawParticleFuncListNum++; - } - if (mDrawParticleFuncListNum) { - mDrawParticleFuncList = (JPAFunctionB**)heap->alloc(mDrawParticleFuncListNum * 4, 4); - } - if (test) { - switch (pBsp->getType()) { - case 0: - mDrawParticleFuncList[0] = JPADrawPoint; - break; - case 1: - mDrawParticleFuncList[0] = JPADrawLine; - break; - case 2: - if (exShapeSet4) - mDrawParticleFuncList[0] = JPADrawRotBillboard; - else - mDrawParticleFuncList[0] = JPADrawBillboard; - break; - case 3: - case 4: - if (exShapeSet4) { - mDrawParticleFuncList[0] = JPADrawRotDirection; - } else { - mDrawParticleFuncList[0] = JPADrawDirection; - } - break; - case 7: - case 8: - mDrawParticleFuncList[0] = JPADrawRotation; - break; - case 9: - mDrawParticleFuncList[0] = JPADrawDBillboard; - break; - case 10: - if (exShapeSet4) { - mDrawParticleFuncList[0] = JPADrawRotYBillboard; - } else { - mDrawParticleFuncList[0] = JPADrawYBillboard; - } - break; - } - } - mDrawParticleFuncList[idx] = JPADrawParticleCallBack; - if (!isGlblTexAnm && (texFlag & 1)) { - mDrawParticleFuncList[idx] = JPALoadTexAnm; - } - if ((test) || (!exShapeSet1)) { - if ((isTexCrdAnm != 0) && (isPrjTex == 0)) { - mDrawParticleFuncList[idx] = JPALoadCalcTexCrdMtxAnm; - } - } else if (test == 0) { - mDrawParticleFuncList[idx] = JPASetLineWidth; - } else { - mDrawParticleFuncList[idx] = JPASetPointSize; - } - - if (!isGlblClrAnm) { - if (!(clrFlag & 2)) { - if (exShapeSet2) { - if (!(clrFlag & 8)) { - mDrawParticleFuncList[idx] = JPARegistAlpha; - } else { - mDrawParticleFuncList[idx] = JPARegistAlphaEnv; - } - } else if (clrFlag & 8) { - mDrawParticleFuncList[idx] = JPARegistEnv; - } - } else if (!(clrFlag & 8)) { - mDrawParticleFuncList[idx] = JPARegistPrmAlpha; - } else { - mDrawParticleFuncList[idx] = JPARegistPrmAlphaEnv; - } - } else if (exShapeSet2 && !test) { - mDrawParticleFuncList[idx] = JPARegistAlpha; - } - - if (shpFlags && pCsp && !test) { - mDrawParticleChildFuncListNum++; - } - mDrawParticleChildFuncListNum++; - if (test) { - mDrawParticleChildFuncListNum++; - } - if (pCsp && !(pCsp->mData->mFlags & 0x800000) && !(pCsp->mData->mFlags & 0x200000) - && !(pCsp->mData->mFlags & 0x400000)) { - mDrawParticleChildFuncListNum++; - } - if (mDrawParticleChildFuncListNum) { - mDrawParticleChildFuncList = (JPAFunctionB**)heap->alloc(mDrawParticleChildFuncListNum * 4, 4); - } - // my sanity is all gone by this point - if (shpFlags && pCsp && !test) { - switch (pBsp->getType()) { - case 0: - mDrawParticleChildFuncList[0] = JPADrawPoint; - break; - case 1: - mDrawParticleChildFuncList[0] = JPADrawLine; - break; - case 2: - if (exShapeSet4) - mDrawParticleChildFuncList[0] = JPADrawRotBillboard; - else - mDrawParticleChildFuncList[0] = JPADrawBillboard; - break; - case 3: - case 4: - if (exShapeSet4) { - mDrawParticleChildFuncList[0] = JPADrawRotDirection; - } else { - mDrawParticleChildFuncList[0] = JPADrawDirection; - } - break; - case 7: - case 8: - mDrawParticleChildFuncList[0] = JPADrawRotation; - break; - case 9: - mDrawParticleChildFuncList[0] = JPADrawDBillboard; - break; - case 10: - if (exShapeSet4) { - mDrawParticleChildFuncList[0] = JPADrawRotYBillboard; - } else { - mDrawParticleChildFuncList[0] = JPADrawYBillboard; - } - break; - } - idx = 1; - } - - mDrawParticleChildFuncList[idx] = JPADrawParticleCallBack; - if (test) { - mDrawParticleChildFuncList[idx] = JPASetPointSize; - } else { - mDrawParticleChildFuncList[idx] = JPASetLineWidth; - } - if (pCsp && !(pCsp->mData->mFlags & 0x800000) && !(pCsp->mData->mFlags & 0x200000) - && (pCsp->mData->mFlags & 0x400000)) { - mDrawParticleChildFuncList[idx] = JPARegistPrmAlphaEnv; - } + BOOL is_glbl_clr_anm = pBsp->isGlblClrAnm(); + BOOL is_glbl_tex_anm = pBsp->isGlblTexAnm(); + BOOL is_prm_anm = pBsp->isPrmAnm(); + BOOL is_env_anm = pBsp->isEnvAnm(); + BOOL is_tex_anm = pBsp->isTexAnm(); + + BOOL is_tex_crd_anm = pBsp->isTexCrdAnm(); + BOOL is_prj_tex = pBsp->isPrjTex(); + BOOL is_enable_scale_anm = pEsp && pEsp->isEnableScaleAnm(); + BOOL is_enable_alpha_anm = pEsp && pEsp->isEnableAlphaAnm(); + BOOL is_enable_alpha_flick = pEsp && pEsp->isEnableAlphaAnm() + && pEsp->isEnableAlphaFlick(); + BOOL is_enable_rotate_anm = pEsp && pEsp->isEnableRotateAnm(); + BOOL is_rotate_on = is_enable_rotate_anm + || (pCsp && pCsp->isRotateOn()); + BOOL base_type_5_6 = pBsp->getType() == 5 || pBsp->getType() == 6; + BOOL base_type_0 = pBsp->getType() == 0; + BOOL base_type_0_1 = pBsp->getType() == 0 || pBsp->getType() == 1; + BOOL child_type_5_6 = pCsp + && (pCsp->getType() == 5 || pCsp->getType() == 6); + BOOL child_type_0 = pCsp && pCsp->getType() == 0; + BOOL child_type_0_1 = pCsp + && (pCsp->getType() == 0 || pCsp->getType() == 1); + BOOL is_draw_parent = !pBsp->isNoDrawParent(); + BOOL is_draw_child = !pBsp->isNoDrawChild(); + + if (is_glbl_tex_anm && is_tex_anm) { + mCalcEmitterFuncListNum++; + } + + if (is_glbl_clr_anm) { + if (is_prm_anm) { + mCalcEmitterFuncListNum++; + } + if (is_env_anm) { + mCalcEmitterFuncListNum++; + } + if (is_prm_anm || is_env_anm) { + mCalcEmitterFuncListNum++; + } + } + + if (mCalcEmitterFuncListNum != 0) { + mCalcEmitterFuncList = + (JPAEmitterFunc*)JKRAllocFromHeap(heap, mCalcEmitterFuncListNum * 4, 4); + } + + int func_no = 0; + + if (is_glbl_tex_anm && is_tex_anm) { + switch (pBsp->getTexAnmType()) { + case 0: + mCalcEmitterFuncList[func_no] = &JPACalcTexIdxNormal; + break; + case 1: + mCalcEmitterFuncList[func_no] = &JPACalcTexIdxRepeat; + break; + case 2: + mCalcEmitterFuncList[func_no] = &JPACalcTexIdxReverse; + break; + case 3: + mCalcEmitterFuncList[func_no] = &JPACalcTexIdxMerge; + break; + case 4: + mCalcEmitterFuncList[func_no] = &JPACalcTexIdxRandom; + break; + } + func_no++; + } + + if (is_glbl_clr_anm) { + if (is_prm_anm) { + mCalcEmitterFuncList[func_no] = &JPACalcPrm; + func_no++; + } + if (is_env_anm) { + mCalcEmitterFuncList[func_no] = &JPACalcEnv; + func_no++; + } + if (is_prm_anm || is_env_anm) { + switch (pBsp->getClrAnmType()) { + case 0: + mCalcEmitterFuncList[func_no] = &JPACalcClrIdxNormal; + break; + case 1: + mCalcEmitterFuncList[func_no] = &JPACalcClrIdxRepeat; + break; + case 2: + mCalcEmitterFuncList[func_no] = &JPACalcClrIdxReverse; + break; + case 3: + mCalcEmitterFuncList[func_no] = &JPACalcClrIdxMerge; + break; + case 4: + mCalcEmitterFuncList[func_no] = &JPACalcClrIdxRandom; + break; + } + } + } + + if (!is_glbl_tex_anm && is_tex_anm) { + mCalcParticleFuncListNum++; + } + + if (!base_type_5_6 && (is_enable_alpha_anm || is_enable_alpha_flick)) { + mCalcParticleFuncListNum++; + } + + if (!is_glbl_clr_anm) { + if (is_prm_anm) { + mCalcParticleFuncListNum++; + } + if (is_env_anm) { + mCalcParticleFuncListNum++; + } + if (is_prm_anm || is_env_anm) { + mCalcParticleFuncListNum++; + } + } else { + mCalcParticleFuncListNum++; + } + + if (is_enable_scale_anm) { + if (pBsp->getType() != 0) { + if (pEsp->isScaleXYDiff()) { + if (pEsp->getScaleAnmTypeX() == 0 && pEsp->getScaleAnmTypeY() == 0) { + mCalcParticleFuncListNum++; + } else { + mCalcParticleFuncListNum++; + mCalcParticleFuncListNum++; + } + } else { + mCalcParticleFuncListNum++; + } + } + mCalcParticleFuncListNum++; + mCalcParticleFuncListNum++; + } + + if (mCalcParticleFuncListNum != 0) { + mCalcParticleFuncList = + (JPAParticleFunc*)JKRAllocFromHeap(heap, mCalcParticleFuncListNum * 4, 4); + } + + func_no = 0; + + if (!is_glbl_tex_anm && is_tex_anm) { + switch (pBsp->getTexAnmType()) { + case 0: + mCalcParticleFuncList[func_no] = &JPACalcTexIdxNormal; + break; + case 1: + mCalcParticleFuncList[func_no] = &JPACalcTexIdxRepeat; + break; + case 2: + mCalcParticleFuncList[func_no] = &JPACalcTexIdxReverse; + break; + case 3: + mCalcParticleFuncList[func_no] = &JPACalcTexIdxMerge; + break; + case 4: + mCalcParticleFuncList[func_no] = &JPACalcTexIdxRandom; + break; + } + func_no++; + } + + if (!base_type_5_6 && (is_enable_alpha_anm || is_enable_alpha_flick)) { + if (is_enable_alpha_flick) { + mCalcParticleFuncList[func_no] = &JPACalcAlphaFlickAnm; + func_no++; + } else { + mCalcParticleFuncList[func_no] = &JPACalcAlphaAnm; + func_no++; + } + } + + if (!is_glbl_clr_anm) { + if (is_prm_anm) { + mCalcParticleFuncList[func_no] = &JPACalcPrm; + func_no++; + } + if (is_env_anm) { + mCalcParticleFuncList[func_no] = &JPACalcEnv; + func_no++; + } + if (is_prm_anm || is_env_anm) { + switch (pBsp->getClrAnmType()) { + case 0: + mCalcParticleFuncList[func_no] = &JPACalcClrIdxNormal; + break; + case 1: + mCalcParticleFuncList[func_no] = &JPACalcClrIdxRepeat; + break; + case 2: + mCalcParticleFuncList[func_no] = &JPACalcClrIdxReverse; + break; + case 3: + mCalcParticleFuncList[func_no] = &JPACalcClrIdxMerge; + break; + case 4: + mCalcParticleFuncList[func_no] = &JPACalcClrIdxRandom; + break; + } + func_no++; + } + } else { + mCalcParticleFuncList[func_no] = &JPACalcColorCopy; + func_no++; + } + + if (is_enable_scale_anm) { + if (pBsp->getType() != 0) { + if (pEsp->isScaleXYDiff()) { + mCalcParticleFuncList[func_no] = &JPACalcScaleY; + func_no++; + if (pEsp->getScaleAnmTypeY() != 0 || pEsp->getScaleAnmTypeX() != 0) { + switch (pEsp->getScaleAnmTypeY()) { + case 0: + mCalcParticleFuncList[func_no] = &JPACalcScaleAnmNormal; + break; + case 1: + mCalcParticleFuncList[func_no] = &JPACalcScaleAnmRepeatY; + break; + case 2: + mCalcParticleFuncList[func_no] = &JPACalcScaleAnmReverseY; + break; + } + func_no++; + } + } else { + mCalcParticleFuncList[func_no] = &JPACalcScaleCopy; + func_no++; + } + } + mCalcParticleFuncList[func_no] = &JPACalcScaleX; + func_no++; + switch (pEsp->getScaleAnmTypeX()) { + case 0: + mCalcParticleFuncList[func_no] = &JPACalcScaleAnmNormal; + break; + case 1: + mCalcParticleFuncList[func_no] = &JPACalcScaleAnmRepeatX; + break; + case 2: + mCalcParticleFuncList[func_no] = &JPACalcScaleAnmReverseX; + break; + } + } + + if (pCsp && pCsp->isScaleOutOn()) { + mCalcParticleChildFuncListNum++; + } + + if (pCsp && pCsp->isAlphaOutOn()) { + mCalcParticleChildFuncListNum++; + } + + if (mCalcParticleChildFuncListNum != 0) { + mCalcParticleChildFuncList = + (JPAParticleFunc*)JKRAllocFromHeap(heap, mCalcParticleChildFuncListNum * 4, 4); + } + + func_no = 0; + + if (pCsp && pCsp->isScaleOutOn()) { + mCalcParticleChildFuncList[func_no] = &JPACalcChildScaleOut; + func_no++; + } + + if (pCsp && pCsp->isAlphaOutOn()) { + mCalcParticleChildFuncList[func_no] = &JPACalcChildAlphaOut; + } + + if (is_draw_parent && base_type_5_6) { + mDrawEmitterFuncListNum++; + } + + mDrawEmitterFuncListNum++; + + if (pEts) { + mDrawEmitterFuncListNum++; + } + + if (is_glbl_tex_anm || !is_tex_anm) { + mDrawEmitterFuncListNum++; + } + + mDrawEmitterFuncListNum++; + + if (base_type_0_1) { + mDrawEmitterFuncListNum++; + } + + if (base_type_0_1 && !is_enable_scale_anm) { + mDrawEmitterFuncListNum++; + } + + if (is_glbl_clr_anm || (!is_prm_anm && !is_enable_alpha_anm) || !is_env_anm) { + mDrawEmitterFuncListNum++; + } + + if (mDrawEmitterFuncListNum != 0) { + mDrawEmitterFuncList = + (JPAEmitterFunc*)JKRAllocFromHeap(heap, mDrawEmitterFuncListNum * 4, 4); + } + + func_no = 0; + + if (is_draw_parent && base_type_5_6) { + if (pBsp->getType() == 5) { + mDrawEmitterFuncList[func_no] = &JPADrawStripe; + func_no++; + } else { + mDrawEmitterFuncList[func_no] = &JPADrawStripeX; + func_no++; + } + } + + mDrawEmitterFuncList[func_no] = &JPADrawEmitterCallBackB; + func_no++; + + if (pEts) { + mDrawEmitterFuncList[func_no] = &JPALoadExTex; + func_no++; + } + + if (!is_tex_anm) { + mDrawEmitterFuncList[func_no] = &JPALoadTex; + func_no++; + } else if (is_glbl_tex_anm) { + mDrawEmitterFuncList[func_no] = &JPALoadTexAnm; + func_no++; + } + + if (base_type_0_1) { + mDrawEmitterFuncList[func_no] = &JPAGenTexCrdMtxIdt; + func_no++; + } else if (is_prj_tex) { + mDrawEmitterFuncList[func_no] = &JPAGenTexCrdMtxPrj; + func_no++; + } else if (is_tex_crd_anm) { + if (base_type_5_6) { + mDrawEmitterFuncList[func_no] = &JPAGenCalcTexCrdMtxAnm; + func_no++; + } else { + mDrawEmitterFuncList[func_no] = &JPAGenTexCrdMtxAnm; + func_no++; + } + } else { + mDrawEmitterFuncList[func_no] = &JPAGenTexCrdMtxIdt; + func_no++; + } + + if (base_type_0_1) { + mDrawEmitterFuncList[func_no] = &JPALoadPosMtxCam; + func_no++; + } + + if (base_type_0_1 && !is_enable_scale_anm) { + if (base_type_0) { + mDrawEmitterFuncList[func_no] = &JPASetPointSize; + func_no++; + } else { + mDrawEmitterFuncList[func_no] = &JPASetLineWidth; + func_no++; + } + } + + if (is_glbl_clr_anm) { + if (base_type_5_6 || !is_enable_alpha_anm) { + mDrawEmitterFuncList[func_no] = &JPARegistPrmEnv; + } else if (is_enable_alpha_anm) { + mDrawEmitterFuncList[func_no] = &JPARegistEnv; + } + } else if (!is_prm_anm && !is_enable_alpha_anm) { + if (!is_env_anm) { + mDrawEmitterFuncList[func_no] = &JPARegistPrmEnv; + } else { + mDrawEmitterFuncList[func_no] = &JPARegistPrm; + } + } else if (!is_env_anm) { + mDrawEmitterFuncList[func_no] = &JPARegistEnv; + } + + if (is_draw_child && child_type_5_6) { + mDrawEmitterChildFuncListNum++; + } + + mDrawEmitterChildFuncListNum++; + + if (child_type_0_1) { + mDrawEmitterChildFuncListNum++; + } + + if (pCsp && !pCsp->isAlphaOutOn() && !pCsp->isAlphaInherited() + && !pCsp->isColorInherited()) { + mDrawEmitterChildFuncListNum++; + } + + if (mDrawEmitterChildFuncListNum != 0) { + mDrawEmitterChildFuncList = + (JPAEmitterFunc*)JKRAllocFromHeap(heap, mDrawEmitterChildFuncListNum * 4, 4); + } + + func_no = 0; + + if (is_draw_child && child_type_5_6) { + if (pCsp->getType() == 5) { + mDrawEmitterChildFuncList[func_no] = &JPADrawStripe; + func_no++; + } else { + mDrawEmitterChildFuncList[func_no] = &JPADrawStripeX; + func_no++; + } + } + + mDrawEmitterChildFuncList[func_no] = &JPADrawEmitterCallBackB; + func_no++; + + if (child_type_0_1) { + mDrawEmitterChildFuncList[func_no] = &JPALoadPosMtxCam; + func_no++; + } + + if (pCsp && !pCsp->isAlphaOutOn() && !pCsp->isAlphaInherited() + && !pCsp->isColorInherited()) { + mDrawEmitterChildFuncList[func_no] = &JPARegistChildPrmEnv; + } + + if (is_draw_parent && !base_type_5_6) { + mDrawParticleFuncListNum++; + } + + mDrawParticleFuncListNum++; + + if (!is_glbl_tex_anm && is_tex_anm) { + mDrawParticleFuncListNum++; + } + + if ((base_type_0_1 && is_enable_scale_anm) || (is_tex_crd_anm && !is_prj_tex)) { + mDrawParticleFuncListNum++; + } + + if ((!is_glbl_clr_anm && (is_prm_anm || is_env_anm || is_enable_alpha_anm)) + || (is_glbl_clr_anm && is_enable_alpha_anm && !base_type_5_6)) { + mDrawParticleFuncListNum++; + } + + if (mDrawParticleFuncListNum != 0) { + mDrawParticleFuncList = + (JPAParticleFunc*)JKRAllocFromHeap(heap, mDrawParticleFuncListNum * 4, 4); + } + + func_no = 0; + + if (is_draw_parent && !base_type_5_6) { + switch (pBsp->getType()) { + case 2: + if (is_enable_rotate_anm) { + mDrawParticleFuncList[func_no] = &JPADrawRotBillboard; + } else { + mDrawParticleFuncList[func_no] = &JPADrawBillboard; + } + break; + case 10: + if (is_enable_rotate_anm) { + mDrawParticleFuncList[func_no] = &JPADrawRotYBillboard; + } else { + mDrawParticleFuncList[func_no] = &JPADrawYBillboard; + } + break; + case 3: + case 4: + if (is_enable_rotate_anm) { + mDrawParticleFuncList[func_no] = &JPADrawRotDirection; + } else { + mDrawParticleFuncList[func_no] = &JPADrawDirection; + } + break; + case 9: + mDrawParticleFuncList[func_no] = &JPADrawDBillboard; + break; + case 7: + case 8: + mDrawParticleFuncList[func_no] = &JPADrawRotation; + break; + case 0: + mDrawParticleFuncList[func_no] = &JPADrawPoint; + break; + case 1: + mDrawParticleFuncList[func_no] = &JPADrawLine; + break; + } + func_no++; + } + + mDrawParticleFuncList[func_no] = &JPADrawParticleCallBack; + func_no++; + + if (!is_glbl_tex_anm && is_tex_anm) { + mDrawParticleFuncList[func_no] = &JPALoadTexAnm; + func_no++; + } + + if (base_type_0_1 && is_enable_scale_anm) { + if (base_type_0) { + mDrawParticleFuncList[func_no] = &JPASetPointSize; + func_no++; + } else { + mDrawParticleFuncList[func_no] = &JPASetLineWidth; + func_no++; + } + } else if (is_tex_crd_anm && !is_prj_tex) { + mDrawParticleFuncList[func_no] = &JPALoadCalcTexCrdMtxAnm; + func_no++; + } + + if (!is_glbl_clr_anm) { + if (is_prm_anm) { + if (is_env_anm) { + mDrawParticleFuncList[func_no] = &JPARegistPrmAlphaEnv; + } else { + mDrawParticleFuncList[func_no] = &JPARegistPrmAlpha; + } + } else if (is_enable_alpha_anm) { + if (is_env_anm) { + mDrawParticleFuncList[func_no] = &JPARegistAlphaEnv; + } else { + mDrawParticleFuncList[func_no] = &JPARegistAlpha; + } + } else if (is_env_anm) { + mDrawParticleFuncList[func_no] = &JPARegistEnv; + } + } else if (is_enable_alpha_anm && !base_type_5_6) { + mDrawParticleFuncList[func_no] = &JPARegistAlpha; + } + + if (is_draw_child && pCsp && !child_type_5_6) { + mDrawParticleChildFuncListNum++; + } + + mDrawParticleChildFuncListNum++; + + if (child_type_0_1) { + mDrawParticleChildFuncListNum++; + } + + if (pCsp && (pCsp->isAlphaOutOn() || pCsp->isAlphaInherited() + || pCsp->isColorInherited())) { + mDrawParticleChildFuncListNum++; + } + + if (mDrawParticleChildFuncListNum != 0) { + mDrawParticleChildFuncList = + (JPAParticleFunc*)JKRAllocFromHeap(heap, mDrawParticleChildFuncListNum * 4, 4); + } + + func_no = 0; + + if (is_draw_child && pCsp && !child_type_5_6) { + switch (pCsp->getType()) { + case 2: + if (is_rotate_on) { + mDrawParticleChildFuncList[func_no] = &JPADrawRotBillboard; + } else { + mDrawParticleChildFuncList[func_no] = &JPADrawBillboard; + } + break; + case 10: + if (is_rotate_on) { + mDrawParticleChildFuncList[func_no] = &JPADrawRotYBillboard; + } else { + mDrawParticleChildFuncList[func_no] = &JPADrawYBillboard; + } + break; + case 3: + case 4: + if (is_rotate_on) { + mDrawParticleChildFuncList[func_no] = &JPADrawRotDirection; + } else { + mDrawParticleChildFuncList[func_no] = &JPADrawDirection; + } + break; + case 9: + mDrawParticleChildFuncList[func_no] = &JPADrawDBillboard; + break; + case 7: + case 8: + mDrawParticleChildFuncList[func_no] = &JPADrawRotation; + break; + case 0: + mDrawParticleChildFuncList[func_no] = &JPADrawPoint; + break; + case 1: + mDrawParticleChildFuncList[func_no] = &JPADrawLine; + break; + } + func_no++; + } + + mDrawParticleChildFuncList[func_no] = &JPADrawParticleCallBack; + func_no++; + + if (child_type_0_1) { + if (child_type_0) { + mDrawParticleChildFuncList[func_no] = &JPASetPointSize; + func_no++; + } else { + mDrawParticleChildFuncList[func_no] = &JPASetLineWidth; + func_no++; + } + } + + if (pCsp && (pCsp->isAlphaOutOn() || pCsp->isAlphaInherited() + || pCsp->isColorInherited())) { + mDrawParticleChildFuncList[func_no] = &JPARegistPrmAlphaEnv; + } } -bool JPAResource::calc(JPAEmitterWorkData* data, JPABaseEmitter* emitter) +bool JPAResource::calc(JPAEmitterWorkData *data, JPABaseEmitter *emitter) { - data->mEmitter = emitter; - data->mResource = this; - data->mCreateNumber = 0; - - if (!emitter->processTillStartFrame()) { - return false; - } - - if (emitter->processTermination()) { - return false; - } - - if (emitter->checkStatus(JPAEMIT_StopCalc)) { - JPAEmitterCallBack* cback = emitter->mEmitterCallback; - if (cback) { - cback->execute(emitter); + data->mEmitter = emitter; + data->mResource = this; + data->mCreateNumber = 0; + + if (!emitter->processTillStartFrame()) { + return false; + } + + if (emitter->processTermination()) { + return true; + } + + if (emitter->checkStatus(JPAEMIT_StopCalc)) { + if (emitter->mEmitterCallback) { + emitter->mEmitterCallback->execute(emitter); if (emitter->checkStatus(JPAEMIT_ForceDelete)) { return true; } - emitter->mEmitterCallback->executeAfter(emitter); if (emitter->checkStatus(JPAEMIT_ForceDelete)) { return true; } - } - } else { + } + + } else { calcKey(data); - for (int i = fldNum - 1; 0 <= i; i--) { + for (int i = fldNum - 1; i >= 0; i--) { ppFld[i]->initOpParam(); } @@ -665,15 +723,15 @@ bool JPAResource::calc(JPAEmitterWorkData* data, JPABaseEmitter* emitter) calcWorkData_c(data); - for (int i = mCalcEmitterFuncListNum - 1; 0 <= i; i--) { - mCalcEmitterFuncList[i](data); + for (int i = mCalcEmitterFuncListNum - 1; i >= 0; i--) { + (*mCalcEmitterFuncList[i])(data); } - for (int i = fldNum - 1; 0 <= i; i--) { - ppFld[i]->pFld->prepare(data, ppFld[i]); + for (int i = fldNum - 1; i >= 0; i--) { + ppFld[i]->prepare(data); } - if (emitter->checkStatus(JPAEMIT_EnableDeleteEmitter)) { + if (!emitter->checkStatus(JPAEMIT_EnableDeleteEmitter)) { pDyn->create(data); } @@ -684,377 +742,360 @@ bool JPAResource::calc(JPAEmitterWorkData* data, JPABaseEmitter* emitter) } } - FOREACH_NODE(JPANode, data->mEmitter->mAlivePtclBase.getLast(), node) - { + JPANode* node = emitter->mAlivePtclBase.getFirst(); + JPANode* next; + while (node != emitter->mAlivePtclBase.getEnd()) { + next = node->getNext(); if (node->getObject()->calc_p(data)) { - // something like this - emitter->mAlivePtclBase.push_back(node); - emitter->mAlivePtclBase.pop_front(); + emitter->mPtclPool->push_front(emitter->mAlivePtclBase.erase(node)); } + node = next; } - FOREACH_NODE(JPANode, data->mEmitter->mAlivePtclChld.getLast(), node) - { + node = emitter->mAlivePtclChld.getFirst(); + while (node != emitter->mAlivePtclChld.getEnd()) { + next = node->getNext(); if (node->getObject()->calc_c(data)) { - emitter->mAlivePtclChld.push_back(node); - emitter->mAlivePtclChld.pop_front(); + emitter->mPtclPool->push_front(emitter->mAlivePtclChld.erase(node)); } + node = next; } emitter->mCurrentFrame++; } - - return false; + return false; } -void JPAResource::draw(JPAEmitterWorkData* work, JPABaseEmitter* emtr) +void JPAResource::draw(JPAEmitterWorkData *work, JPABaseEmitter *emitter) { - work->mEmitter = emtr; - work->mResource = this; - work->mDrawCount = 0; - calcWorkData_d(work); - pBsp->setGX(work); - for (s32 i = 1; i <= emtr->getDrawTimes(); i++) { - work->mDrawCount++; - if (getBsp()->isDrawPrntAhead() && pCsp != nullptr) - drawC(work); - drawP(work); - if (!getBsp()->isDrawPrntAhead() && pCsp != nullptr) - drawC(work); - } + work->mEmitter = emitter; + work->mResource = this; + work->mDrawCount = 0; + calcWorkData_d(work); + pBsp->setGX(work); + for (s32 i = 1; i <= emitter->getDrawTimes(); i++) { + work->mDrawCount++; + if (getBsp()->isDrawPrntAhead() && pCsp != nullptr) + drawC(work); + drawP(work); + if (!getBsp()->isDrawPrntAhead() && pCsp != nullptr) + drawC(work); + } } -void JPAResource::drawP(JPAEmitterWorkData* data) +void JPAResource::drawP(JPAEmitterWorkData *data) { - data->mEmitter->resetFlag(JPAEMIT_DrawChild); - data->mGlobalPtclScl.x = data->mEmitter->mGlobalPScl.x * pBsp->pBsd->mBaseSizeX; - data->mGlobalPtclScl.y = data->mEmitter->mGlobalPScl.y * pBsp->pBsd->mBaseSizeY; - u32 flag = pBsp->getType(); - if (flag == 0) { - data->mGlobalPtclScl.x *= 1.02f; - } else if (flag == 1) { - data->mGlobalPtclScl.x *= 1.02f; - data->mGlobalPtclScl.y *= 0.4f; - } - - if (pEsp && pEsp->isEnableScaleAnm()) { - data->mPivot.x = (pEsp->mData->mFlags >> 0xc & 3) - 1.0f; - data->mPivot.y = (pEsp->mData->mFlags >> 0xe & 3) - 1.0f; - } else { - data->mPivot.y = 0.0f; - data->mPivot.x = 0.0f; - } - bool test = true; - data->mDirType = pBsp->getDirType(); - data->mRotType = pBsp->getRotType(); - - flag = pBsp->pBsd->mFlags & 15; - if (flag != 4 && flag != 8) { - test = false; - } - data->mDLType = test; - data->mPlaneType = ((u32)data->mDLType) ? 2 : pBsp->getBasePlaneType(); - // int projType; - // if (pBsp->isPrjTex()) { - // projType = pBsp->getProjType() + 1; - // } else { - // projType = 0; - // } - // data->mProjectionType = projType; - data->mProjectionType = (!pBsp->isPrjTex()) ? 0 : pBsp->getProjType(); // need this to not optimise - data->mpAlivePtcl = &data->mEmitter->mAlivePtclBase; - setPTev(); - - for (int i = mDrawEmitterFuncListNum - 1; 0 <= i; i--) { - mDrawEmitterFuncList[i](data); - } - - if (pBsp->pBsd->mFlags & 0x200000) { - for (JPANode* node = data->mEmitter->mAlivePtclBase.getLast(); node; node = node->getPrev()) { - data->mpCurNode = node; - if (mDrawParticleFuncList) { - for (int i = mDrawParticleFuncListNum - 1; 0 <= i; i--) { - mDrawParticleFuncList[i](data, node->getObject()); - } - } - } - } else { - FOREACH_NODE(JPANode, data->mEmitter->mAlivePtclBase.getFirst(), node) - { - data->mpCurNode = node; - if (mDrawParticleFuncList) { - for (int i = mDrawParticleFuncListNum - 1; 0 <= i; i--) { - mDrawParticleFuncList[i](data, node->getObject()); - } - } - } - } - GXSetMisc(GX_MT_XF_FLUSH, 0); - if (data->mEmitter->mEmitterCallback) { - data->mEmitter->mEmitterCallback->drawAfter(data->mEmitter); - } + data->mEmitter->clearStatus(JPAEMIT_DrawChild); + data->mGlobalPtclScl.x = data->mEmitter->mGlobalPScl.x * pBsp->pBsd->mBaseSizeX; + data->mGlobalPtclScl.y = data->mEmitter->mGlobalPScl.y * pBsp->pBsd->mBaseSizeY; + u32 flag = pBsp->getType(); + if (flag == 0) { + data->mGlobalPtclScl.x *= 1.02f; + } else if (flag == 1) { + data->mGlobalPtclScl.x *= 1.02f; + data->mGlobalPtclScl.y *= 0.4f; + } + + if (pEsp && pEsp->isEnableScaleAnm()) { + data->mPivot.x = (pEsp->mData->mFlags >> 0xc & 3) - 1.0f; + data->mPivot.y = (pEsp->mData->mFlags >> 0xe & 3) - 1.0f; + } else { + data->mPivot.y = 0.0f; + data->mPivot.x = 0.0f; + } + bool test = true; + data->mDirType = pBsp->getDirType(); + data->mRotType = pBsp->getRotType(); + + flag = pBsp->pBsd->mFlags & 15; + if (flag != 4 && flag != 8) { + test = false; + } + data->mDLType = test; + data->mPlaneType = ((u32)data->mDLType) ? 2 : pBsp->getBasePlaneType(); + + data->mProjectionType = (pBsp->isPrjTex()) ? (pBsp->isTexCrdAnm() ? 2 : 1) : 0; + data->mpAlivePtcl = &data->mEmitter->mAlivePtclBase; + setPTev(); + + for (int i = mDrawEmitterFuncListNum - 1; 0 <= i; i--) { + mDrawEmitterFuncList[i](data); + } + + if (pBsp->pBsd->mFlags & 0x200000) { + for (JPANode* node = data->mEmitter->mAlivePtclBase.getLast(); node; node = node->getPrev()) { + data->mpCurNode = node; + if (mDrawParticleFuncList) { + for (int i = mDrawParticleFuncListNum - 1; 0 <= i; i--) { + mDrawParticleFuncList[i](data, node->getObject()); + } + } + } + } else { + FOREACH_NODE(JPANode, data->mEmitter->mAlivePtclBase.getFirst(), node) + { + data->mpCurNode = node; + if (mDrawParticleFuncList) { + for (int i = mDrawParticleFuncListNum - 1; 0 <= i; i--) { + mDrawParticleFuncList[i](data, node->getObject()); + } + } + } + } + GXSetMisc(GX_MT_XF_FLUSH, 0); + if (data->mEmitter->mEmitterCallback) { + data->mEmitter->mEmitterCallback->drawAfter(data->mEmitter); + } } -void JPAResource::drawC(JPAEmitterWorkData* data) +void JPAResource::drawC(JPAEmitterWorkData *data) { - data->mEmitter->setFlag(JPAEMIT_DrawChild); - if (pCsp->isScaleInherited()) { - data->mGlobalPtclScl.x = data->mEmitter->mGlobalPScl.x * pBsp->pBsd->mBaseSizeX; - data->mGlobalPtclScl.y = data->mEmitter->mGlobalPScl.y * pBsp->pBsd->mBaseSizeY; - } else { - data->mGlobalPtclScl.x = data->mEmitter->mGlobalPScl.x * pCsp->mData->mScaleX; - data->mGlobalPtclScl.y = data->mEmitter->mGlobalPScl.y * pCsp->mData->mScaleY; - } - - u32 flag = pCsp->mData->mFlags & 0xf; - if (flag == 0) { - data->mGlobalPtclScl.x *= 1.02f; - } else if (flag == 1) { - data->mGlobalPtclScl.x *= 1.02f; - data->mGlobalPtclScl.y *= 0.4f; - } - - bool test = true; - data->mPivot.y = 0.0f; - data->mPivot.x = 0.0f; - data->mDirType = pCsp->mData->mFlags >> 4 & 7; - data->mRotType = pCsp->mData->mFlags >> 7 & 7; - - flag = pCsp->mData->mFlags & 15; - if (flag != 4 && flag != 8) { - test = false; - } - data->mDLType = test; - data->mPlaneType = ((u32)data->mDLType) ? 2 : pCsp->mData->mFlags >> 10 & 1; - data->mProjectionType = 0; - data->mpAlivePtcl = &data->mEmitter->mAlivePtclChld; - setCTev(data); - - for (int i = mDrawEmitterChildFuncListNum - 1; 0 <= i; i--) { - mDrawEmitterChildFuncList[i](data); - } - - if (pBsp->pBsd->mFlags & 0x200000) { - for (JPANode* node = data->mEmitter->mAlivePtclChld.getLast(); node; node = node->getPrev()) { - data->mpCurNode = node; - if (mDrawParticleChildFuncList) { - for (int i = mDrawParticleChildFuncListNum - 1; 0 <= i; i--) { - mDrawParticleChildFuncList[i](data, node->getObject()); - } - } - } - } else { - FOREACH_NODE(JPANode, data->mEmitter->mAlivePtclChld.getFirst(), node) - { - data->mpCurNode = node; - if (mDrawParticleChildFuncList) { - for (int i = mDrawParticleChildFuncListNum - 1; 0 <= i; i--) { - mDrawParticleChildFuncList[i](data, node->getObject()); - } - } - } - } - GXSetMisc(GX_MT_XF_FLUSH, 0); - if (data->mEmitter->mEmitterCallback) { - data->mEmitter->mEmitterCallback->drawAfter(data->mEmitter); - } + data->mEmitter->setFlag(JPAEMIT_DrawChild); + if (pCsp->isScaleInherited()) { + data->mGlobalPtclScl.x = data->mEmitter->mGlobalPScl.x * pBsp->pBsd->mBaseSizeX; + data->mGlobalPtclScl.y = data->mEmitter->mGlobalPScl.y * pBsp->pBsd->mBaseSizeY; + } else { + data->mGlobalPtclScl.x = data->mEmitter->mGlobalPScl.x * pCsp->mData->mScaleX; + data->mGlobalPtclScl.y = data->mEmitter->mGlobalPScl.y * pCsp->mData->mScaleY; + } + + u32 flag = pCsp->mData->mFlags & 0xf; + if (flag == 0) { + data->mGlobalPtclScl.x *= 1.02f; + } else if (flag == 1) { + data->mGlobalPtclScl.x *= 1.02f; + data->mGlobalPtclScl.y *= 0.4f; + } + + bool test = true; + data->mPivot.y = 0.0f; + data->mPivot.x = 0.0f; + data->mDirType = pCsp->mData->mFlags >> 4 & 7; + data->mRotType = pCsp->mData->mFlags >> 7 & 7; + + flag = pCsp->mData->mFlags & 15; + if (flag != 4 && flag != 8) { + test = false; + } + data->mDLType = test; + data->mPlaneType = ((u32)data->mDLType) ? 2 : pCsp->mData->mFlags >> 10 & 1; + data->mProjectionType = 0; + data->mpAlivePtcl = &data->mEmitter->mAlivePtclChld; + setCTev(data); + + for (int i = mDrawEmitterChildFuncListNum - 1; 0 <= i; i--) { + mDrawEmitterChildFuncList[i](data); + } + + if (pBsp->pBsd->mFlags & 0x200000) { + for (JPANode* node = data->mEmitter->mAlivePtclChld.getLast(); node; node = node->getPrev()) { + data->mpCurNode = node; + if (mDrawParticleChildFuncList) { + for (int i = mDrawParticleChildFuncListNum - 1; 0 <= i; i--) { + mDrawParticleChildFuncList[i](data, node->getObject()); + } + } + } + } else { + FOREACH_NODE(JPANode, data->mEmitter->mAlivePtclChld.getFirst(), node) + { + data->mpCurNode = node; + if (mDrawParticleChildFuncList) { + for (int i = mDrawParticleChildFuncListNum - 1; 0 <= i; i--) { + mDrawParticleChildFuncList[i](data, node->getObject()); + } + } + } + } + GXSetMisc(GX_MT_XF_FLUSH, 0); + if (data->mEmitter->mEmitterCallback) { + data->mEmitter->mEmitterCallback->drawAfter(data->mEmitter); + } } void JPAResource::setPTev() { - u8 nStages = 1; - u8 flag = 1; - GXTexCoordID coord = GX_TEXCOORD1; - u8 nIndStages = 1; - u8 nTexGens = 0; - - u32 childflag = pCsp->mData->mFlags & 0xf; - if (childflag != 3 && childflag != 7) { - flag = 0; - } - - int offs; - if (pEsp) { - u32 shpflag = pEsp->mData->mFlags & 0xf; - offs = ((shpflag >> 0xc & 3) + (shpflag >> 0xe & 3) * 3) * 0xc; - } else { - offs = 0x30; - } // some nonsense here - GXSetArray(GX_VA_POS, &jpa_pos[offs + flag], 3); - GXSetArray(GX_VA_TEX0, &jpa_crd[offs], 2); - - GXSetTevOrder(GX_TEVSTAGE0, GX_TEXCOORD0, GX_TEXMAP0, GX_COLOR_NULL); - - if (pEts) { - if (pEts->mData->mFlags & 0x1) { - nIndStages = 1; - } - - if (nIndStages) { - GXSetIndTexOrder(GX_INDTEXSTAGE0, GX_TEXCOORD1, GX_TEXMAP2); - GXSetIndTexCoordScale(GX_INDTEXSTAGE0, GX_ITS_1, GX_ITS_1); - const JPAExTexShapeData* data = pEts->mData; - GXSetIndTexMtx(GX_ITM_0, data->mIndTexMtx, data->mExpScale); - GXSetTevIndirect(GX_TEVSTAGE0, GX_INDTEXSTAGE0, GX_ITF_8, GX_ITB_STU, GX_ITM_0, GX_ITW_OFF, GX_ITW_OFF, GX_FALSE, GX_FALSE, - GX_ITBA_OFF); - coord = GX_TEXCOORD2; - nIndStages = 1; - nTexGens = 2; - } - - if ((pEts->mData->mFlags & 0x100) != 0) { - GXSetTevOrder(GX_TEVSTAGE1, coord, GX_TEXMAP3, GX_COLOR_NULL); - GXSetTevColorIn(GX_TEVSTAGE1, GX_CC_ZERO, GX_CC_TEXC, GX_CC_CPREV, GX_CC_ZERO); - GXSetTevAlphaIn(GX_TEVSTAGE1, GX_CA_ZERO, GX_CA_TEXA, GX_CA_APREV, GX_CA_ZERO); - GXSetTevColorOp(GX_TEVSTAGE1, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_TRUE, GX_TEVPREV); - GXSetTevAlphaOp(GX_TEVSTAGE1, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_TRUE, GX_TEVPREV); - nStages = 2; - nTexGens += 1; - } - } - GXSetNumTevStages(nStages); - GXSetNumIndStages(nIndStages); - - if (pBsp->pBsd->mFlags & 0x800000) { - GXSetMisc(GX_MT_XF_FLUSH, 8); - GXSetClipMode(GX_CLIP_ENABLE); - } else { - GXSetClipMode(GX_CLIP_DISABLE); - } - GXSetNumTexGens(nTexGens); + GXTexCoordID coord = GX_TEXCOORD1; + u8 nStages = 1; + u8 nTexGens = 1; + u8 nIndStages = 0; + + int base_plane_type = (pBsp->getType() == 3 || pBsp->getType() == 7) ? + pBsp->getBasePlaneType() : 0; + int center_offset; + if (pEsp) { + center_offset = + (pEsp->getScaleCenterX() + 3 * pEsp->getScaleCenterY()) * 0xC; + } else { + center_offset = 0x30; + } + int pos_offset = center_offset + base_plane_type * 0x6C; + int crd_offset = (pBsp->getTilingS() + 2 * pBsp->getTilingT()) * 8; + GXSetArray(GX_VA_POS, jpa_pos + pos_offset, 3); + GXSetArray(GX_VA_TEX0, jpa_crd + crd_offset, 2); + GXSetTevOrder(GX_TEVSTAGE0, GX_TEXCOORD0, GX_TEXMAP0, GX_COLOR_NULL); + + if (pEts) { + if (pEts->isUseIndirect()) { + GXSetIndTexOrder(GX_INDTEXSTAGE0, GX_TEXCOORD1, GX_TEXMAP2); + GXSetIndTexCoordScale(GX_INDTEXSTAGE0, GX_ITS_1, GX_ITS_1); + GXSetIndTexMtx(GX_ITM_0, pEts->getIndTexMtx(), pEts->getExpScale()); + GXSetTevIndirect(GX_TEVSTAGE0, GX_INDTEXSTAGE0, GX_ITF_8, GX_ITB_STU, GX_ITM_0, GX_ITW_OFF, GX_ITW_OFF, GX_FALSE, GX_FALSE, + GX_ITBA_OFF); + coord = GX_TEXCOORD2; + nIndStages = 1; + nTexGens = 2; + } + + if ((pEts->mData->mFlags & 0x100) != 0) { + GXSetTevOrder(GX_TEVSTAGE1, coord, GX_TEXMAP3, GX_COLOR_NULL); + GXSetTevColorIn(GX_TEVSTAGE1, GX_CC_ZERO, GX_CC_TEXC, GX_CC_CPREV, GX_CC_ZERO); + GXSetTevAlphaIn(GX_TEVSTAGE1, GX_CA_ZERO, GX_CA_TEXA, GX_CA_APREV, GX_CA_ZERO); + GXSetTevColorOp(GX_TEVSTAGE1, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_TRUE, GX_TEVPREV); + GXSetTevAlphaOp(GX_TEVSTAGE1, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_TRUE, GX_TEVPREV); + nStages = 2; + nTexGens += 1; + } + } + GXSetNumTevStages(nStages); + GXSetNumIndStages(nIndStages); + + if (pBsp->isClipOn()) { + GXSetMisc(GX_MT_XF_FLUSH, 8); + GXSetClipMode(GX_CLIP_ENABLE); + } else { + GXSetClipMode(GX_CLIP_DISABLE); + } + GXSetNumTexGens(nTexGens); } -void JPAResource::setCTev(JPAEmitterWorkData* data) +void JPAResource::setCTev(JPAEmitterWorkData *data) { - u32 flag = pCsp->mData->mFlags & 0xf; - bool set = true; - if (flag != 3 && flag != 7) { - set = false; - } - // some nonsense here - GXSetArray(GX_VA_POS, &jpa_pos[flag >> 10 & 1 & (set ? 1 : 0)], 3); - - GXSetArray(GX_VA_TEX0, jpa_crd, 2); - GXSetTevOrder(GX_TEVSTAGE0, GX_TEXCOORD_NULL, GX_TEXMAP0, GX_COLOR_NULL); - GXSetTexCoordGen2(GX_TEXCOORD_NULL, GX_TG_MTX3x4, GX_TG_TEX0, 0x3c, GX_FALSE, 0x7d); - GXSetTevDirect(GX_TEVSTAGE0); - GXSetNumTevStages(1); - GXSetNumIndStages(0); - - if (pCsp->mData->mFlags & 0x100000) { - GXSetMisc(GX_MT_XF_FLUSH, 8); - GXSetClipMode(GX_CLIP_ENABLE); - } else { - GXSetClipMode(GX_CLIP_DISABLE); - } - GXSetNumTexGens(1); - - data->mResourceMgr->pTexAry[data->mResource->texIdxTbl[pCsp->mData->mTexIdx]]->load(GX_TEXMAP1); + int base_plane_type = (pCsp->getType() == 3 || pCsp->getType() == 7) ? + pCsp->getBasePlaneType() : 0; + int pos_offset = 0x30 + base_plane_type * 0x6C; + GXSetArray(GX_VA_POS, jpa_pos + pos_offset, 3); + GXSetArray(GX_VA_TEX0, jpa_crd, 2); + GXSetTevOrder(GX_TEVSTAGE0, GX_TEXCOORD0, GX_TEXMAP1, GX_COLOR_NULL); + GXSetTexCoordGen2(GX_TEXCOORD0, GX_TG_MTX2x4, GX_TG_TEX0, 0x3c, GX_FALSE, 0x7d); + GXSetTevDirect(GX_TEVSTAGE0); + GXSetNumTevStages(1); + GXSetNumIndStages(0); + + if (pCsp->isClipOn()) { + GXSetMisc(GX_MT_XF_FLUSH, 8); + GXSetClipMode(GX_CLIP_ENABLE); + } else { + GXSetClipMode(GX_CLIP_DISABLE); + } + GXSetNumTexGens(1); + + data->mResourceMgr->pTexAry[data->mResource->texIdxTbl[pCsp->mData->mTexIdx]]->load(GX_TEXMAP1); } -void JPAResource::calc_p(JPAEmitterWorkData* workData, JPABaseParticle* particle) +void JPAResource::calc_p(JPAEmitterWorkData *workData, JPABaseParticle* particle) { - if (mCalcParticleFuncList == nullptr) { - return; - } - for (int i = mCalcParticleFuncListNum - 1; 0 <= i; i--) { - mCalcParticleFuncList[i](workData, particle); - } + if (mCalcParticleFuncList == nullptr) { + return; + } + for (int i = mCalcParticleFuncListNum - 1; 0 <= i; i--) { + mCalcParticleFuncList[i](workData, particle); + } } -void JPAResource::calc_c(JPAEmitterWorkData* workData, JPABaseParticle* particle) +void JPAResource::calc_c(JPAEmitterWorkData *workData, JPABaseParticle* particle) { - if (!mCalcParticleChildFuncList) { - return; - } + if (!mCalcParticleChildFuncList) { + return; + } - for (int i = mCalcParticleChildFuncListNum - 1; 0 <= i; i--) { - mCalcParticleChildFuncList[i](workData, particle); - } + for (int i = mCalcParticleChildFuncListNum - 1; 0 <= i; i--) { + mCalcParticleChildFuncList[i](workData, particle); + } } -void JPAResource::calcField(JPAEmitterWorkData* workData, JPABaseParticle* particle) +void JPAResource::calcField(JPAEmitterWorkData *workData, JPABaseParticle* particle) { - for (int i = fldNum - 1; 0 <= i; i--) { - ppFld[i]->pFld->calc(workData, ppFld[i], particle); - } + for (int i = fldNum - 1; 0 <= i; i--) { + ppFld[i]->pFld->calc(workData, ppFld[i], particle); + } } -void JPAResource::calcKey(JPAEmitterWorkData* data) +void JPAResource::calcKey(JPAEmitterWorkData *data) { - for (int i = keyNum - 1; i >= 0; i--) { - f32 calc = ppKey[i]->calc(data->mEmitter->mCurrentFrame); - - switch (ppKey[i]->mDataStart->mFlag) { - case 0: - data->mEmitter->setRate(calc); - break; - case 1: - data->mEmitter->setVolumeSize(calc); - break; - case 3: - data->mEmitter->mVolumeMinRad = calc; - break; - case 4: - data->mEmitter->setLifeTime(calc); - break; - case 6: - data->mEmitter->mAwayFromCenterSpeed = calc; - break; - case 7: - data->mEmitter->mAwayFromAxisSpeed = calc; - break; - case 8: - data->mEmitter->mDirSpeed = calc; - break; - case 9: - data->mEmitter->mSpread = calc; - break; - case 10: - data->mEmitter->mScaleOut = calc; - break; + for (int i = keyNum - 1; i >= 0; i--) { + f32 calc = ppKey[i]->calc(data->mEmitter->mCurrentFrame); + + switch (ppKey[i]->mDataStart->mFlag) { + case 0: + data->mEmitter->setRate(calc); + break; + case 1: + data->mEmitter->setVolumeSize(calc); + break; + case 3: + data->mEmitter->mVolumeMinRad = calc; + break; + case 4: + data->mEmitter->setLifeTime(calc); + break; + case 6: + data->mEmitter->mAwayFromCenterSpeed = calc; + break; + case 7: + data->mEmitter->mAwayFromAxisSpeed = calc; + break; + case 8: + data->mEmitter->mDirSpeed = calc; + break; + case 9: + data->mEmitter->mSpread = calc; + break; + case 10: + data->mEmitter->mScaleOut = calc; + break; default: #line 917 JUT_WARNING_F2("%s", "JPA : WRONG ID in key data\n"); - } - } + } + } } -void JPAResource::calcWorkData_c(JPAEmitterWorkData* data) +void JPAResource::calcWorkData_c(JPAEmitterWorkData *data) { - data->mVolumeSize = data->mEmitter->mVolumeSize; - data->mVolumeMinRad = data->mEmitter->mVolumeMinRad; - data->mVolumeSweep = data->mEmitter->mVolumeSweep; - data->mVolumeX = 0; - data->mVolumeAngleNum = 0; - data->mVolumeAngleMax = 1; - data->mDivNumber = pDyn->mData->mDivNumber * 2 + 1; - - Mtx mtx, mtx2, mtx3; - PSMTXScale(mtx, data->mEmitter->mLocalScl.x, data->mEmitter->mLocalScl.y, data->mEmitter->mLocalScl.z); - JPAGetXYZRotateMtx(data->mEmitter->mLocalRot.x * 182, data->mEmitter->mLocalRot.y * 182, data->mEmitter->mLocalRot.z * 182, mtx2); - PSMTXScale(mtx3, data->mEmitter->mGlobalScl.x, data->mEmitter->mGlobalScl.y, data->mEmitter->mGlobalScl.z); - PSMTXConcat(data->mEmitter->mGlobalRot, mtx3, mtx3); - mtx3[0][3] = data->mEmitter->mGlobalTrs.x; - mtx3[1][3] = data->mEmitter->mGlobalTrs.y; - mtx3[2][3] = data->mEmitter->mGlobalTrs.z; - PSMTXCopy(data->mEmitter->mGlobalRot, data->mRotationMtx); - PSMTXConcat(data->mRotationMtx, mtx2, data->mGlobalRot); - PSMTXConcat(data->mGlobalRot, mtx, data->mGlobalSR); + data->mVolumeSize = data->mEmitter->mVolumeSize; + data->mVolumeMinRad = data->mEmitter->mVolumeMinRad; + data->mVolumeSweep = data->mEmitter->mVolumeSweep; + data->mVolumeX = 0; + data->mVolumeAngleNum = 0; + data->mVolumeAngleMax = 1; + data->mDivNumber = pDyn->mData->mDivNumber * 2 + 1; + + Mtx mtx, mtx2, mtx3; + PSMTXScale(mtx, data->mEmitter->mLocalScl.x, data->mEmitter->mLocalScl.y, data->mEmitter->mLocalScl.z); + JPAGetXYZRotateMtx(data->mEmitter->mLocalRot.x * 182, data->mEmitter->mLocalRot.y * 182, data->mEmitter->mLocalRot.z * 182, mtx2); + PSMTXScale(mtx3, data->mEmitter->mGlobalScl.x, data->mEmitter->mGlobalScl.y, data->mEmitter->mGlobalScl.z); + PSMTXConcat(data->mEmitter->mGlobalRot, mtx3, mtx3); + mtx3[0][3] = data->mEmitter->mGlobalTrs.x; + mtx3[1][3] = data->mEmitter->mGlobalTrs.y; + mtx3[2][3] = data->mEmitter->mGlobalTrs.z; + PSMTXCopy(data->mEmitter->mGlobalRot, data->mRotationMtx); + PSMTXConcat(data->mRotationMtx, mtx2, data->mGlobalRot); + PSMTXConcat(data->mGlobalRot, mtx, data->mGlobalSR); data->mEmitterPos.set(data->mEmitter->mLocalTrs); data->mGlobalScl.mul(data->mEmitter->mGlobalScl, data->mEmitter->mLocalScl); - JPAGetDirMtx(data->mEmitter->mLocalDir, data->mDirectionMtx); - data->mPublicScale.set(data->mEmitter->mGlobalScl); - PSMTXMultVec(mtx3, &data->mEmitter->mLocalTrs, &data->mGlobalPos); + JPAGetDirMtx(data->mEmitter->mLocalDir, data->mDirectionMtx); + data->mPublicScale.set(data->mEmitter->mGlobalScl); + PSMTXMultVec(mtx3, &data->mEmitter->mLocalTrs, &data->mGlobalPos); } -void JPAResource::calcWorkData_d(JPAEmitterWorkData* work) +void JPAResource::calcWorkData_d(JPAEmitterWorkData *work) { - Mtx mtx; - JPAGetXYZRotateMtx(work->mEmitter->mLocalRot.x * 0xB6, work->mEmitter->mLocalRot.y * 0xB6, work->mEmitter->mLocalRot.z * 0xB6, mtx); - PSMTXConcat(work->mEmitter->mGlobalRot, mtx, work->mGlobalRot); - PSMTXMultVecSR(work->mGlobalRot, (Vec*)&work->mEmitter->mLocalDir, (Vec*)&work->mGlobalEmtrDir); + Mtx mtx; + JPAGetXYZRotateMtx(work->mEmitter->mLocalRot.x * 0xB6, work->mEmitter->mLocalRot.y * 0xB6, work->mEmitter->mLocalRot.z * 0xB6, mtx); + PSMTXConcat(work->mEmitter->mGlobalRot, mtx, work->mGlobalRot); + PSMTXMultVecSR(work->mGlobalRot, (Vec*)&work->mEmitter->mLocalDir, (Vec*)&work->mGlobalEmtrDir); } diff --git a/libs/JSystem/JParticle/JPAResourceLoader.cpp b/libs/JSystem/JParticle/JPAResourceLoader.cpp index 17df414f..3fbefe1c 100644 --- a/libs/JSystem/JParticle/JPAResourceLoader.cpp +++ b/libs/JSystem/JParticle/JPAResourceLoader.cpp @@ -5,10 +5,6 @@ #include "JSystem/JUtility/JUTAssert.h" #include "types.h" -/* - -*/ - #define GetTypeFromByteStream(data, type, offset) (*(type*)((data) + (offset))) JPAResourceLoader::JPAResourceLoader(const u8 *p1, JPAResourceManager* p_res_mgr, u16) diff --git a/libs/JSystem/JParticle/JPAResourceManager.cpp b/libs/JSystem/JParticle/JPAResourceManager.cpp index 02ee1acf..af6875a1 100644 --- a/libs/JSystem/JParticle/JPAResourceManager.cpp +++ b/libs/JSystem/JParticle/JPAResourceManager.cpp @@ -68,7 +68,7 @@ void JPAResourceManager::registTex(JPATexture *res) texRegNum++; } -void JPAResourceManager::registTexDupCheck(const unsigned char *, JKRHeap *) +void JPAResourceManager::registTexDupCheck(const u8 *, JKRHeap *) { // UNUSED } @@ -76,4 +76,4 @@ void JPAResourceManager::registTexDupCheck(const unsigned char *, JKRHeap *) u32 JPAResourceManager::getResUserWork(u16) const { // UNUSED -} \ No newline at end of file +} diff --git a/libs/JSystem/JParticle/JPATexture.cpp b/libs/JSystem/JParticle/JPATexture.cpp index 086addbd..0741daaf 100644 --- a/libs/JSystem/JParticle/JPATexture.cpp +++ b/libs/JSystem/JParticle/JPATexture.cpp @@ -2,10 +2,10 @@ #include "JSystem/JParticle/JPATexture.h" -JPATexture::JPATexture(const unsigned char *p1) +JPATexture::JPATexture(const u8 *p1) : mTexture(), mData((const JPATextureData *)p1) { mTexture.storeTIMG(&mData->mResTIMG, (u8)'\0'); } -JPATexture::~JPATexture() {} \ No newline at end of file +JPATexture::~JPATexture() {}