diff options
| author | Jcw87 <Jcw87@users.noreply.github.com> | 2026-02-07 04:43:51 -0800 |
|---|---|---|
| committer | GitHub <noreply@github.com> | 2026-02-07 04:43:51 -0800 |
| commit | 57cea18076aaf37de164b2ddeafdda4c42bdda80 (patch) | |
| tree | df4573e1c7058cde2d255adf909899c9d337b332 | |
| parent | 434550355b33a95a6d715e820dfc380404105af3 (diff) | |
JParticle debug (#3090)
28 files changed, 879 insertions, 853 deletions
diff --git a/config/RZDE01_00/splits.txt b/config/RZDE01_00/splits.txt index f12fb44ebd..54c6ce1e3f 100644 --- a/config/RZDE01_00/splits.txt +++ b/config/RZDE01_00/splits.txt @@ -1626,7 +1626,7 @@ JSystem/JParticle/JPAResource.cpp: JSystem/JParticle/JPABaseShape.cpp: .text start:0x8025F598 end:0x802629A4 .data start:0x8041D360 end:0x8041D508 - .sdata start:0x80539AC0 end:0x80539AD0 + .sdata start:0x80539AC0 end:0x80539AC8 .sdata2 start:0x8053F0D8 end:0x8053F110 JSystem/JParticle/JPAExtraShape.cpp: @@ -1873,6 +1873,7 @@ JSystem/JAudio2/JASSeqParser.cpp: .text start:0x80279E94 end:0x8027BB90 .ctors start:0x803CE324 end:0x803CE328 .data start:0x8041E890 end:0x804201C0 + .sdata start:0x80539AC8 end:0x80539AD0 .sbss start:0x8053AF18 end:0x8053AF28 .sdata2 start:0x8053F3E8 end:0x8053F420 diff --git a/config/RZDE01_02/splits.txt b/config/RZDE01_02/splits.txt index ec096087af..99537c82d6 100644 --- a/config/RZDE01_02/splits.txt +++ b/config/RZDE01_02/splits.txt @@ -1629,7 +1629,7 @@ JSystem/JParticle/JPAResource.cpp: JSystem/JParticle/JPABaseShape.cpp: .text start:0x8025ECC0 end:0x802620CC .data start:0x80408760 end:0x80408908 - .sdata start:0x8051FB68 end:0x8051FB78 + .sdata start:0x8051FB68 end:0x8051FB70 .sdata2 start:0x805250F8 end:0x80525130 JSystem/JParticle/JPAExtraShape.cpp: @@ -1876,6 +1876,7 @@ JSystem/JAudio2/JASSeqParser.cpp: .text start:0x80279630 end:0x8027B32C .ctors start:0x803B8D68 end:0x803B8D6C .data start:0x80409C90 end:0x8040B5C0 + .sdata start:0x8051FB70 end:0x8051FB78 .sbss start:0x80520F38 end:0x80520F48 .sdata2 start:0x80525408 end:0x80525440 diff --git a/config/RZDJ01/splits.txt b/config/RZDJ01/splits.txt index b8c597e29b..ffef7e8114 100644 --- a/config/RZDJ01/splits.txt +++ b/config/RZDJ01/splits.txt @@ -1629,7 +1629,7 @@ JSystem/JParticle/JPAResource.cpp: JSystem/JParticle/JPABaseShape.cpp: .text start:0x802607DC end:0x80263BE8 .data start:0x804065E0 end:0x80406788 - .sdata start:0x8051D9D8 end:0x8051D9E8 + .sdata start:0x8051D9D8 end:0x8051D9E0 .sdata2 start:0x80522F50 end:0x80522F88 JSystem/JParticle/JPAExtraShape.cpp: @@ -1876,6 +1876,7 @@ JSystem/JAudio2/JASSeqParser.cpp: .text start:0x8027B14C end:0x8027CE48 .ctors start:0x803BA828 end:0x803BA82C .data start:0x80407B10 end:0x80409440 + .sdata start:0x8051D9E0 end:0x8051D9E8 .sbss start:0x8051EDA8 end:0x8051EDB8 .sdata2 start:0x80523260 end:0x80523298 diff --git a/config/RZDP01/splits.txt b/config/RZDP01/splits.txt index 7f16163fc1..06235cc4c2 100644 --- a/config/RZDP01/splits.txt +++ b/config/RZDP01/splits.txt @@ -1626,7 +1626,7 @@ JSystem/JParticle/JPAResource.cpp: JSystem/JParticle/JPABaseShape.cpp: .text start:0x8025F128 end:0x80262534 .data start:0x80409080 end:0x80409228 - .sdata start:0x80520310 end:0x80520320 + .sdata start:0x80520310 end:0x80520318 .sdata2 start:0x805258C8 end:0x80525900 JSystem/JParticle/JPAExtraShape.cpp: @@ -1873,6 +1873,7 @@ JSystem/JAudio2/JASSeqParser.cpp: .text start:0x80279A98 end:0x8027B794 .ctors start:0x803B91E8 end:0x803B91EC .data start:0x8040A5B0 end:0x8040BEE0 + .sdata start:0x80520318 end:0x80520320 .sbss start:0x805216F8 end:0x80521708 .sdata2 start:0x80525BD8 end:0x80525C10 diff --git a/include/JSystem/JGeometry.h b/include/JSystem/JGeometry.h index 513d5242dd..696d2f60a4 100644 --- a/include/JSystem/JGeometry.h +++ b/include/JSystem/JGeometry.h @@ -286,12 +286,7 @@ struct TVec3<f32> : public Vec { } void scale(__REGISTER f32 sc) { -#if DEBUG - x *= sc; - y *= sc; - z *= sc; -#else -#ifdef __MWERKS__ +#if PLATFORM_GCN && defined(__MWERKS__) __REGISTER f32 z; __REGISTER f32 x_y; __REGISTER f32* dst = &x; @@ -305,12 +300,15 @@ struct TVec3<f32> : public Vec { ps_muls0 zres, z, sc psq_st zres, 8(dst), 1, 0 }; -#endif +#else + x *= sc; + y *= sc; + z *= sc; #endif } void scale(__REGISTER f32 sc, const TVec3<f32>& other) { -#ifdef __MWERKS__ +#if PLATFORM_GCN && defined(__MWERKS__) __REGISTER const f32* src = &other.x; __REGISTER f32 z; __REGISTER f32 x_y; @@ -325,6 +323,10 @@ struct TVec3<f32> : public Vec { ps_muls0 zres, z, sc psq_st zres, 8(dst), 1, 0 }; +#else + x = other.x * sc; + y = other.y * sc; + z = other.z * sc; #endif } diff --git a/include/JSystem/JParticle/JPABaseShape.h b/include/JSystem/JParticle/JPABaseShape.h index 35dcbb83ad..6e7605baac 100644 --- a/include/JSystem/JParticle/JPABaseShape.h +++ b/include/JSystem/JParticle/JPABaseShape.h @@ -27,11 +27,11 @@ struct JPABaseShapeData { /* 0x1C */ u8 mAlphaRef1; /* 0x1D */ u8 mZModeCfg; /* 0x1E */ u8 mTexFlg; - /* 0x1F */ u8 mTexAnmNum; + /* 0x1F */ u8 texAnmKeyNum; /* 0x20 */ u8 mTexIdx; /* 0x21 */ u8 mClrFlg; - /* 0x22 */ u8 mClrPrmKeyNum; - /* 0x23 */ u8 mClrEnvKeyNum; + /* 0x22 */ u8 prmAnmKeyNum; + /* 0x23 */ u8 envAnmKeyNum; /* 0x24 */ s16 mClrAnmFrmMax; /* 0x26 */ GXColor mClrPrm; /* 0x2A */ GXColor mClrEnv; @@ -57,62 +57,62 @@ public: static GXTevColorArg st_ca[6][4]; static GXTevAlphaArg st_aa[2][4]; - GXBlendMode getBlendMode() const { return st_bm[mpData->mBlendModeCfg & 0x03]; } - GXBlendFactor getBlendSrc() const { return st_bf[(mpData->mBlendModeCfg >> 2) & 0x0F]; } - GXBlendFactor getBlendDst() const { return st_bf[(mpData->mBlendModeCfg >> 6) & 0x0F]; } - GXLogicOp getLogicOp() const { return st_lo[(mpData->mBlendModeCfg >> 10) & 0x0F]; } - GXBool getZCompLoc() const { return (GXBool)((mpData->mZModeCfg >> 5) & 0x01); } - - GXBool getZEnable() const { return (GXBool)(mpData->mZModeCfg & 0x01); } - GXCompare getZCmp() const { return st_c[(mpData->mZModeCfg >> 1) & 0x07]; } - GXBool getZUpd() const { return (GXBool)((mpData->mZModeCfg >> 4) & 0x01); } - - GXCompare getAlphaCmp0() const { return st_c[mpData->mAlphaCompareCfg & 0x07]; } - u8 getAlphaRef0() const { return mpData->mAlphaRef0; } - GXAlphaOp getAlphaOp() const { return st_ao[(mpData->mAlphaCompareCfg >> 3) & 0x03]; } - GXCompare getAlphaCmp1() const { return st_c[(mpData->mAlphaCompareCfg >> 5) & 0x07]; } - u8 getAlphaRef1() const { return mpData->mAlphaRef1; } - - const GXTevColorArg* getTevColorArg() const { return st_ca[(mpData->mFlags >> 0x0F) & 0x07]; } - const GXTevAlphaArg* getTevAlphaArg() const { return st_aa[(mpData->mFlags >> 0x12) & 0x01]; } - - u32 getType() const { return (mpData->mFlags >> 0) & 0x0F; } - u32 getDirType() const { return (mpData->mFlags >> 4) & 0x07; } - u32 getRotType() const { return (mpData->mFlags >> 7) & 0x07; } - u32 getBasePlaneType() const { return (mpData->mFlags >> 10) & 0x01; } - u32 getTilingS() const { return (mpData->mFlags >> 25) & 0x01; } - u32 getTilingT() const { return (mpData->mFlags >> 26) & 0x01; } - BOOL isGlblClrAnm() const { return mpData->mFlags & 0x00001000; } - BOOL isGlblTexAnm() const { return mpData->mFlags & 0x00004000; } - BOOL isPrjTex() const { return mpData->mFlags & 0x00100000; } - bool isDrawFwdAhead() const { return !!(mpData->mFlags & 0x00200000); } - bool isDrawPrntAhead() const { return !!(mpData->mFlags & 0x00400000); } - bool isClipOn() const { return !!(mpData->mFlags & 0x00800000); } - BOOL isTexCrdAnm() const { return mpData->mFlags & 0x01000000; } - bool isNoDrawParent() const { return !!(mpData->mFlags & 0x08000000); } - bool isNoDrawChild() const { return !!(mpData->mFlags & 0x10000000); } - - BOOL isPrmAnm() const { return mpData->mClrFlg & 0x02; } - BOOL isEnvAnm() const { return mpData->mClrFlg & 0x08; } - u8 getClrAnmType() const { return (mpData->mClrFlg >> 4) & 0x07; } - s16 getClrAnmMaxFrm() const { return mpData->mClrAnmFrmMax; } - void getPrmClr(GXColor* dst) { *dst = mpData->mClrPrm; } - void getPrmClr(s16 idx, GXColor* dst) { *dst = mpPrmClrAnmTbl[idx]; } - void getEnvClr(GXColor* dst) { *dst = mpData->mClrEnv; } - void getEnvClr(s16 idx, GXColor* dst) { *dst = mpEnvClrAnmTbl[idx]; } - - BOOL isTexAnm() const { return mpData->mTexFlg & 0x01; } - u8 getTexAnmType() const { return (mpData->mTexFlg >> 2) & 0x07; } - u32 getTexIdx() const { return mpData->mTexIdx; } + GXBlendMode getBlendMode() const { return st_bm[pBsd->mBlendModeCfg & 0x03]; } + GXBlendFactor getBlendSrc() const { return st_bf[(pBsd->mBlendModeCfg >> 2) & 0x0F]; } + GXBlendFactor getBlendDst() const { return st_bf[(pBsd->mBlendModeCfg >> 6) & 0x0F]; } + GXLogicOp getLogicOp() const { return st_lo[(pBsd->mBlendModeCfg >> 10) & 0x0F]; } + GXBool getZCompLoc() const { return (GXBool)((pBsd->mZModeCfg >> 5) & 0x01); } + + GXBool getZEnable() const { return (GXBool)(pBsd->mZModeCfg & 0x01); } + GXCompare getZCmp() const { return st_c[(pBsd->mZModeCfg >> 1) & 0x07]; } + GXBool getZUpd() const { return (GXBool)((pBsd->mZModeCfg >> 4) & 0x01); } + + GXCompare getAlphaCmp0() const { return st_c[pBsd->mAlphaCompareCfg & 0x07]; } + u8 getAlphaRef0() const { return pBsd->mAlphaRef0; } + GXAlphaOp getAlphaOp() const { return st_ao[(pBsd->mAlphaCompareCfg >> 3) & 0x03]; } + GXCompare getAlphaCmp1() const { return st_c[(pBsd->mAlphaCompareCfg >> 5) & 0x07]; } + u8 getAlphaRef1() const { return pBsd->mAlphaRef1; } + + const GXTevColorArg* getTevColorArg() const { return st_ca[(pBsd->mFlags >> 0x0F) & 0x07]; } + const GXTevAlphaArg* getTevAlphaArg() const { return st_aa[(pBsd->mFlags >> 0x12) & 0x01]; } + + u32 getType() const { return (pBsd->mFlags >> 0) & 0x0F; } + u32 getDirType() const { return (pBsd->mFlags >> 4) & 0x07; } + u32 getRotType() const { return (pBsd->mFlags >> 7) & 0x07; } + u32 getBasePlaneType() const { return (pBsd->mFlags >> 10) & 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 >> 27 & 1; } + BOOL isNoDrawChild() const { return pBsd->mFlags >> 28 & 1; } + + BOOL isPrmAnm() const { return pBsd->mClrFlg & 0x02; } + BOOL isEnvAnm() const { return pBsd->mClrFlg & 0x08; } + u32 getClrAnmType() const { return (pBsd->mClrFlg >> 4) & 0x07; } + s16 getClrAnmMaxFrm() const { return pBsd->mClrAnmFrmMax; } + void getPrmClr(GXColor* dst) const { *dst = pBsd->mClrPrm; } + void getPrmClr(s16 idx, GXColor* dst) const { *dst = mpPrmClrAnmTbl[idx]; } + void getEnvClr(GXColor* dst) const { *dst = pBsd->mClrEnv; } + void getEnvClr(s16 idx, GXColor* dst) const { *dst = mpEnvClrAnmTbl[idx]; } + + BOOL isTexAnm() const { return pBsd->mTexFlg & 0x01; } + u32 getTexAnmType() const { return (pBsd->mTexFlg >> 2) & 0x07; } + u8 getTexIdx() const { return pBsd->mTexIdx; } u8 getTexIdx(u8 idx) const { return mpTexIdxAnimTbl[idx]; } - f32 getBaseSizeX() const { return mpData->mBaseSizeX; } - f32 getBaseSizeY() const { return mpData->mBaseSizeY; } - u8 getClrLoopOfstMask() const { return mpData->mClrAnmRndmMask; } - u32 getClrLoopOfst(u32 param_1) const { return getClrLoopOfstMask() & param_1; } - u8 getTexLoopOfstMask() const { return mpData->mTexAnmRndmMask; } - u32 getTexLoopOfst(u8 param_1) const { return getTexLoopOfstMask() & param_1; } - u8 getLoopOfstValue() const { return mpData->mAnmRndm; } + f32 getBaseSizeX() const { return pBsd->mBaseSizeX; } + f32 getBaseSizeY() const { return pBsd->mBaseSizeY; } + u8 getClrLoopOfstMask() const { return pBsd->mClrAnmRndmMask; } + s32 getClrLoopOfst(u8 param_1) const { return getClrLoopOfstMask() & param_1; } + u8 getTexLoopOfstMask() const { return pBsd->mTexAnmRndmMask; } + s32 getTexLoopOfst(u8 param_1) const { return getTexLoopOfstMask() & param_1; } + u8 getLoopOfstValue() const { return pBsd->mAnmRndm; } f32 getIncTransX() const { return ((f32*)mpTexCrdMtxAnmTbl)[5]; } f32 getInitTransX() const { return ((f32*)mpTexCrdMtxAnmTbl)[0]; } @@ -124,10 +124,10 @@ public: f32 getInitScaleY() const { return ((f32*)mpTexCrdMtxAnmTbl)[3]; } f32 getIncRot() const { return ((f32*)mpTexCrdMtxAnmTbl)[9]; } f32 getInitRot() const { return ((f32*)mpTexCrdMtxAnmTbl)[4]; } - u8 getTexAnmKeyNum() const { return mpData->mTexAnmNum; } + u8 getTexAnmKeyNum() const { return pBsd->texAnmKeyNum; } public: - /* 0x00 */ const JPABaseShapeData* mpData; + /* 0x00 */ const JPABaseShapeData* pBsd; /* 0x04 */ const void* mpTexCrdMtxAnmTbl; /* 0x08 */ const u8* mpTexIdxAnimTbl; /* 0x0C */ GXColor* mpPrmClrAnmTbl; diff --git a/include/JSystem/JParticle/JPADynamicsBlock.h b/include/JSystem/JParticle/JPADynamicsBlock.h index a27922913e..02b3961e5a 100644 --- a/include/JSystem/JParticle/JPADynamicsBlock.h +++ b/include/JSystem/JParticle/JPADynamicsBlock.h @@ -63,7 +63,7 @@ public: void init(); void create(JPAEmitterWorkData*); - void calc(JPAEmitterWorkData* work) { mpCalcVolumeFunc(work); } + void calc(JPAEmitterWorkData* work) const { mpCalcVolumeFunc(work); } s16 getStartFrame() const { return mpData->mStartFrame; } u32 getResUserWork() const { return mpData->mResUserWork; } @@ -71,32 +71,32 @@ public: u32 getVolumeType() const { return (mpData->mFlags >> 8) & 0x07; } u16 getDivNumber() const { return mpData->mDivNumber; } f32 getRateRndm() const { return mpData->mRateRndm; } - void getEmitterScl(JGeometry::TVec3<f32>* vec) const { - vec->set(mpData->mEmitterScl.x, mpData->mEmitterScl.y, mpData->mEmitterScl.z); + void getEmitterScl(JGeometry::TVec3<f32>* vec) const { + vec->set(mpData->mEmitterScl.x, mpData->mEmitterScl.y, mpData->mEmitterScl.z); } - void getEmitterTrs(JGeometry::TVec3<f32>* vec) const { - vec->set(mpData->mEmitterTrs.x, mpData->mEmitterTrs.y, mpData->mEmitterTrs.z); + void getEmitterTrs(JGeometry::TVec3<f32>* vec) const { + vec->set(mpData->mEmitterTrs.x, mpData->mEmitterTrs.y, mpData->mEmitterTrs.z); } - void getEmitterDir(JGeometry::TVec3<f32>* vec) const { - vec->set(mpData->mEmitterDir.x, mpData->mEmitterDir.y, mpData->mEmitterDir.z); + void getEmitterDir(JGeometry::TVec3<f32>* vec) const { + vec->set(mpData->mEmitterDir.x, mpData->mEmitterDir.y, mpData->mEmitterDir.z); } - void getEmitterRot(JGeometry::TVec3<s16>* vec) const { - vec->set(mpData->mEmitterRot.x, mpData->mEmitterRot.y, mpData->mEmitterRot.z); - } - s16 getMaxFrame() { return mpData->mMaxFrame; } - s16 getLifetime() { return mpData->mLifeTime; } - u16 getVolumeSize() { return mpData->mVolumeSize; } - f32 getRate() { return mpData->mRate; } - u8 getRateStep() { return mpData->mRateStep; } - f32 getVolumeSweep() { return mpData->mVolumeSweep; } - f32 getVolumeMinRad() { return mpData->mVolumeMinRad; } - f32 getInitVelOmni() { return mpData->mInitialVelOmni; } - f32 getInitVelAxis() { return mpData->mInitialVelAxis; } - f32 getInitVelDir() { return mpData->mInitialVelDir; } - f32 getInitVelDirSp() { return mpData->mSpread; } - f32 getInitVelRndm() { return mpData->mInitialVelRndm; } + void getEmitterRot(JGeometry::TVec3<s16>* vec) const { + vec->set(mpData->mEmitterRot.x, mpData->mEmitterRot.y, mpData->mEmitterRot.z); + } + s16 getMaxFrame() const { return mpData->mMaxFrame; } + s16 getLifetime() const { return mpData->mLifeTime; } + u16 getVolumeSize() const { return mpData->mVolumeSize; } + f32 getRate() const { return mpData->mRate; } + u8 getRateStep() const { return mpData->mRateStep; } + f32 getVolumeSweep() const { return mpData->mVolumeSweep; } + f32 getVolumeMinRad() const { return mpData->mVolumeMinRad; } + f32 getInitVelOmni() const { return mpData->mInitialVelOmni; } + f32 getInitVelAxis() const { return mpData->mInitialVelAxis; } + f32 getInitVelDir() const { return mpData->mInitialVelDir; } + f32 getInitVelDirSp() const { return mpData->mSpread; } + f32 getInitVelRndm() const { return mpData->mInitialVelRndm; } f32 getInitVelRatio() const { return mpData->mInitialVelRatio; } - f32 getAirRes() { return mpData->mAirResist; } + f32 getAirRes() const { return mpData->mAirResist; } f32 getLifetimeRndm() const { return mpData->mLifeTimeRndm; } f32 getMomentRndm() const { return mpData->mMoment; } diff --git a/include/JSystem/JParticle/JPAEmitter.h b/include/JSystem/JParticle/JPAEmitter.h index b79e6f9022..691096babe 100644 --- a/include/JSystem/JParticle/JPAEmitter.h +++ b/include/JSystem/JParticle/JPAEmitter.h @@ -115,7 +115,7 @@ public: void setStatus(u32 status) { mStatus |= status; } void clearStatus(u32 status) { mStatus &= ~status; } u32 checkStatus(u32 status) const { return (mStatus & status); } - bool checkFlag(u32 flag) const { return !!(mpRes->getDyn()->getFlag() & flag); } + u32 checkFlag(u32 flag) const { return pRes->getDyn()->getFlag() & flag; } u8 getResourceManagerID() const { return mResMgrID; } u8 getGroupID() const { return mGroupID; } u8 getDrawTimes() const { return mDrawTimes; } @@ -258,7 +258,7 @@ public: /* 0xD4 */ JPAList<JPABaseParticle> mAlivePtclChld; /* 0xE0 */ JPAList<JPABaseParticle>* mpPtclPool; /* 0xE4 */ JPAEmitterManager* mpEmtrMgr; - /* 0xE8 */ JPAResource* mpRes; + /* 0xE8 */ JPAResource* pRes; /* 0xEC */ JPAEmitterCallBack* mpEmtrCallBack; /* 0xF0 */ JPAParticleCallBack* mpPtclCallBack; /* 0xF4 */ u32 mStatus; diff --git a/include/JSystem/JParticle/JPAExTexShape.h b/include/JSystem/JParticle/JPAExTexShape.h index 43175517ec..841b0e052c 100644 --- a/include/JSystem/JParticle/JPAExTexShape.h +++ b/include/JSystem/JParticle/JPAExTexShape.h @@ -33,8 +33,8 @@ public: s8 getExpScale() const { return mpData->mExpScale; } u8 getIndTexIdx() const { return mpData->mIndTexIdx; } u8 getSecTexIdx() const { return mpData->mSecTexIdx; } - bool isUseIndirect() const { return !!(mpData->mFlags & 0x01); } - bool isUseSecTex() const { return !!(mpData->mFlags & 0x0100); } + BOOL isUseIndirect() const { return mpData->mFlags & 0x01; } + BOOL isUseSecTex() const { return mpData->mFlags & 0x0100; } public: const JPAExTexShapeData* mpData; diff --git a/include/JSystem/JParticle/JPAFieldBlock.h b/include/JSystem/JParticle/JPAFieldBlock.h index 56a2de1d15..ccca533622 100644 --- a/include/JSystem/JParticle/JPAFieldBlock.h +++ b/include/JSystem/JParticle/JPAFieldBlock.h @@ -21,32 +21,27 @@ public: /* 0x04 */ JGeometry::TVec3<f32> mAccel; }; -class JPAFieldVortex : public JPAFieldBase { +class JPAFieldGravity : public JPAFieldBase { public: void prepare(JPAEmitterWorkData*, JPAFieldBlock*); void calc(JPAEmitterWorkData*, JPAFieldBlock*, JPABaseParticle*); - ~JPAFieldVortex() {} - - /* 0x10 */ JGeometry::TVec3<f32> field_0x10; - /* 0x1C */ f32 field_0x1c; - /* 0x20 */ f32 field_0x20; + ~JPAFieldGravity() {} }; -class JPAFieldSpin : public JPAFieldBase { +class JPAFieldAir : public JPAFieldBase { public: void prepare(JPAEmitterWorkData*, JPAFieldBlock*); void calc(JPAEmitterWorkData*, JPAFieldBlock*, JPABaseParticle*); - ~JPAFieldSpin() {} - - /* 0x10 */ JGeometry::TVec3<f32> field_0x10; - /* 0x1C */ JGeometry::TVec3<f32> field_0x1c; - /* 0x28 */ JGeometry::TVec3<f32> field_0x28; + ~JPAFieldAir() {} }; -class JPAFieldRandom : public JPAFieldBase { +class JPAFieldMagnet : public JPAFieldBase { public: + void prepare(JPAEmitterWorkData*, JPAFieldBlock*); void calc(JPAEmitterWorkData*, JPAFieldBlock*, JPABaseParticle*); - ~JPAFieldRandom() {} + ~JPAFieldMagnet() {} + + /* 0x10 */ JGeometry::TVec3<f32> mDir; }; class JPAFieldNewton : public JPAFieldBase { @@ -59,20 +54,21 @@ public: /* 0x1C */ f32 mCutoff; }; -class JPAFieldMagnet : public JPAFieldBase { +class JPAFieldVortex : public JPAFieldBase { public: void prepare(JPAEmitterWorkData*, JPAFieldBlock*); void calc(JPAEmitterWorkData*, JPAFieldBlock*, JPABaseParticle*); - ~JPAFieldMagnet() {} + ~JPAFieldVortex() {} - /* 0x10 */ JGeometry::TVec3<f32> mDir; + /* 0x10 */ JGeometry::TVec3<f32> field_0x10; + /* 0x1C */ f32 field_0x1c; + /* 0x20 */ f32 field_0x20; }; -class JPAFieldGravity : public JPAFieldBase { +class JPAFieldRandom : public JPAFieldBase { public: - void prepare(JPAEmitterWorkData*, JPAFieldBlock*); void calc(JPAEmitterWorkData*, JPAFieldBlock*, JPABaseParticle*); - ~JPAFieldGravity() {} + ~JPAFieldRandom() {} }; class JPAFieldDrag : public JPAFieldBase { @@ -92,11 +88,15 @@ public: /* 0x28 */ JGeometry::TVec3<f32> field_0x28; }; -class JPAFieldAir : public JPAFieldBase { +class JPAFieldSpin : public JPAFieldBase { public: void prepare(JPAEmitterWorkData*, JPAFieldBlock*); void calc(JPAEmitterWorkData*, JPAFieldBlock*, JPABaseParticle*); - ~JPAFieldAir() {} + ~JPAFieldSpin() {} + + /* 0x10 */ JGeometry::TVec3<f32> field_0x10; + /* 0x1C */ JGeometry::TVec3<f32> field_0x1c; + /* 0x28 */ JGeometry::TVec3<f32> field_0x28; }; // unknown name @@ -122,36 +122,36 @@ public: JPAFieldBlock(u8 const*, JKRHeap*); void init(JKRHeap*); - u32 getType() { return mpData->mFlags & 0xF; } - u32 getAddType() { return (mpData->mFlags >> 8) & 3; } - u32 getSttFlag() { return mpData->mFlags >> 16; } - bool checkStatus(u16 flag) { return flag & getSttFlag(); } + u32 getType() const { return mpData->mFlags & 0xF; } + u32 getAddType() const { return (mpData->mFlags >> 8) & 3; } + u32 getSttFlag() const { return mpData->mFlags >> 16; } + u32 checkStatus(u16 flag) { return flag & getSttFlag(); } f32 getMagRndm() const { return mpData->mMagRndm; } f32 getVal1() const { return mpData->mVal1; } - f32 getFadeInTime() { return mpData->mFadeInTime; } - f32 getFadeOutTime() { return mpData->mFadeOutTime; } - f32 getEnTime() { return mpData->mEnTime; } - f32 getDisTime() { return mpData->mDisTime; } - u8 getCycle() { return mpData->mCycle; } - f32 getFadeInRate() { return mFadeInRate; } - f32 getFadeOutRate() { return mFadeOutRate; } - JGeometry::TVec3<f32>& getPos() { return mPos; } - JGeometry::TVec3<f32>& getDir() { return mDir; } + f32 getFadeInTime() const { return mpData->mFadeInTime; } + f32 getFadeOutTime() const { return mpData->mFadeOutTime; } + f32 getEnTime() const { return mpData->mEnTime; } + f32 getDisTime() const { return mpData->mDisTime; } + u8 getCycle() const { return mpData->mCycle; } + f32 getFadeInRate() const { return mFadeInRate; } + f32 getFadeOutRate() const { return mFadeOutRate; } + const JGeometry::TVec3<f32>& getPos() const { return mPos; } + const JGeometry::TVec3<f32>& getDir() const { return mDir; } f32 getMag() const { return mMag; } - void getPosOrig(JGeometry::TVec3<f32>* pos) { pos->set(mpData->mPos); } - void getDirOrig(JGeometry::TVec3<f32>* dir) { dir->set(mpData->mDir); } - f32 getMagOrig() { return mpData->mMag; } + void getPosOrig(JGeometry::TVec3<f32>* pos) const { pos->set(mpData->mPos); } + void getDirOrig(JGeometry::TVec3<f32>* dir) const { dir->set(mpData->mDir); } + f32 getMagOrig() const { return mpData->mMag; } void initOpParam() { getPosOrig(&mPos); getDirOrig(&mDir); mMag = getMagOrig(); } - void prepare(JPAEmitterWorkData* work) { mpField->prepare(work, this); } - void calc(JPAEmitterWorkData* work, JPABaseParticle* ptcl) { mpField->calc(work, this, ptcl); } + void prepare(JPAEmitterWorkData* work) { pFld->prepare(work, this); } + void calc(JPAEmitterWorkData* work, JPABaseParticle* ptcl) { pFld->calc(work, this, ptcl); } private: /* 0x00 */ const JPAFieldBlockData* mpData; - /* 0x04 */ JPAFieldBase* mpField; + /* 0x04 */ JPAFieldBase* pFld; /* 0x08 */ f32 mFadeInRate; /* 0x0C */ f32 mFadeOutRate; /* 0x10 */ JGeometry::TVec3<f32> mPos; diff --git a/include/JSystem/JParticle/JPAKeyBlock.h b/include/JSystem/JParticle/JPAKeyBlock.h index e1591f1d26..07c1f57171 100644 --- a/include/JSystem/JParticle/JPAKeyBlock.h +++ b/include/JSystem/JParticle/JPAKeyBlock.h @@ -11,7 +11,10 @@ struct JPAKeyBlock { JPAKeyBlock(u8 const*); f32 calc(f32); - u8 getID() { return mDataStart[8]; } + u8 getID() const { return mDataStart[8]; } + u8 getKeyNum() const { return mDataStart[9]; } + BOOL isLoop() const { return mDataStart[11]; } + const f32* getKeyData() const { return field_0x4; } const u8* mDataStart; const f32* field_0x4; diff --git a/include/JSystem/JParticle/JPAList.h b/include/JSystem/JParticle/JPAList.h index cb02349c87..6f201b73b8 100644 --- a/include/JSystem/JParticle/JPAList.h +++ b/include/JSystem/JParticle/JPAList.h @@ -12,8 +12,8 @@ struct JPANode { JPANode() : mpPrev(NULL), mpNext(NULL) { } ~JPANode() {} - JPANode<T>* getPrev() { return mpPrev; } - JPANode<T>* getNext() { return mpNext; } + JPANode<T>* getPrev() const { return mpPrev; } + JPANode<T>* getNext() const { return mpNext; } T* getObject() { return &mData; } /* 0x00 */ JPANode<T>* mpPrev; @@ -48,8 +48,7 @@ struct JPAList { } else { mpLast = node; mpFirst = node; - node->mpPrev = NULL; - node->mpNext = NULL; + node->mpNext = node->mpPrev = NULL; } mNum++; @@ -75,8 +74,7 @@ struct JPAList { if (mNum == 1) { ret = mpFirst; - mpLast = NULL; - mpFirst = NULL; + mpFirst = mpLast = NULL; mNum--; } else if (mNum) { ret = mpFirst; @@ -93,8 +91,7 @@ struct JPAList { if (mNum == 1) { ret = mpLast; - mpLast = NULL; - mpFirst = NULL; + mpFirst = mpLast = NULL; mNum--; } else if (mNum) { ret = mpLast; @@ -120,8 +117,7 @@ struct JPAList { mpLast = node->mpPrev; mNum--; } else { - mpLast = NULL; - mpFirst = NULL; + mpFirst = mpLast = NULL; mNum--; } return node; diff --git a/include/JSystem/JParticle/JPAParticle.h b/include/JSystem/JParticle/JPAParticle.h index e6e0bec6f4..64d682cfa2 100644 --- a/include/JSystem/JParticle/JPAParticle.h +++ b/include/JSystem/JParticle/JPAParticle.h @@ -33,17 +33,15 @@ public: void getOffsetPosition(JGeometry::TVec3<f32>& pos) { pos.set(mOffsetPosition); } void getOffsetPosition(JGeometry::TVec3<f32>* pos) const { pos->set(mOffsetPosition); } u16 getRotateAngle() const { return mRotateAngle; } - void getGlobalPosition(JGeometry::TVec3<f32>& pos) const { pos.set(mPosition); } void getGlobalPosition(JGeometry::TVec3<f32>* pos) const { pos->set(mPosition); } f32 getParticleScaleX() const { return mParticleScaleX; } f32 getParticleScaleY() const { return mParticleScaleY; } void setStatus(u32 flag) { mStatus |= flag; } - u32 checkStatus(u32 flag) { return mStatus & flag; } + u32 checkStatus(u32 flag) const { return mStatus & flag; } void initStatus(u32 status) { mStatus = status; } void setInvisibleParticleFlag() { setStatus(8); } void setDeleteParticleFlag() { setStatus(2); } - void getVelVec(JGeometry::TVec3<f32>& vec) const { vec.set(mVelocity); } - void getLocalPosition(JGeometry::TVec3<f32>& vec) const { vec.set(mLocalPosition); } + void getVelVec(JGeometry::TVec3<f32>* vec) const { vec->set(mVelocity); } void getLocalPosition(JGeometry::TVec3<f32>* vec) const { vec->set(mLocalPosition); } void getBaseAxis(JGeometry::TVec3<f32>& vec) const { vec.set(mBaseAxis); } void getBaseAxis(JGeometry::TVec3<f32>* vec) const { vec->set(mBaseAxis); } diff --git a/include/JSystem/JParticle/JPAResource.h b/include/JSystem/JParticle/JPAResource.h index f07868208d..707725c9af 100644 --- a/include/JSystem/JParticle/JPAResource.h +++ b/include/JSystem/JParticle/JPAResource.h @@ -37,13 +37,13 @@ public: void calcWorkData_c(JPAEmitterWorkData*); void calcWorkData_d(JPAEmitterWorkData*); - JPABaseShape* getBsp() const { return mpBaseShape; } - JPAExtraShape* getEsp() const { return mpExtraShape; } - JPAChildShape* getCsp() const { return mpChildShape; } - JPAExTexShape* getEts() const { return mpExTexShape; } - JPADynamicsBlock* getDyn() const { return mpDynamicsBlock; } + JPABaseShape* getBsp() const { return pBsp; } + JPAExtraShape* getEsp() const { return pEsp; } + JPAChildShape* getCsp() const { return pCsp; } + JPAExTexShape* getEts() const { return pEts; } + JPADynamicsBlock* getDyn() const { return pDyn; } - u32 getTexIdx(u32 idx) const { return mpTDB1[idx]; } + const u16 getTexIdx(u8 idx) { return mpTDB1[idx]; } u16 getUsrIdx() const { return mUsrIdx; } public: @@ -57,18 +57,18 @@ public: /* 0x14 */ ParticleFunc* mpCalcParticleChildFuncList; /* 0x18 */ ParticleFunc* mpDrawParticleChildFuncList; - /* 0x1C */ JPABaseShape* mpBaseShape; - /* 0x20 */ JPAExtraShape* mpExtraShape; - /* 0x24 */ JPAChildShape* mpChildShape; - /* 0x28 */ JPAExTexShape* mpExTexShape; - /* 0x2C */ JPADynamicsBlock* mpDynamicsBlock; - /* 0x30 */ JPAFieldBlock** mpFieldBlocks; - /* 0x34 */ JPAKeyBlock** mpKeyBlocks; + /* 0x1C */ JPABaseShape* pBsp; + /* 0x20 */ JPAExtraShape* pEsp; + /* 0x24 */ JPAChildShape* pCsp; + /* 0x28 */ JPAExTexShape* pEts; + /* 0x2C */ JPADynamicsBlock* pDyn; + /* 0x30 */ JPAFieldBlock** ppFld; + /* 0x34 */ JPAKeyBlock** ppKey; /* 0x38 */ u16 const* mpTDB1; /* 0x3C */ u16 mUsrIdx; - /* 0x3E */ u8 mFieldBlockNum; - /* 0x3F */ u8 mKeyBlockNum; - /* 0x40 */ u8 mTDB1Num; + /* 0x3E */ u8 fldNum; + /* 0x3F */ u8 keyNum; + /* 0x40 */ u8 texNum; /* 0x41 */ u8 mpCalcEmitterFuncListNum; /* 0x42 */ u8 mpDrawEmitterFuncListNum; /* 0x43 */ u8 mpDrawEmitterChildFuncListNum; diff --git a/include/JSystem/JParticle/JPAResourceManager.h b/include/JSystem/JParticle/JPAResourceManager.h index 60a027a6b9..068858c5a6 100644 --- a/include/JSystem/JParticle/JPAResourceManager.h +++ b/include/JSystem/JParticle/JPAResourceManager.h @@ -21,16 +21,16 @@ public: void registTex(JPATexture*); u32 getResUserWork(u16) const; - void load(u16 idx, GXTexMapID texMapID) { mpTexArr[idx]->load(texMapID); } + void load(u16 idx, GXTexMapID texMapID) { pTexAry[idx]->load(texMapID); } public: /* 0x00 */ JKRHeap* mpHeap; - /* 0x04 */ JPAResource** mpResArr; - /* 0x08 */ JPATexture** mpTexArr; - /* 0x0C */ u16 mResMax; - /* 0x0E */ u16 mResNum; - /* 0x10 */ u16 mTexMax; - /* 0x12 */ u16 mTexNum; + /* 0x04 */ JPAResource** pResAry; + /* 0x08 */ JPATexture** pTexAry; + /* 0x0C */ u16 resMaxNum; + /* 0x0E */ u16 resRegNum; + /* 0x10 */ u16 texMaxNum; + /* 0x12 */ u16 texRegNum; }; #endif /* JPARESOURCEMANAGER_H */ diff --git a/src/JSystem/JParticle/JPABaseShape.cpp b/src/JSystem/JParticle/JPABaseShape.cpp index 66b299af58..54991d2560 100644 --- a/src/JSystem/JParticle/JPABaseShape.cpp +++ b/src/JSystem/JParticle/JPABaseShape.cpp @@ -135,15 +135,7 @@ void JPACalcClrIdxNormal(JPAEmitterWorkData* work) { void JPACalcClrIdxNormal(JPAEmitterWorkData* work, JPABaseParticle* param_1) { JPABaseShape* shape = work->mpRes->getBsp(); - s16 age = param_1->mAge; - s16 maxFrm = shape->getClrAnmMaxFrm(); - s16 keyFrame; - if (age < maxFrm) { - keyFrame = age; - } else { - keyFrame = maxFrm; - } - work->mClrKeyFrame = keyFrame; + work->mClrKeyFrame = param_1->mAge < shape->getClrAnmMaxFrm() ? param_1->mAge : shape->getClrAnmMaxFrm(); } void JPACalcClrIdxRepeat(JPAEmitterWorkData* work) { @@ -153,27 +145,25 @@ void JPACalcClrIdxRepeat(JPAEmitterWorkData* work) { void JPACalcClrIdxRepeat(JPAEmitterWorkData* work, JPABaseParticle* param_1) { JPABaseShape* shape = work->mpRes->getBsp(); - s32 tick = shape->getClrLoopOfst(param_1->mAnmRandom); - tick = param_1->mAge + tick; - work->mClrKeyFrame = tick % (shape->getClrAnmMaxFrm() + 1); + s32 r28 = shape->getClrAnmMaxFrm() + 1; + work->mClrKeyFrame = (param_1->mAge + shape->getClrLoopOfst(param_1->mAnmRandom)) % r28; } void JPACalcClrIdxReverse(JPAEmitterWorkData* work) { JPABaseShape* shape = work->mpRes->getBsp(); int maxFrm = shape->getClrAnmMaxFrm(); - u32 tick = work->mpEmtr->mTick; - u32 uVar1 = tick / maxFrm; - tick = tick % maxFrm; - uVar1 &= 1; - work->mClrKeyFrame = tick + (uVar1) * (maxFrm - tick * 2); + u32 div = (work->mpEmtr->mTick / maxFrm) & 1; + u32 rem = work->mpEmtr->mTick % maxFrm; + work->mClrKeyFrame = rem + (div) * (maxFrm - rem * 2); } void JPACalcClrIdxReverse(JPAEmitterWorkData* work, JPABaseParticle* param_1) { JPABaseShape* shape = work->mpRes->getBsp(); - s32 tick = param_1->mAge + shape->getClrLoopOfst(param_1->mAnmRandom); + s32 r29 = param_1->mAge + shape->getClrLoopOfst(param_1->mAnmRandom); s32 maxFrm = shape->getClrAnmMaxFrm(); - s32 rem = tick % maxFrm; - work->mClrKeyFrame = rem + ((tick / maxFrm) & 1) * (maxFrm - rem * 2); + s32 div = (r29 / maxFrm) & 1; + s32 rem = r29 % maxFrm; + work->mClrKeyFrame = rem + (div) * (maxFrm - rem * 2); } void JPACalcClrIdxMerge(JPAEmitterWorkData* work) { @@ -183,8 +173,7 @@ void JPACalcClrIdxMerge(JPAEmitterWorkData* work) { void JPACalcClrIdxMerge(JPAEmitterWorkData* work, JPABaseParticle* param_1) { JPABaseShape* shape = work->mpRes->getBsp(); s32 maxFrm = shape->getClrAnmMaxFrm() + 1; - s32 tick = (s32)(param_1->mTime * maxFrm) + shape->getClrLoopOfst(param_1->mAnmRandom); - work->mClrKeyFrame = tick % maxFrm; + work->mClrKeyFrame = (s32(param_1->mTime * maxFrm) + shape->getClrLoopOfst(param_1->mAnmRandom)) % maxFrm; } void JPACalcClrIdxRandom(JPAEmitterWorkData* work) { @@ -193,9 +182,7 @@ void JPACalcClrIdxRandom(JPAEmitterWorkData* work) { void JPACalcClrIdxRandom(JPAEmitterWorkData* work, JPABaseParticle* param_1) { JPABaseShape* shape = work->mpRes->getBsp(); - s32 tick = shape->getClrLoopOfst(param_1->mAnmRandom); - s32 maxFrm = shape->getClrAnmMaxFrm() + 1; - work->mClrKeyFrame = tick % maxFrm; + work->mClrKeyFrame = shape->getClrLoopOfst(param_1->mAnmRandom) % (shape->getClrAnmMaxFrm() + 1); } void JPACalcPrm(JPAEmitterWorkData* work) { @@ -221,15 +208,15 @@ void JPACalcColorCopy(JPAEmitterWorkData* work, JPABaseParticle* ptcl) { } void JPAGenTexCrdMtxIdt(JPAEmitterWorkData* param_0) { - GXSetTexCoordGen2(GX_TEXCOORD0, GX_TG_MTX2x4, GX_TG_TEX0, GX_IDENTITY, GX_FALSE, GX_PTIDENTITY); + GXSetTexCoordGen(GX_TEXCOORD0, GX_TG_MTX2x4, GX_TG_TEX0, GX_IDENTITY); } void JPAGenTexCrdMtxAnm(JPAEmitterWorkData* param_0) { - GXSetTexCoordGen2(GX_TEXCOORD0, GX_TG_MTX2x4, GX_TG_TEX0, GX_TEXMTX0, GX_FALSE, GX_PTIDENTITY); + GXSetTexCoordGen(GX_TEXCOORD0, GX_TG_MTX2x4, GX_TG_TEX0, GX_TEXMTX0); } void JPAGenTexCrdMtxPrj(JPAEmitterWorkData* param_0) { - GXSetTexCoordGen2(GX_TEXCOORD0, GX_TG_MTX3x4, GX_TG_POS, GX_TEXMTX0, GX_FALSE, GX_PTIDENTITY); + GXSetTexCoordGen(GX_TEXCOORD0, GX_TG_MTX3x4, GX_TG_POS, GX_TEXMTX0); } void JPAGenCalcTexCrdMtxAnm(JPAEmitterWorkData* work) { @@ -260,7 +247,7 @@ void JPAGenCalcTexCrdMtxAnm(JPAEmitterWorkData* work) { local_108[2][2] = 1.0f; local_108[2][3] = 0.0f; GXLoadTexMtxImm(local_108, 0x1e, GX_MTX2x4); - GXSetTexCoordGen2(GX_TEXCOORD0, GX_TG_MTX2x4, GX_TG_TEX0, 0x1e, false, 0x7d); + GXSetTexCoordGen(GX_TEXCOORD0, GX_TG_MTX2x4, GX_TG_TEX0, GX_TEXMTX0); } void JPALoadCalcTexCrdMtxAnm(JPAEmitterWorkData* work, JPABaseParticle* param_1) { @@ -307,16 +294,12 @@ void JPALoadTexAnm(JPAEmitterWorkData* work, JPABaseParticle* ptcl) { void JPACalcTexIdxNormal(JPAEmitterWorkData* work) { JPABaseShape* shape = work->mpRes->getBsp(); - u8 tick = shape->getTexAnmKeyNum() - 1 < work->mpEmtr->mTick - ? shape->getTexAnmKeyNum() - 1 : work->mpEmtr->mTick; - work->mpEmtr->mTexAnmIdx = shape->getTexIdx(tick); + work->mpEmtr->mTexAnmIdx = shape->getTexIdx(shape->getTexAnmKeyNum() - 1 < work->mpEmtr->mTick ? shape->getTexAnmKeyNum() - 1 : work->mpEmtr->mTick); } void JPACalcTexIdxNormal(JPAEmitterWorkData* work, JPABaseParticle* param_1) { JPABaseShape* shape = work->mpRes->getBsp(); - u8 tick = shape->getTexAnmKeyNum() - 1 < param_1->mAge - ? shape->getTexAnmKeyNum() - 1 : param_1->mAge; - param_1->mTexAnmIdx = shape->getTexIdx(tick); + param_1->mTexAnmIdx = shape->getTexIdx(shape->getTexAnmKeyNum() - 1 < param_1->mAge ? shape->getTexAnmKeyNum() - 1 : param_1->mAge); } void JPACalcTexIdxRepeat(JPAEmitterWorkData* work) { @@ -335,18 +318,18 @@ void JPACalcTexIdxReverse(JPAEmitterWorkData* work) { JPABaseShape* shape = work->mpRes->getBsp(); int tick = work->mpEmtr->mTick; int keyNum = (int)shape->getTexAnmKeyNum() - 1; - int div = tick / keyNum; + int div = tick / keyNum & 1; int rem = tick % keyNum; - work->mpEmtr->mTexAnmIdx = shape->getTexIdx(rem + (div & 1) * (keyNum - rem * 2)); + work->mpEmtr->mTexAnmIdx = shape->getTexIdx(rem + div * (keyNum - rem * 2)); } void JPACalcTexIdxReverse(JPAEmitterWorkData* work, JPABaseParticle* param_1) { JPABaseShape* shape = work->mpRes->getBsp(); s32 tick = shape->getTexLoopOfst(param_1->mAnmRandom) + param_1->mAge; int keyNum = (int)shape->getTexAnmKeyNum() - 1; - int div = tick / keyNum; + int div = tick / keyNum & 1; int rem = tick % keyNum; - param_1->mTexAnmIdx = shape->getTexIdx(rem + (div & 1) * (keyNum - rem * 2)); + param_1->mTexAnmIdx = shape->getTexIdx(rem + div * (keyNum - rem * 2)); } void JPACalcTexIdxMerge(JPAEmitterWorkData* work) { @@ -356,8 +339,7 @@ void JPACalcTexIdxMerge(JPAEmitterWorkData* work) { void JPACalcTexIdxMerge(JPAEmitterWorkData* work, JPABaseParticle* param_1) { JPABaseShape* shape = work->mpRes->getBsp(); s32 maxFrm = shape->getTexAnmKeyNum(); - s32 tick = (s32)(maxFrm * param_1->mTime) + shape->getTexLoopOfst(param_1->mAnmRandom); - param_1->mTexAnmIdx = shape->getTexIdx(tick % maxFrm); + param_1->mTexAnmIdx = shape->getTexIdx((s32(maxFrm * param_1->mTime) + shape->getTexLoopOfst(param_1->mAnmRandom)) % maxFrm); } void JPACalcTexIdxRandom(JPAEmitterWorkData* work) { @@ -435,124 +417,122 @@ static projectionFunc p_prj[3] = { }; void JPADrawBillboard(JPAEmitterWorkData* work, JPABaseParticle* param_1) { - if (param_1->checkStatus(8) == 0) { - JGeometry::TVec3<f32> local_48; - MTXMultVec(work->mPosCamMtx, param_1->mPosition, local_48); - Mtx local_38; - local_38[0][0] = work->mGlobalPtclScl.x * param_1->mParticleScaleX; - local_38[0][3] = local_48.x; - local_38[1][1] = work->mGlobalPtclScl.y * param_1->mParticleScaleY; - local_38[1][3] = local_48.y; - local_38[2][2] = 1.0f; - local_38[2][3] = local_48.z; - local_38[2][1] = 0.0f; - local_38[2][0] = 0.0f; - local_38[1][2] = 0.0f; - local_38[1][0] = 0.0f; - local_38[0][2] = 0.0f; - local_38[0][1] = 0.0f; - GXLoadPosMtxImm(local_38, 0); - p_prj[work->mPrjType](work, local_38); - GXCallDisplayList(jpa_dl, sizeof(jpa_dl)); + if (param_1->checkStatus(JPAPtclStts_Invisible)) { + return; } + + JGeometry::TVec3<f32> local_48; + MTXMultVec(work->mPosCamMtx, ¶m_1->mPosition, &local_48); + Mtx local_38; + local_38[0][0] = work->mGlobalPtclScl.x * param_1->mParticleScaleX; + local_38[0][3] = local_48.x; + local_38[1][1] = work->mGlobalPtclScl.y * param_1->mParticleScaleY; + local_38[1][3] = local_48.y; + local_38[2][2] = 1.0f; + local_38[2][3] = local_48.z; + local_38[0][1] = local_38[0][2] = local_38[1][0] = local_38[1][2] = local_38[2][0] = local_38[2][1] = 0.0f; + GXLoadPosMtxImm(local_38, 0); + p_prj[work->mPrjType](work, local_38); + GXCallDisplayList(jpa_dl, sizeof(jpa_dl)); } void JPADrawRotBillboard(JPAEmitterWorkData* work, JPABaseParticle* param_1) { - if (param_1->checkStatus(8) == 0) { - JGeometry::TVec3<f32> local_48; - MTXMultVec(work->mPosCamMtx, param_1->mPosition, local_48); - f32 sinRot = JMASSin(param_1->mRotateAngle); - f32 cosRot = JMASCos(param_1->mRotateAngle); - f32 particleX = work->mGlobalPtclScl.x * param_1->mParticleScaleX; - f32 particleY = work->mGlobalPtclScl.y * param_1->mParticleScaleY; - - Mtx local_38; - local_38[0][0] = cosRot * particleX; - local_38[0][1] = -sinRot * particleY; - local_38[0][3] = local_48.x; - local_38[1][0] = sinRot * particleX; - local_38[1][1] = cosRot * particleY; - local_38[1][3] = local_48.y; - local_38[2][2] = 1.0f; - local_38[2][3] = local_48.z; - local_38[2][1] = 0.0f; - local_38[2][0] = 0.0f; - local_38[1][2] = 0.0f; - local_38[0][2] = 0.0f; - GXLoadPosMtxImm(local_38, 0); - p_prj[work->mPrjType](work, local_38); - GXCallDisplayList(jpa_dl, sizeof(jpa_dl)); + if (param_1->checkStatus(JPAPtclStts_Invisible)) { + return; } + + JGeometry::TVec3<f32> local_48; + MTXMultVec(work->mPosCamMtx, ¶m_1->mPosition, &local_48); + f32 sinRot = JMASSin(param_1->mRotateAngle); + f32 cosRot = JMASCos(param_1->mRotateAngle); + f32 particleX = work->mGlobalPtclScl.x * param_1->mParticleScaleX; + f32 particleY = work->mGlobalPtclScl.y * param_1->mParticleScaleY; + + Mtx local_38; + local_38[0][0] = cosRot * particleX; + local_38[0][1] = -sinRot * particleY; + local_38[0][3] = local_48.x; + local_38[1][0] = sinRot * particleX; + local_38[1][1] = cosRot * particleY; + local_38[1][3] = local_48.y; + local_38[2][2] = 1.0f; + local_38[2][3] = local_48.z; + local_38[0][2] = local_38[1][2] = local_38[2][0] = local_38[2][1] = 0.0f; + GXLoadPosMtxImm(local_38, 0); + p_prj[work->mPrjType](work, local_38); + GXCallDisplayList(jpa_dl, sizeof(jpa_dl)); } void JPADrawYBillboard(JPAEmitterWorkData* work, JPABaseParticle* param_1) { - if (param_1->checkStatus(8) == 0) { - JGeometry::TVec3<f32> local_48; - MTXMultVec(work->mPosCamMtx, param_1->mPosition, local_48); - Mtx local_38; - f32 particleY = work->mGlobalPtclScl.y * param_1->mParticleScaleY; - local_38[0][0] = work->mGlobalPtclScl.x * param_1->mParticleScaleX; - local_38[0][3] = local_48.x; - local_38[1][1] = work->mYBBCamMtx[1][1] * particleY; - local_38[1][2] = work->mYBBCamMtx[1][2]; - local_38[1][3] = local_48.y; - local_38[2][1] = work->mYBBCamMtx[2][1] * particleY; - local_38[2][2] = work->mYBBCamMtx[2][2]; - local_38[2][3] = local_48.z; - local_38[2][0] = 0.0f; - local_38[1][0] = 0.0f; - local_38[0][2] = 0.0f; - local_38[0][1] = 0.0f; - GXLoadPosMtxImm(local_38, 0); - p_prj[work->mPrjType](work, local_38); - GXCallDisplayList(jpa_dl, sizeof(jpa_dl)); + if (param_1->checkStatus(JPAPtclStts_Invisible)) { + return; } + + JGeometry::TVec3<f32> local_48; + MTXMultVec(work->mPosCamMtx, ¶m_1->mPosition, &local_48); + Mtx local_38; + f32 particleX = work->mGlobalPtclScl.x * param_1->mParticleScaleX; + f32 particleY = work->mGlobalPtclScl.y * param_1->mParticleScaleY; + local_38[0][0] = particleX; + local_38[0][3] = local_48.x; + local_38[1][1] = work->mYBBCamMtx[1][1] * particleY; + local_38[1][2] = work->mYBBCamMtx[1][2]; + local_38[1][3] = local_48.y; + local_38[2][1] = work->mYBBCamMtx[2][1] * particleY; + local_38[2][2] = work->mYBBCamMtx[2][2]; + local_38[2][3] = local_48.z; + local_38[0][1] = local_38[0][2] = local_38[1][0] = local_38[2][0] = 0.0f; + GXLoadPosMtxImm(local_38, 0); + p_prj[work->mPrjType](work, local_38); + GXCallDisplayList(jpa_dl, sizeof(jpa_dl)); } void JPADrawRotYBillboard(JPAEmitterWorkData* work, JPABaseParticle* param_1) { - if (param_1->checkStatus(8) == 0) { - JGeometry::TVec3<f32> local_48; - MTXMultVec(work->mPosCamMtx, param_1->mPosition, local_48); - f32 sinRot = JMASSin(param_1->mRotateAngle); - f32 cosRot = JMASCos(param_1->mRotateAngle); - Mtx local_38; - f32 particleX = work->mGlobalPtclScl.x * param_1->mParticleScaleX; - f32 particleY = work->mGlobalPtclScl.y * param_1->mParticleScaleY; - f32 local_98 = (float)(sinRot * particleX); - f32 local_94 = (float)(cosRot * particleY); - f32 local_90 = work->mYBBCamMtx[1][1]; - f32 fVar1 = work->mYBBCamMtx[2][1]; - local_38[0][0] = (float)(cosRot * particleX); - local_38[0][1] = (float)(-sinRot * particleY); - local_38[0][2] = 0.0f; - local_38[0][3] = local_48.x; - local_38[1][0] = local_98 * local_90; - local_38[1][1] = local_94 * local_90; - local_38[1][2] = -fVar1; - local_38[1][3] = local_48.y; - local_38[2][0] = local_98 * fVar1; - local_38[2][1] = local_94 * fVar1; - local_38[2][2] = local_90; - local_38[2][3] = local_48.z; - GXLoadPosMtxImm(local_38, 0); - p_prj[work->mPrjType](work, local_38); - GXCallDisplayList(jpa_dl, sizeof(jpa_dl)); + if (param_1->checkStatus(JPAPtclStts_Invisible)) { + return; } + + JGeometry::TVec3<f32> local_48; + MTXMultVec(work->mPosCamMtx, ¶m_1->mPosition, &local_48); + f32 sinRot = JMASSin(param_1->mRotateAngle); + f32 cosRot = JMASCos(param_1->mRotateAngle); + Mtx local_38; + f32 particleX = work->mGlobalPtclScl.x * param_1->mParticleScaleX; + f32 particleY = work->mGlobalPtclScl.y * param_1->mParticleScaleY; + f32 local_98 = (float)(sinRot * particleX); + f32 local_94 = (float)(cosRot * particleY); + f32 local_90 = work->mYBBCamMtx[1][1]; + f32 fVar1 = work->mYBBCamMtx[2][1]; + local_38[0][0] = (float)(cosRot * particleX); + local_38[0][1] = (float)(-sinRot * particleY); + local_38[0][2] = 0.0f; + local_38[0][3] = local_48.x; + local_38[1][0] = local_98 * local_90; + local_38[1][1] = local_94 * local_90; + local_38[1][2] = -fVar1; + local_38[1][3] = local_48.y; + local_38[2][0] = local_98 * fVar1; + local_38[2][1] = local_94 * fVar1; + local_38[2][2] = local_90; + local_38[2][3] = local_48.z; + GXLoadPosMtxImm(local_38, 0); + p_prj[work->mPrjType](work, local_38); + GXCallDisplayList(jpa_dl, sizeof(jpa_dl)); } void dirTypeVel(JPAEmitterWorkData const* work, JPABaseParticle const* param_1, JGeometry::TVec3<f32>* param_2) { - param_1->getVelVec(*param_2); + param_1->getVelVec(param_2); } void dirTypePos(JPAEmitterWorkData const* work, JPABaseParticle const* param_1, JGeometry::TVec3<f32>* param_2) { - param_1->getLocalPosition(*param_2); + param_1->getLocalPosition(param_2); } void dirTypePosInv(JPAEmitterWorkData const* work, JPABaseParticle const* param_1, JGeometry::TVec3<f32>* param_2) { - param_1->getLocalPosition(*param_2); + param_1->getLocalPosition(param_2); param_2->negate(); } @@ -564,13 +544,10 @@ void dirTypeEmtrDir(JPAEmitterWorkData const* work, JPABaseParticle const* param void dirTypePrevPtcl(JPAEmitterWorkData const* work, JPABaseParticle const* param_1, JGeometry::TVec3<f32>* param_2) { JGeometry::TVec3<f32> aTStack_24; - param_1->getGlobalPosition(aTStack_24); - JPANode<JPABaseParticle>* end = work->mpAlivePtcl->getEnd(); - JPANode<JPABaseParticle>* prev = work->mpCurNode->getPrev(); - - if (end != prev) { - JPABaseParticle* particle = work->mpCurNode->getPrev()->getObject(); - particle->getGlobalPosition(*param_2); + param_1->getGlobalPosition(&aTStack_24); + + if (work->mpCurNode->getPrev() != work->mpAlivePtcl->getEnd()) { + work->mpCurNode->getPrev()->getObject()->getGlobalPosition(param_2); } else { work->mpEmtr->calcEmitterGlobalPosition(param_2); } @@ -623,23 +600,22 @@ static void rotTypeZ(f32 param_0, f32 param_1, Mtx& param_2) { } static void rotTypeXYZ(f32 param_0, f32 param_1, Mtx& param_2) { - f32 f3 = 0.33333298563957214f * (1.0f - param_1); - f32 fVar1; - f32 f4; - f4 = f3 + 0.5773500204086304f * param_0; - fVar1 = f3 - 0.5773500204086304f * param_0; - f3 += param_1; - param_2[0][0] = f3; - param_2[0][1] = fVar1; - param_2[0][2] = f4; + f32 f31 = 0.33333298563957214f * (1.0f - param_1); + f32 f30 = 0.57735f * param_0; + f32 f29 = f31 + f30; + f30 = f31 - f30; + f31 += param_1; + param_2[0][0] = f31; + param_2[0][1] = f30; + param_2[0][2] = f29; param_2[0][3] = 0.0f; - param_2[1][0] = f4; - param_2[1][1] = f3; - param_2[1][2] = fVar1; + param_2[1][0] = f29; + param_2[1][1] = f31; + param_2[1][2] = f30; param_2[1][3] = 0.0f; - param_2[2][0] = fVar1; - param_2[2][1] = f4; - param_2[2][2] = f3; + param_2[2][0] = f30; + param_2[2][1] = f29; + param_2[2][2] = f31; param_2[2][3] = 0.0f; } @@ -704,141 +680,160 @@ static u8* p_dl[2] = { }; void JPADrawDirection(JPAEmitterWorkData* param_0, JPABaseParticle* param_1) { - if (param_1->checkStatus(8) == 0) { - JGeometry::TVec3<f32> local_6c; - JGeometry::TVec3<f32> local_78; - p_direction[param_0->mDirType](param_0, param_1, &local_6c); - if (!local_6c.isZero()) { - local_6c.normalize(); - local_78.cross(param_1->mBaseAxis, local_6c); - if (!local_78.isZero()) { - local_78.normalize(); - param_1->mBaseAxis.cross(local_6c, local_78); - param_1->mBaseAxis.normalize(); - Mtx local_60; - f32 fVar1 = param_0->mGlobalPtclScl.x * param_1->mParticleScaleX; - f32 fVar2 = param_0->mGlobalPtclScl.y * param_1->mParticleScaleY; - local_60[0][0] = param_1->mBaseAxis.x; - local_60[0][1] = local_6c.x; - local_60[0][2] = local_78.x; - local_60[0][3] = param_1->mPosition.x; - local_60[1][0] = param_1->mBaseAxis.y; - local_60[1][1] = local_6c.y; - local_60[1][2] = local_78.y; - local_60[1][3] = param_1->mPosition.y; - local_60[2][0] = param_1->mBaseAxis.z; - local_60[2][1] = local_6c.z; - local_60[2][2] = local_78.z; - local_60[2][3] = param_1->mPosition.z; - p_plane[param_0->mPlaneType](local_60, fVar1, fVar2); - MTXConcat(param_0->mPosCamMtx, local_60, local_60); - GXLoadPosMtxImm(local_60, 0); - p_prj[param_0->mPrjType](param_0, local_60); - GXCallDisplayList(p_dl[param_0->mDLType], sizeof(jpa_dl)); - } - } + if (param_1->checkStatus(JPAPtclStts_Invisible)) { + return; + } + + JGeometry::TVec3<f32> local_6c; + JGeometry::TVec3<f32> local_78; + p_direction[param_0->mDirType](param_0, param_1, &local_6c); + + if (local_6c.isZero()) { + return; } + + local_6c.normalize(); + local_78.cross(param_1->mBaseAxis, local_6c); + + if (local_78.isZero()) { + return; + } + + local_78.normalize(); + param_1->mBaseAxis.cross(local_6c, local_78); + param_1->mBaseAxis.normalize(); + Mtx local_60; + f32 fVar1 = param_0->mGlobalPtclScl.x * param_1->mParticleScaleX; + f32 fVar2 = param_0->mGlobalPtclScl.y * param_1->mParticleScaleY; + local_60[0][0] = param_1->mBaseAxis.x; + local_60[0][1] = local_6c.x; + local_60[0][2] = local_78.x; + local_60[0][3] = param_1->mPosition.x; + local_60[1][0] = param_1->mBaseAxis.y; + local_60[1][1] = local_6c.y; + local_60[1][2] = local_78.y; + local_60[1][3] = param_1->mPosition.y; + local_60[2][0] = param_1->mBaseAxis.z; + local_60[2][1] = local_6c.z; + local_60[2][2] = local_78.z; + local_60[2][3] = param_1->mPosition.z; + p_plane[param_0->mPlaneType](local_60, fVar1, fVar2); + MTXConcat(param_0->mPosCamMtx, local_60, local_60); + GXLoadPosMtxImm(local_60, 0); + p_prj[param_0->mPrjType](param_0, local_60); + GXCallDisplayList(p_dl[param_0->mDLType], sizeof(jpa_dl)); } void JPADrawRotDirection(JPAEmitterWorkData* param_0, JPABaseParticle* param_1) { - if (param_1->checkStatus(8) == 0) { - f32 sinRot = JMASSin(param_1->mRotateAngle); - f32 cosRot = JMASCos(param_1->mRotateAngle); - JGeometry::TVec3<f32> local_6c; - JGeometry::TVec3<f32> local_78; - p_direction[param_0->mDirType](param_0, param_1, &local_6c); - if (!local_6c.isZero()) { - local_6c.normalize(); - local_78.cross(param_1->mBaseAxis, local_6c); - if (!local_78.isZero()) { - local_78.normalize(); - param_1->mBaseAxis.cross(local_6c, local_78); - param_1->mBaseAxis.normalize(); - f32 particleX = param_0->mGlobalPtclScl.x * param_1->mParticleScaleX; - f32 particleY = param_0->mGlobalPtclScl.y * param_1->mParticleScaleY; - Mtx auStack_80; - Mtx local_60; - p_rot[param_0->mRotType](sinRot, cosRot, auStack_80); - p_plane[param_0->mPlaneType](auStack_80, particleX, particleY); - local_60[0][0] = param_1->mBaseAxis.x; - local_60[0][1] = local_6c.x; - local_60[0][2] = local_78.x; - local_60[0][3] = param_1->mPosition.x; - local_60[1][0] = param_1->mBaseAxis.y; - local_60[1][1] = local_6c.y; - local_60[1][2] = local_78.y; - local_60[1][3] = param_1->mPosition.y; - local_60[2][0] = param_1->mBaseAxis.z; - local_60[2][1] = local_6c.z; - local_60[2][2] = local_78.z; - local_60[2][3] = param_1->mPosition.z; - MTXConcat(local_60, auStack_80, auStack_80); - MTXConcat(param_0->mPosCamMtx, auStack_80, local_60); - GXLoadPosMtxImm(local_60, 0); - p_prj[param_0->mPrjType](param_0, local_60); - GXCallDisplayList(p_dl[param_0->mDLType], sizeof(jpa_dl)); - } - } + if (param_1->checkStatus(JPAPtclStts_Invisible)) { + return; } + + f32 sinRot = JMASSin(param_1->mRotateAngle); + f32 cosRot = JMASCos(param_1->mRotateAngle); + JGeometry::TVec3<f32> local_6c; + JGeometry::TVec3<f32> local_78; + p_direction[param_0->mDirType](param_0, param_1, &local_6c); + + if (local_6c.isZero()) { + return; + } + + local_6c.normalize(); + local_78.cross(param_1->mBaseAxis, local_6c); + + if (local_78.isZero()) { + return; + } + + local_78.normalize(); + param_1->mBaseAxis.cross(local_6c, local_78); + param_1->mBaseAxis.normalize(); + f32 particleX = param_0->mGlobalPtclScl.x * param_1->mParticleScaleX; + f32 particleY = param_0->mGlobalPtclScl.y * param_1->mParticleScaleY; + Mtx auStack_80; + Mtx local_60; + p_rot[param_0->mRotType](sinRot, cosRot, auStack_80); + p_plane[param_0->mPlaneType](auStack_80, particleX, particleY); + local_60[0][0] = param_1->mBaseAxis.x; + local_60[0][1] = local_6c.x; + local_60[0][2] = local_78.x; + local_60[0][3] = param_1->mPosition.x; + local_60[1][0] = param_1->mBaseAxis.y; + local_60[1][1] = local_6c.y; + local_60[1][2] = local_78.y; + local_60[1][3] = param_1->mPosition.y; + local_60[2][0] = param_1->mBaseAxis.z; + local_60[2][1] = local_6c.z; + local_60[2][2] = local_78.z; + local_60[2][3] = param_1->mPosition.z; + MTXConcat(local_60, auStack_80, auStack_80); + MTXConcat(param_0->mPosCamMtx, auStack_80, local_60); + GXLoadPosMtxImm(local_60, 0); + p_prj[param_0->mPrjType](param_0, local_60); + GXCallDisplayList(p_dl[param_0->mDLType], sizeof(jpa_dl)); } void JPADrawDBillboard(JPAEmitterWorkData* param_0, JPABaseParticle* param_1) { - if (param_1->checkStatus(8) == 0) { - JGeometry::TVec3<f32> local_70; - p_direction[param_0->mDirType](param_0, param_1, &local_70); - JGeometry::TVec3<f32> aTStack_7c; - aTStack_7c.set(param_0->mPosCamMtx[2][0], param_0->mPosCamMtx[2][1], - param_0->mPosCamMtx[2][2]); - local_70.cross(local_70, aTStack_7c); - if (!local_70.isZero()) { - local_70.normalize(); - MTXMultVecSR(param_0->mPosCamMtx, local_70, local_70); - JGeometry::TVec3<f32> local_88; - MTXMultVec(param_0->mPosCamMtx, param_1->mPosition, local_88); - f32 particleX = param_0->mGlobalPtclScl.x * param_1->mParticleScaleX; - f32 particleY = param_0->mGlobalPtclScl.y * param_1->mParticleScaleY; - Mtx local_60; - local_60[0][0] = local_70.x * particleX; - local_60[0][1] = -local_70.y * particleY; - local_60[0][3] = local_88.x; - local_60[1][0] = local_70.y * particleX; - local_60[1][1] = local_70.x * particleY; - local_60[1][3] = local_88.y; - local_60[2][2] = 1.0f; - local_60[2][3] = local_88.z; - local_60[2][1] = 0.0f; - local_60[2][0] = 0.0f; - local_60[1][2] = 0.0f; - local_60[0][2] = 0.0f; - GXLoadPosMtxImm(local_60, 0); - p_prj[param_0->mPrjType](param_0, local_60); - GXCallDisplayList(jpa_dl, sizeof(jpa_dl)); - } + if (param_1->checkStatus(JPAPtclStts_Invisible)) { + return; + } + + JGeometry::TVec3<f32> local_70; + p_direction[param_0->mDirType](param_0, param_1, &local_70); + JGeometry::TVec3<f32> aTStack_7c(param_0->mPosCamMtx[2][0], param_0->mPosCamMtx[2][1], param_0->mPosCamMtx[2][2]); + local_70.cross(local_70, aTStack_7c); + + if (local_70.isZero()) { + return; } + + local_70.normalize(); + MTXMultVecSR(param_0->mPosCamMtx, &local_70, &local_70); + JGeometry::TVec3<f32> local_88; + MTXMultVec(param_0->mPosCamMtx, ¶m_1->mPosition, &local_88); + f32 particleX = param_0->mGlobalPtclScl.x * param_1->mParticleScaleX; + f32 particleY = param_0->mGlobalPtclScl.y * param_1->mParticleScaleY; + Mtx local_60; + local_60[0][0] = local_70.x * particleX; + local_60[0][1] = -local_70.y * particleY; + local_60[0][3] = local_88.x; + local_60[1][0] = local_70.y * particleX; + local_60[1][1] = local_70.x * particleY; + local_60[1][3] = local_88.y; + local_60[2][2] = 1.0f; + local_60[2][3] = local_88.z; + local_60[0][2] = local_60[1][2] = local_60[2][0] = local_60[2][1] = 0.0f; + GXLoadPosMtxImm(local_60, 0); + p_prj[param_0->mPrjType](param_0, local_60); + GXCallDisplayList(jpa_dl, sizeof(jpa_dl)); } void JPADrawRotation(JPAEmitterWorkData* param_0, JPABaseParticle* param_1) { - if (param_1->checkStatus(8) == 0) { - f32 sinRot = JMASSin(param_1->mRotateAngle); - f32 cosRot = JMASCos(param_1->mRotateAngle); - f32 particleX = param_0->mGlobalPtclScl.x * param_1->mParticleScaleX; - f32 particleY = param_0->mGlobalPtclScl.y * param_1->mParticleScaleY; - Mtx auStack_88; - p_rot[param_0->mRotType](sinRot, cosRot, auStack_88); - p_plane[param_0->mPlaneType](auStack_88, particleX, particleY); - auStack_88[0][3] = param_1->mPosition.x; - auStack_88[1][3] = param_1->mPosition.y; - auStack_88[2][3] = param_1->mPosition.z; - MTXConcat(param_0->mPosCamMtx, auStack_88, auStack_88); - GXLoadPosMtxImm(auStack_88, 0); - p_prj[param_0->mPrjType](param_0, auStack_88); - GXCallDisplayList(p_dl[param_0->mDLType], sizeof(jpa_dl)); + if (param_1->checkStatus(JPAPtclStts_Invisible)) { + return; } + + f32 sinRot = JMASSin(param_1->mRotateAngle); + f32 cosRot = JMASCos(param_1->mRotateAngle); + f32 particleX = param_0->mGlobalPtclScl.x * param_1->mParticleScaleX; + f32 particleY = param_0->mGlobalPtclScl.y * param_1->mParticleScaleY; + Mtx auStack_88; + p_rot[param_0->mRotType](sinRot, cosRot, auStack_88); + p_plane[param_0->mPlaneType](auStack_88, particleX, particleY); + auStack_88[0][3] = param_1->mPosition.x; + auStack_88[1][3] = param_1->mPosition.y; + auStack_88[2][3] = param_1->mPosition.z; + MTXConcat(param_0->mPosCamMtx, auStack_88, auStack_88); + GXLoadPosMtxImm(auStack_88, 0); + p_prj[param_0->mPrjType](param_0, auStack_88); + GXCallDisplayList(p_dl[param_0->mDLType], sizeof(jpa_dl)); } void JPADrawPoint(JPAEmitterWorkData* work, JPABaseParticle* ptcl) { - if (!!(ptcl->mStatus & JPAPtclStts_Invisible)) + if (ptcl->checkStatus(JPAPtclStts_Invisible)) { return; + } GXSetVtxDesc(GX_VA_POS, GX_DIRECT); GXSetVtxDesc(GX_VA_TEX0, GX_DIRECT); @@ -851,26 +846,30 @@ void JPADrawPoint(JPAEmitterWorkData* work, JPABaseParticle* ptcl) { } void JPADrawLine(JPAEmitterWorkData* param_0, JPABaseParticle* param_1) { - if (param_1->checkStatus(8) == 0) { - JGeometry::TVec3<f32> local_1c; - JGeometry::setTVec3f(¶m_1->mPosition.x, &local_1c.x); - JGeometry::TVec3<f32> local_28; - param_1->getVelVec(local_28); - if (!local_28.isZero()) { - local_28.setLength(param_0->mGlobalPtclScl.y * (25.0f * param_1->mParticleScaleY)); - local_28.sub(local_1c, local_28); - GXSetVtxDesc(GX_VA_POS, GX_DIRECT); - GXSetVtxDesc(GX_VA_TEX0, GX_DIRECT); - GXBegin(GX_LINES, GX_VTXFMT1, 2); - GXPosition3f32(local_1c.x, local_1c.y, local_1c.z); - GXTexCoord2f32(0.0f, 0.0f); - GXPosition3f32(local_28.x, local_28.y, local_28.z); - GXTexCoord2f32(0.0f, 1.0f); - GXEnd(); - GXSetVtxDesc(GX_VA_POS, GX_INDEX8); - GXSetVtxDesc(GX_VA_TEX0, GX_INDEX8); - } + if (param_1->checkStatus(JPAPtclStts_Invisible)) { + return; } + + JGeometry::TVec3<f32> local_1c(param_1->mPosition); + JGeometry::TVec3<f32> local_28; + param_1->getVelVec(&local_28); + + if (local_28.isZero()) { + return; + } + + local_28.setLength(param_0->mGlobalPtclScl.y * (25.0f * param_1->mParticleScaleY)); + local_28.sub(local_1c, local_28); + GXSetVtxDesc(GX_VA_POS, GX_DIRECT); + GXSetVtxDesc(GX_VA_TEX0, GX_DIRECT); + GXBegin(GX_LINES, GX_VTXFMT1, 2); + GXPosition3f32(local_1c.x, local_1c.y, local_1c.z); + GXTexCoord2f32(0.0f, 0.0f); + GXPosition3f32(local_28.x, local_28.y, local_28.z); + GXTexCoord2f32(0.0f, 1.0f); + GXEnd(); + GXSetVtxDesc(GX_VA_POS, GX_INDEX8); + GXSetVtxDesc(GX_VA_TEX0, GX_INDEX8); } JPANode<JPABaseParticle>* getNext(JPANode<JPABaseParticle>* param_0) { @@ -901,8 +900,8 @@ void JPADrawStripe(JPAEmitterWorkData* param_0) { JGeometry::TVec3<f32> local_e0[2]; JGeometry::TVec3<f32> local_f8; JGeometry::TVec3<f32> local_104; - getNodeFunc node_func; - JPANode<JPABaseParticle>* startNode; + JPANode<JPABaseParticle>* startNode = NULL; + getNodeFunc node_func = NULL; if (shape->isDrawFwdAhead()) { startNode = param_0->mpAlivePtcl->getLast(); node_func = getPrev; @@ -990,8 +989,8 @@ void JPADrawStripeX(JPAEmitterWorkData* param_0) { JGeometry::TVec3<f32> local_a8[2]; JGeometry::TVec3<f32> local_c0; JGeometry::TVec3<f32> local_cc; - JPANode<JPABaseParticle>* startNode; - getNodeFunc node_func; + JPANode<JPABaseParticle>* startNode = NULL; + getNodeFunc node_func = NULL; if (shape->isDrawFwdAhead()) { startNode = param_0->mpAlivePtcl->getLast(); node_func = getPrev; @@ -1109,22 +1108,27 @@ void JPADrawStripeX(JPAEmitterWorkData* param_0) { } void JPADrawEmitterCallBackB(JPAEmitterWorkData* work) { - if (work->mpEmtr->mpEmtrCallBack == NULL) + JPABaseEmitter* emtr = work->mpEmtr; + if (emtr->mpEmtrCallBack == NULL) { return; + } - work->mpEmtr->mpEmtrCallBack->draw(work->mpEmtr); + emtr->mpEmtrCallBack->draw(emtr); } void JPADrawParticleCallBack(JPAEmitterWorkData* work, JPABaseParticle* ptcl) { - if (work->mpEmtr->mpPtclCallBack == NULL) + JPABaseEmitter* emtr = work->mpEmtr; + if (emtr->mpPtclCallBack == NULL) { return; + } - work->mpEmtr->mpPtclCallBack->draw(work->mpEmtr, ptcl); + emtr->mpPtclCallBack->draw(emtr, ptcl); } static void makeColorTable(GXColor** o_color_table, JPAClrAnmKeyData const* i_data, u8 param_2, s16 i_size, JKRHeap* i_heap) { - GXColor* color_table = (GXColor*)JKRAllocFromHeap(i_heap, (i_size + 1) * 4, 4); + GXColor* p_clr_tbl = (GXColor*)JKRAllocFromHeap(i_heap, (i_size + 1) * 4, 4); + JUT_ASSERT(1548, p_clr_tbl); f32 r_step, g_step, b_step, a_step; r_step = g_step = b_step = a_step = 0.0f; f32 r = i_data[0].color.r; @@ -1134,7 +1138,7 @@ static void makeColorTable(GXColor** o_color_table, JPAClrAnmKeyData const* i_da int j = 0; for (s16 i = 0; i < i_size + 1; i++) { if (i == i_data[j].index) { - color_table[i] = i_data[j].color; + p_clr_tbl[i] = i_data[j].color; r = i_data[j].color.r; g = i_data[j].color.g; b = i_data[j].color.b; @@ -1151,49 +1155,16 @@ static void makeColorTable(GXColor** o_color_table, JPAClrAnmKeyData const* i_da } } else { r += r_step; - color_table[i].r = r; + p_clr_tbl[i].r = r; g += g_step; - color_table[i].g = g; + p_clr_tbl[i].g = g; b += b_step; - color_table[i].b = b; + p_clr_tbl[i].b = b; a += a_step; - color_table[i].a = a; + p_clr_tbl[i].a = a; } } - *o_color_table = color_table; -} - -JPABaseShape::JPABaseShape(u8 const* pData, JKRHeap* pHeap) { - mpData = (const JPABaseShapeData*)pData; - - if (isTexCrdAnm()) { - mpTexCrdMtxAnmTbl = (const void*)(pData + sizeof(JPABaseShapeData)); - } else { - mpTexCrdMtxAnmTbl = NULL; - } - - if (isTexAnm()) { - u32 offs = sizeof(JPABaseShapeData); - if (isTexCrdAnm()) - offs = sizeof(JPABaseShapeData) + 0x28; - mpTexIdxAnimTbl = (const u8*)(pData + offs); - } else { - mpTexIdxAnimTbl = NULL; - } - - if (isPrmAnm()) { - makeColorTable(&mpPrmClrAnmTbl, (JPAClrAnmKeyData*)(pData + mpData->mClrPrmAnmOffset), - mpData->mClrPrmKeyNum, mpData->mClrAnmFrmMax, pHeap); - } else { - mpPrmClrAnmTbl = NULL; - } - - if (isEnvAnm()) { - makeColorTable(&mpEnvClrAnmTbl, (JPAClrAnmKeyData*)(pData + mpData->mClrEnvAnmOffset), - mpData->mClrEnvKeyNum, mpData->mClrAnmFrmMax, pHeap); - } else { - mpEnvClrAnmTbl = NULL; - } + *o_color_table = p_clr_tbl; } GXBlendMode JPABaseShape::st_bm[3] = { @@ -1279,15 +1250,55 @@ GXTevAlphaArg JPABaseShape::st_aa[2][4] = { }, }; +JPABaseShape::JPABaseShape(u8 const* pData, JKRHeap* pHeap) { + pBsd = (const JPABaseShapeData*)pData; + + if (isTexCrdAnm()) { + mpTexCrdMtxAnmTbl = (const void*)(pData + sizeof(JPABaseShapeData)); + } else { + mpTexCrdMtxAnmTbl = NULL; + } + + if (isTexAnm()) { + JUT_ASSERT(1698, pBsd->texAnmKeyNum != NULL); + u32 offs = sizeof(JPABaseShapeData); + if (isTexCrdAnm()) { + offs += 0x28; + } + mpTexIdxAnimTbl = (const u8*)(pData + offs); + } else { + mpTexIdxAnimTbl = NULL; + } + + if (isPrmAnm()) { + JUT_ASSERT(1707, pBsd->prmAnmKeyNum != NULL); + JPAClrAnmKeyData* anmKeyData = (JPAClrAnmKeyData*)(pData + pBsd->mClrPrmAnmOffset); + makeColorTable(&mpPrmClrAnmTbl, anmKeyData, + pBsd->prmAnmKeyNum, pBsd->mClrAnmFrmMax, pHeap); + } else { + mpPrmClrAnmTbl = NULL; + } + + if (isEnvAnm()) { + JUT_ASSERT(1716, pBsd->envAnmKeyNum != NULL); + JPAClrAnmKeyData* anmKeyData = (JPAClrAnmKeyData*)(pData + pBsd->mClrEnvAnmOffset); + makeColorTable(&mpEnvClrAnmTbl, anmKeyData, + pBsd->envAnmKeyNum, pBsd->mClrAnmFrmMax, pHeap); + } else { + mpEnvClrAnmTbl = NULL; + } +} + void JPABaseShape::setGX(JPAEmitterWorkData* work) const { - const GXTevColorArg* colorArg = getTevColorArg(); - const GXTevAlphaArg* alphaArg = getTevAlphaArg(); - GXSetBlendMode(getBlendMode(), getBlendSrc(), getBlendDst(), getLogicOp()); - GXSetZMode(getZEnable(), getZCmp(), getZUpd()); - GXSetAlphaCompare(getAlphaCmp0(), getAlphaRef0(), getAlphaOp(), getAlphaCmp1(), getAlphaRef1()); + JPAExtraShape* extraShape = work->mpRes->getEsp(); + const GXTevColorArg* colorArg = st_ca[(pBsd->mFlags >> 0x0F) & 0x07]; + const GXTevAlphaArg* alphaArg = st_aa[(pBsd->mFlags >> 0x12) & 0x01]; + GXSetBlendMode(st_bm[pBsd->mBlendModeCfg & 0x03], st_bf[(pBsd->mBlendModeCfg >> 2) & 0x0F], st_bf[(pBsd->mBlendModeCfg >> 6) & 0x0F], st_lo[(pBsd->mBlendModeCfg >> 10) & 0x0F]); + GXSetZMode(pBsd->mZModeCfg & 0x01, st_c[(pBsd->mZModeCfg >> 1) & 0x07], (pBsd->mZModeCfg >> 4) & 0x01); + GXSetAlphaCompare(st_c[pBsd->mAlphaCompareCfg & 0x07], pBsd->mAlphaRef0, st_ao[(pBsd->mAlphaCompareCfg >> 3) & 0x03], st_c[(pBsd->mAlphaCompareCfg >> 5) & 0x07], pBsd->mAlphaRef1); GXSetTevColorIn(GX_TEVSTAGE0, colorArg[0], colorArg[1], colorArg[2], colorArg[3]); GXSetTevAlphaIn(GX_TEVSTAGE0, alphaArg[0], alphaArg[1], alphaArg[2], alphaArg[3]); GXSetTevDirect(GX_TEVSTAGE0); GXSetTevDirect(GX_TEVSTAGE1); - GXSetZCompLoc(getZCompLoc()); + GXSetZCompLoc((pBsd->mZModeCfg >> 5) & 0x01); } diff --git a/src/JSystem/JParticle/JPADynamicsBlock.cpp b/src/JSystem/JParticle/JPADynamicsBlock.cpp index 2a0616f5d1..ee22259d89 100644 --- a/src/JSystem/JParticle/JPADynamicsBlock.cpp +++ b/src/JSystem/JParticle/JPADynamicsBlock.cpp @@ -63,11 +63,11 @@ void JPAVolumeCube(JPAEmitterWorkData* work) { } static void JPAVolumeSphere(JPAEmitterWorkData* work) { - s16 phi, theta; + s16 phi, r28; if (work->mpEmtr->checkFlag(JPADynFlag_FixedInterval)) { - phi = (u16)(work->mVolumeX * 0x8000 / (work->mDivNumber - 1) + 0x4000); - f32 tmp = (u16)(work->mVolumeAngleNum * 0x10000 / (work->mVolumeAngleMax - 1)); - theta = tmp * work->mVolumeSweep + 0x8000; + phi = u16(work->mVolumeX * 0x8000 / (work->mDivNumber - 1) + 0x4000); + u16 r26 = u16(work->mVolumeAngleNum * 0x10000 / (work->mVolumeAngleMax - 1)); + r28 = f32(r26) * work->mVolumeSweep + 0x8000; work->mVolumeAngleNum++; if (work->mVolumeAngleNum == work->mVolumeAngleMax) { work->mVolumeAngleNum = 0; @@ -81,30 +81,30 @@ static void JPAVolumeSphere(JPAEmitterWorkData* work) { } } else { phi = work->mpEmtr->get_r_ss() >> 1; - theta = work->mVolumeSweep * work->mpEmtr->get_r_ss(); + r28 = work->mVolumeSweep * work->mpEmtr->get_r_ss(); } - f32 rnd = work->mpEmtr->get_r_f(); + f32 f31 = work->mpEmtr->get_r_f(); if (work->mpEmtr->checkFlag(JPADynFlag_FixedDensity)) { - rnd = 1.0f - rnd * rnd * rnd; + f31 = 1.0f - f31 * f31 * f31; } - f32 rad = work->mVolumeSize * (work->mVolumeMinRad + rnd * (1.0f - work->mVolumeMinRad)); - work->mVolumeCalcData.mVolumePos.set(rad * JMASCos(phi) * JMASSin(theta), -rad * JMASSin(phi), - rad * JMASCos(phi) * JMASCos(theta)); + f31 = work->mVolumeSize * (work->mVolumeMinRad + f31 * (1.0f - work->mVolumeMinRad)); + work->mVolumeCalcData.mVolumePos.set(f31 * JMASCos(phi) * JMASSin(r28), -f31 * JMASSin(phi), + f31 * JMASCos(phi) * JMASCos(r28)); work->mVolumeCalcData.mVelOmni.mul(work->mVolumeCalcData.mVolumePos, work->mGlobalScl); work->mVolumeCalcData.mVelAxis.set(work->mVolumeCalcData.mVolumePos.x, 0.0f, work->mVolumeCalcData.mVolumePos.z); } static void JPAVolumeCylinder(JPAEmitterWorkData* work) { - s16 theta = work->mVolumeSweep * work->mpEmtr->get_r_ss(); - f32 rnd = work->mpEmtr->get_r_f(); + s16 r30 = work->mVolumeSweep * work->mpEmtr->get_r_ss(); + f32 f31 = work->mpEmtr->get_r_f(); if (work->mpEmtr->checkFlag(JPADynFlag_FixedDensity)) { - rnd = 1.0f - rnd * rnd; + f31 = 1.0f - f31 * f31; } - f32 rad = work->mVolumeSize * (work->mVolumeMinRad + rnd * (1.0f - work->mVolumeMinRad)); + f31 = work->mVolumeSize * (work->mVolumeMinRad + f31 * (1.0f - work->mVolumeMinRad)); work->mVolumeCalcData.mVolumePos.set( - rad * JMASSin(theta), work->mVolumeSize * work->mpEmtr->get_r_zp(), rad * JMASCos(theta)); + f31 * JMASSin(r30), work->mVolumeSize * work->mpEmtr->get_r_zp(), f31 * JMASCos(r30)); work->mVolumeCalcData.mVelOmni.mul(work->mVolumeCalcData.mVolumePos, work->mGlobalScl); work->mVolumeCalcData.mVelAxis.set(work->mVolumeCalcData.mVolumePos.x, 0.0f, work->mVolumeCalcData.mVolumePos.z); @@ -166,26 +166,16 @@ void JPADynamicsBlock::init() { void JPADynamicsBlock::create(JPAEmitterWorkData* work) { if (work->mpEmtr->checkStatus(JPAEmtrStts_RateStepEmit)) { - s32 emitCount; - s32 createCount; + s32 emitCount = 0; - // Probably an inlined function. if (work->mpEmtr->checkFlag(JPADynFlag_FixedInterval)) { - s32 count; - if (getVolumeType() == VOL_Sphere) { - count = 4 * getDivNumber() * getDivNumber() + 2; - } else { - count = getDivNumber(); - } - emitCount = count; + emitCount = getVolumeType() == VOL_Sphere ? 4 * getDivNumber() * getDivNumber() + 2 : getDivNumber(); work->mVolumeEmitIdx = 0; } else { f32 newPtclCount = work->mpEmtr->mRate * (getRateRndm() * work->mpEmtr->get_r_zp() + 1.0f); - f32 newEmitCount = work->mpEmtr->mEmitCount + newPtclCount; - work->mpEmtr->mEmitCount = newEmitCount; - emitCount = (s32)newEmitCount; + emitCount = work->mpEmtr->mEmitCount += newPtclCount; work->mpEmtr->mEmitCount -= emitCount; if (work->mpEmtr->checkStatus(JPAEmtrStts_FirstEmit) && 0.0f < newPtclCount && @@ -198,10 +188,10 @@ void JPADynamicsBlock::create(JPAEmitterWorkData* work) { emitCount = 0; } - // Probably an inlined function. - createCount = emitCount; + JPABaseParticle* ptcl = NULL; + s32 createCount = emitCount; while (createCount > 0) { - JPABaseParticle* ptcl = work->mpEmtr->createParticle(); + ptcl = work->mpEmtr->createParticle(); if (ptcl == NULL) break; createCount--; @@ -209,7 +199,7 @@ void JPADynamicsBlock::create(JPAEmitterWorkData* work) { } if (++work->mpEmtr->mRateStepTimer >= (work->mpEmtr->mRateStep + 1)) { - work->mpEmtr->mRateStepTimer -= (work->mpEmtr->mRateStep + 1); + work->mpEmtr->mRateStepTimer -= work->mpEmtr->mRateStep + 1; work->mpEmtr->setStatus(JPAEmtrStts_RateStepEmit); } else { work->mpEmtr->clearStatus(JPAEmtrStts_RateStepEmit); diff --git a/src/JSystem/JParticle/JPAEmitter.cpp b/src/JSystem/JParticle/JPAEmitter.cpp index 95ab4147dd..fb03d52640 100644 --- a/src/JSystem/JParticle/JPAEmitter.cpp +++ b/src/JSystem/JParticle/JPAEmitter.cpp @@ -12,38 +12,31 @@ JPAEmitterCallBack::~JPAEmitterCallBack() { void JPABaseEmitter::init(JPAEmitterManager* param_0, JPAResource* param_1) { mpEmtrMgr = param_0; - mpRes = param_1; - mpRes->getDyn()->getEmitterScl(&mLocalScl); - mpRes->getDyn()->getEmitterTrs(&mLocalTrs); - mpRes->getDyn()->getEmitterDir(&mLocalDir); + pRes = param_1; + pRes->getDyn()->getEmitterScl(&mLocalScl); + pRes->getDyn()->getEmitterTrs(&mLocalTrs); + pRes->getDyn()->getEmitterDir(&mLocalDir); mLocalDir.normalize(); - mpRes->getDyn()->getEmitterRot(&mLocalRot); - mMaxFrame = mpRes->getDyn()->getMaxFrame(); - mLifeTime = mpRes->getDyn()->getLifetime(); - mVolumeSize = mpRes->getDyn()->getVolumeSize(); - mRate = mpRes->getDyn()->getRate(); - mRateStep = mpRes->getDyn()->getRateStep(); - mVolumeSweep = mpRes->getDyn()->getVolumeSweep(); - mVolumeMinRad = mpRes->getDyn()->getVolumeMinRad(); - mAwayFromCenterSpeed = mpRes->getDyn()->getInitVelOmni(); - mAwayFromAxisSpeed = mpRes->getDyn()->getInitVelAxis(); - mDirSpeed = mpRes->getDyn()->getInitVelDir(); - mSpread = mpRes->getDyn()->getInitVelDirSp(); - mRndmDirSpeed = mpRes->getDyn()->getInitVelRndm(); - mAirResist = mpRes->getDyn()->getAirRes(); + pRes->getDyn()->getEmitterRot(&mLocalRot); + mMaxFrame = pRes->getDyn()->getMaxFrame(); + mLifeTime = pRes->getDyn()->getLifetime(); + mVolumeSize = pRes->getDyn()->getVolumeSize(); + mRate = pRes->getDyn()->getRate(); + mRateStep = pRes->getDyn()->getRateStep(); + mVolumeSweep = pRes->getDyn()->getVolumeSweep(); + mVolumeMinRad = pRes->getDyn()->getVolumeMinRad(); + mAwayFromCenterSpeed = pRes->getDyn()->getInitVelOmni(); + mAwayFromAxisSpeed = pRes->getDyn()->getInitVelAxis(); + mDirSpeed = pRes->getDyn()->getInitVelDir(); + mSpread = pRes->getDyn()->getInitVelDirSp(); + mRndmDirSpeed = pRes->getDyn()->getInitVelRndm(); + mAirResist = pRes->getDyn()->getAirRes(); mRndm.set_seed(mpEmtrMgr->pWd->mRndm.get_rndm_u()); MTXIdentity(mGlobalRot); mGlobalScl.set(1.0f, 1.0f, 1.0f); mGlobalTrs.zero(); mGlobalPScl.set(1.0f, 1.0f); - mGlobalEnvClr.a = 0xff; - mGlobalEnvClr.b = 0xff; - mGlobalEnvClr.g = 0xff; - mGlobalEnvClr.r = 0xff; - mGlobalPrmClr.a = 0xff; - mGlobalPrmClr.b = 0xff; - mGlobalPrmClr.g = 0xff; - mGlobalPrmClr.r = 0xff; + mGlobalPrmClr.r = mGlobalPrmClr.g = mGlobalPrmClr.b = mGlobalPrmClr.a = mGlobalEnvClr.r = mGlobalEnvClr.g = mGlobalEnvClr.b = mGlobalEnvClr.a = 0xff; param_1->getBsp()->getPrmClr(&mPrmClr); param_1->getBsp()->getEnvClr(&mEnvClr); mpUserWork = NULL; @@ -61,9 +54,11 @@ JPABaseParticle* JPABaseEmitter::createParticle() { if (mpPtclPool->getNum() != 0) { JPANode<JPABaseParticle>* node = mpPtclPool->pop_front(); mAlivePtclBase.push_front(node); - mpRes->getDyn()->calc(mpEmtrMgr->pWd); - node->mData.init_p(mpEmtrMgr->pWd); - return &node->mData; + pRes->getDyn()->calc(mpEmtrMgr->pWd); + node->getObject()->init_p(mpEmtrMgr->pWd); + return node->getObject(); + } else { + JUT_WARN(128, "%s", "JPA : Can NOT create particle more\n"); } return NULL; @@ -73,8 +68,10 @@ JPABaseParticle* JPABaseEmitter::createChild(JPABaseParticle* parent) { if (mpPtclPool->getNum() != 0) { JPANode<JPABaseParticle>* node = mpPtclPool->pop_front(); mAlivePtclChld.push_front(node); - node->mData.init_c(mpEmtrMgr->pWd, parent); - return &node->mData; + node->getObject()->init_c(mpEmtrMgr->pWd, parent); + return node->getObject(); + } else { + JUT_WARN(151, "%s", "JPA : Can NOT create child particle more\n") } return NULL; @@ -88,14 +85,12 @@ void JPABaseEmitter::deleteAllParticle() { } bool JPABaseEmitter::processTillStartFrame() { - JPADynamicsBlock* dyn = mpRes->getDyn(); - s16 startFrame = dyn->getStartFrame(); - - if (mWaitTime >= startFrame) + if (mWaitTime >= pRes->getDyn()->getStartFrame()) return true; - if (!(mStatus & 2)) + if (!checkStatus(2)) { mWaitTime++; + } return false; } @@ -111,7 +106,7 @@ bool JPABaseEmitter::processTermination() { if (mMaxFrame < 0) { setStatus(8); return getParticleNumber() == 0; - } + } if (mTick >= mMaxFrame) { setStatus(8); if (checkStatus(0x40)) { @@ -129,7 +124,7 @@ void JPABaseEmitter::calcEmitterGlobalPosition(JGeometry::TVec3<f32>* dst) const mtx[0][3] = mGlobalTrs.x; mtx[1][3] = mGlobalTrs.y; mtx[2][3] = mGlobalTrs.z; - MTXMultVec(mtx, mLocalTrs, *dst); + MTXMultVec(mtx, &mLocalTrs, dst); } u32 JPABaseEmitter::getCurrentCreateNumber() const { @@ -140,7 +135,8 @@ u8 JPABaseEmitter::getDrawCount() const { return mpEmtrMgr->pWd->mDrawCount; } -bool JPABaseEmitter::loadTexture(u8 idx, GXTexMapID texMapID) { - mpEmtrMgr->pWd->mpResMgr->load(mpRes->getTexIdx(idx), texMapID); +bool JPABaseEmitter::loadTexture(u8 no, GXTexMapID texMapID) { + JUT_ASSERT(286, pRes->texNum > no); + mpEmtrMgr->pWd->mpResMgr->load(pRes->getTexIdx(no), texMapID); return true; } diff --git a/src/JSystem/JParticle/JPAEmitterManager.cpp b/src/JSystem/JParticle/JPAEmitterManager.cpp index 40f8411134..5af5785055 100644 --- a/src/JSystem/JParticle/JPAEmitterManager.cpp +++ b/src/JSystem/JParticle/JPAEmitterManager.cpp @@ -79,7 +79,7 @@ void JPAEmitterManager::calc(u8 group_id) { JPABaseEmitter* emtr = pLink->getObject(); - if (emtr->mpRes->calc(pWd, emtr) && !emtr->checkStatus(0x200)) + if (emtr->pRes->calc(pWd, emtr) && !emtr->checkStatus(0x200)) forceDeleteEmitter(emtr); } } @@ -115,7 +115,7 @@ void JPAEmitterManager::draw(JPADrawInfo const* drawInfo, u8 group_id) { JPABaseEmitter* emtr = pLink->getObject(); if (!emtr->checkStatus(0x04)) { pWd->mpResMgr = pResMgrAry[emtr->mResMgrID]; - emtr->mpRes->draw(pWd, emtr); + emtr->pRes->draw(pWd, emtr); } } } diff --git a/src/JSystem/JParticle/JPAExTexShape.cpp b/src/JSystem/JParticle/JPAExTexShape.cpp index 81e14ef556..0cf01703b9 100644 --- a/src/JSystem/JParticle/JPAExTexShape.cpp +++ b/src/JSystem/JParticle/JPAExTexShape.cpp @@ -10,18 +10,14 @@ void JPALoadExTex(JPAEmitterWorkData* work) { GXTexCoordID secTexCoordID = GX_TEXCOORD1; if (ets->isUseIndirect()) { - GXSetTexCoordGen2(GX_TEXCOORD1, GX_TG_MTX2x4, GX_TG_TEX0, GX_IDENTITY, GX_FALSE, - GX_PTIDENTITY); - u8 texIdx = ets->getIndTexIdx(); - work->mpResMgr->load(work->mpRes->getTexIdx(texIdx), GX_TEXMAP2); + GXSetTexCoordGen(secTexCoordID, GX_TG_MTX2x4, GX_TG_TEX0, GX_IDENTITY); + work->mpResMgr->load(work->mpRes->getTexIdx(ets->getIndTexIdx()), GX_TEXMAP2); secTexCoordID = GX_TEXCOORD2; } if (ets->isUseSecTex()) { - GXSetTexCoordGen2(secTexCoordID, GX_TG_MTX2x4, GX_TG_TEX0, GX_IDENTITY, GX_FALSE, - GX_PTIDENTITY); - u8 texIdx = ets->getSecTexIdx(); - work->mpResMgr->load(work->mpRes->getTexIdx(texIdx), GX_TEXMAP3); + GXSetTexCoordGen(secTexCoordID, GX_TG_MTX2x4, GX_TG_TEX0, GX_IDENTITY); + work->mpResMgr->load(work->mpRes->getTexIdx(ets->getSecTexIdx()), GX_TEXMAP3); } } diff --git a/src/JSystem/JParticle/JPAExtraShape.cpp b/src/JSystem/JParticle/JPAExtraShape.cpp index 09c6b45bb0..43244dbce6 100644 --- a/src/JSystem/JParticle/JPAExtraShape.cpp +++ b/src/JSystem/JParticle/JPAExtraShape.cpp @@ -35,7 +35,6 @@ void JPACalcScaleY(JPAEmitterWorkData* work, JPABaseParticle* ptcl) { } void JPACalcScaleCopy(JPAEmitterWorkData* work, JPABaseParticle* ptcl) { - JPAExtraShape* esp = work->mpRes->getEsp(); ptcl->mParticleScaleY = ptcl->mParticleScaleX; } @@ -55,21 +54,21 @@ void JPACalcScaleAnmRepeatY(JPAEmitterWorkData* work, JPABaseParticle* ptcl) { void JPACalcScaleAnmReverseX(JPAEmitterWorkData* work, JPABaseParticle* ptcl) { JPAExtraShape* esp = work->mpRes->getEsp(); - s32 cycle = ptcl->mAge / esp->getScaleAnmCycleX(); + f32 cycle = ptcl->mAge / esp->getScaleAnmCycleX() & 1; f32 base = (ptcl->mAge % esp->getScaleAnmCycleX()) / (f32)esp->getScaleAnmCycleX(); - work->mScaleAnm = base + ((cycle & 1) * (1.0f - base * 2.0f)); + work->mScaleAnm = base + cycle * (1.0f - base * 2.0f); } void JPACalcScaleAnmReverseY(JPAEmitterWorkData* work, JPABaseParticle* ptcl) { JPAExtraShape* esp = work->mpRes->getEsp(); - s32 cycle = ptcl->mAge / esp->getScaleAnmCycleY(); + f32 cycle = ptcl->mAge / esp->getScaleAnmCycleY() & 1; f32 base = (ptcl->mAge % esp->getScaleAnmCycleY()) / (f32)esp->getScaleAnmCycleY(); - work->mScaleAnm = base + ((cycle & 1) * (1.0f - base * 2.0f)); + work->mScaleAnm = base + cycle * (1.0f - base * 2.0f); } void JPACalcAlphaAnm(JPAEmitterWorkData* work, JPABaseParticle* ptcl) { JPAExtraShape* esp = work->mpRes->getEsp(); - f32 alpha; + f32 alpha = 0.0f; if (ptcl->mTime < esp->getAlphaInTiming()) { alpha = 255.0f * (esp->getAlphaInValue() + esp->getAlphaIncRate() * ptcl->mTime); } else if (ptcl->mTime > esp->getAlphaOutTiming()) { @@ -83,7 +82,7 @@ void JPACalcAlphaAnm(JPAEmitterWorkData* work, JPABaseParticle* ptcl) { void JPACalcAlphaFlickAnm(JPAEmitterWorkData* work, JPABaseParticle* ptcl) { JPAExtraShape* esp = work->mpRes->getEsp(); - f32 alpha; + f32 alpha = 0.0f; if (ptcl->mTime < esp->getAlphaInTiming()) { alpha = (esp->getAlphaInValue() + esp->getAlphaIncRate() * ptcl->mTime); } else if (ptcl->mTime > esp->getAlphaOutTiming()) { @@ -92,8 +91,7 @@ void JPACalcAlphaFlickAnm(JPAEmitterWorkData* work, JPABaseParticle* ptcl) { } else { alpha = esp->getAlphaBaseValue(); } - s32 theta = ptcl->mAlphaWaveRandom * ptcl->mAge * 16384.0f * (1.0f - esp->getAlphaFreq()); - f32 wave = JMASSin(theta); + f32 wave = JMASSin(ptcl->mAlphaWaveRandom * ptcl->mAge * 16384.0f * (1.0f - esp->getAlphaFreq())); alpha *= (1.0f + esp->getAlphaAmp() * (wave - 1.0f) * 0.5f) * 255.0f; OSf32tou8(&alpha, &ptcl->mPrmColorAlphaAnm); } diff --git a/src/JSystem/JParticle/JPAFieldBlock.cpp b/src/JSystem/JParticle/JPAFieldBlock.cpp index 34397601e5..87f89bc32f 100644 --- a/src/JSystem/JParticle/JPAFieldBlock.cpp +++ b/src/JSystem/JParticle/JPAFieldBlock.cpp @@ -57,7 +57,7 @@ void JPAFieldAir::prepare(JPAEmitterWorkData* work, JPAFieldBlock* block) { if (block->checkStatus(2)) { mAccel.scale(block->getMag(), vec); } else { - MTXMultVecSR(work->mRotationMtx, vec, mAccel); + MTXMultVecSR(work->mRotationMtx, &vec, &mAccel); mAccel.scale(block->getMag()); } } @@ -129,7 +129,7 @@ void JPAFieldConvection::prepare(JPAEmitterWorkData* work, JPAFieldBlock* block) vec2.cross(block->getPos(), block->getDir()); vec1.cross(block->getDir(), vec2); MTXMultVecSR(work->mGlobalRot, &vec1, &field_0x10); - MTXMultVecSR(work->mGlobalRot, &block->getDir(), field_0x1c); + MTXMultVecSR(work->mGlobalRot, &block->getDir(), &field_0x1c); MTXMultVecSR(work->mGlobalRot, &vec2, &field_0x28); field_0x10.normalize(); field_0x1c.normalize(); @@ -224,34 +224,36 @@ void JPAFieldBlock::init(JKRHeap* heap) { switch (getType()) { case FIELD_GRAVITY: - mpField = new (heap, 0) JPAFieldGravity(); + pFld = new (heap, 0) JPAFieldGravity(); break; case FIELD_AIR: - mpField = new (heap, 0) JPAFieldAir(); + pFld = new (heap, 0) JPAFieldAir(); break; case FIELD_MAGNET: - mpField = new (heap, 0) JPAFieldMagnet(); + pFld = new (heap, 0) JPAFieldMagnet(); break; case FIELD_NEWTON: - mpField = new (heap, 0) JPAFieldNewton(); + pFld = new (heap, 0) JPAFieldNewton(); break; case FIELD_VORTEX: - mpField = new (heap, 0) JPAFieldVortex(); + pFld = new (heap, 0) JPAFieldVortex(); break; case FIELD_RANDOM: - mpField = new (heap, 0) JPAFieldRandom(); + pFld = new (heap, 0) JPAFieldRandom(); break; case FIELD_DRAG: - mpField = new (heap, 0) JPAFieldDrag(); + pFld = new (heap, 0) JPAFieldDrag(); break; case FIELD_CONVECTION: - mpField = new (heap, 0) JPAFieldConvection(); + pFld = new (heap, 0) JPAFieldConvection(); break; case FIELD_SPIN: - mpField = new (heap, 0) JPAFieldSpin(); + pFld = new (heap, 0) JPAFieldSpin(); break; default: - mpField = NULL; + pFld = NULL; + JUT_WARN(483, "JPA : WRONG ID (%d) in field data\n", getType()); break; } + JUT_ASSERT(485, pFld != 0); } diff --git a/src/JSystem/JParticle/JPAKeyBlock.cpp b/src/JSystem/JParticle/JPAKeyBlock.cpp index c574618eee..82b7d81d56 100644 --- a/src/JSystem/JParticle/JPAKeyBlock.cpp +++ b/src/JSystem/JParticle/JPAKeyBlock.cpp @@ -10,11 +10,11 @@ JPAKeyBlock::JPAKeyBlock(const u8* data) } f32 JPAKeyBlock::calc(float p1) { - if (mDataStart[0xB] != '\0') { - int v1 = (int)field_0x4[(mDataStart[9] - 1) * 4] + 1; + if (isLoop()) { + int v1 = (int)getKeyData()[(getKeyNum() - 1) * 4] + 1; // p1 -= (v1 * ((int)p1 / v1)); int v2 = ((int)p1 / v1); p1 = p1 - (v2 * v1); } - return JPACalcKeyAnmValue(p1, mDataStart[9], field_0x4); + return JPACalcKeyAnmValue(p1, getKeyNum(), getKeyData()); } diff --git a/src/JSystem/JParticle/JPAMath.cpp b/src/JSystem/JParticle/JPAMath.cpp index aa3807a4fe..cd559572b5 100644 --- a/src/JSystem/JParticle/JPAMath.cpp +++ b/src/JSystem/JParticle/JPAMath.cpp @@ -50,10 +50,7 @@ void JPAGetYZRotateMtx(s16 angleY, s16 angleZ, f32 (*param_2)[4]) { param_2[1][2] = (siny * sinz); param_2[2][0] = -siny; param_2[2][2] = cosy; - param_2[2][3] = 0.0f; - param_2[2][1] = 0.0f; - param_2[1][3] = 0.0f; - param_2[0][3] = 0.0f; + param_2[0][3] = param_2[1][3] = param_2[2][1] = param_2[2][3] = 0.0f; } void JPAGetXYZRotateMtx(s16 x, s16 y, s16 z, Mtx mtx) { @@ -68,17 +65,15 @@ void JPAGetXYZRotateMtx(s16 x, s16 y, s16 z, Mtx mtx) { mtx[2][0] = -siny; mtx[2][1] = sinx * cosy; mtx[2][2] = cosx * cosy; - f32 cosxsinz = cosx * sinz; - f32 sinxcosz = sinx * cosz; - mtx[0][1] = sinxcosz * siny - cosxsinz; - mtx[1][2] = cosxsinz * siny - sinxcosz; - f32 sinxsinz = sinx * sinz; - f32 cosxcosz = cosx * cosz; - mtx[0][2] = sinxsinz + cosxcosz * siny; - mtx[1][1] = cosxcosz + sinxsinz * siny; - mtx[2][3] = 0.0f; - mtx[1][3] = 0.0f; - mtx[0][3] = 0.0f; + f32 f30 = cosx * sinz; + f32 f29 = sinx * cosz; + mtx[0][1] = f29 * siny - f30; + mtx[1][2] = f30 * siny - f29; + f30 = sinx * sinz; + f29 = cosx * cosz; + mtx[0][2] = f30 + f29 * siny; + mtx[1][1] = f29 + f30 * siny; + mtx[0][3] = mtx[1][3] = mtx[2][3] = 0.0f; } void JPASetRMtxTVecfromMtx(f32 const (*param_0)[4], f32 (*param_1)[4], @@ -89,8 +84,7 @@ void JPASetRMtxTVecfromMtx(f32 const (*param_0)[4], f32 (*param_1)[4], void JPASetRMtxSTVecfromMtx(f32 const (*param_0)[4], f32 (*param_1)[4], JGeometry::TVec3<f32>* param_2, JGeometry::TVec3<f32>* param_3) { - JGeometry::TVec3<float> aTStack_54; - aTStack_54.set(param_0[0][0], param_0[1][0], param_0[2][0]); + JGeometry::TVec3<float> aTStack_54(param_0[0][0], param_0[1][0], param_0[2][0]); param_2->x = aTStack_54.length(); aTStack_54.set(param_0[0][1], param_0[1][1], param_0[2][1]); param_2->y = aTStack_54.length(); diff --git a/src/JSystem/JParticle/JPAResource.cpp b/src/JSystem/JParticle/JPAResource.cpp index b3351be574..efba3f323f 100644 --- a/src/JSystem/JParticle/JPAResource.cpp +++ b/src/JSystem/JParticle/JPAResource.cpp @@ -15,32 +15,17 @@ #include "global.h" JPAResource::JPAResource() { - mpDrawEmitterChildFuncList = NULL; - mpDrawEmitterFuncList = NULL; - mpCalcEmitterFuncList = NULL; - mpDrawParticleChildFuncList = NULL; - mpCalcParticleChildFuncList = NULL; - mpDrawParticleFuncList = NULL; - mpCalcParticleFuncList = NULL; - mpBaseShape = NULL; - mpExtraShape = NULL; - mpChildShape = NULL; - mpExTexShape = NULL; - mpDynamicsBlock = NULL; - mpFieldBlocks = NULL; - mpKeyBlocks = NULL; + mpCalcEmitterFuncList = mpDrawEmitterFuncList = mpDrawEmitterChildFuncList = NULL; + mpCalcParticleFuncList = mpDrawParticleFuncList = mpCalcParticleChildFuncList = mpDrawParticleChildFuncList = NULL; + pBsp = NULL; + pEsp = NULL; + pCsp = NULL; + pEts = NULL; + pDyn = NULL; + ppFld = NULL; + ppKey = NULL; mpTDB1 = NULL; - mpDrawParticleChildFuncListNum = 0; - mpCalcParticleChildFuncListNum = 0; - mpDrawParticleFuncListNum = 0; - mpCalcParticleFuncListNum = 0; - mpDrawEmitterChildFuncListNum = 0; - mpDrawEmitterFuncListNum = 0; - mpCalcEmitterFuncListNum = 0; - mTDB1Num = 0; - mKeyBlockNum = 0; - mFieldBlockNum = 0; - mUsrIdx = 0; + mUsrIdx = fldNum = keyNum = texNum = mpCalcEmitterFuncListNum = mpDrawEmitterFuncListNum = mpDrawEmitterChildFuncListNum = mpCalcParticleFuncListNum = mpDrawParticleFuncListNum = mpCalcParticleChildFuncListNum = mpDrawParticleChildFuncListNum = 0; } static u8 jpa_pos[324] ATTRIBUTE_ALIGN(32) = { @@ -73,30 +58,31 @@ static u8 jpa_crd[32] ATTRIBUTE_ALIGN(32) = { }; void JPAResource::init(JKRHeap* heap) { - BOOL is_glbl_clr_anm = mpBaseShape->isGlblClrAnm(); - BOOL is_glbl_tex_anm = mpBaseShape->isGlblTexAnm(); - BOOL is_prm_anm = mpBaseShape->isPrmAnm(); - BOOL is_env_anm = mpBaseShape->isEnvAnm(); - BOOL is_tex_anm = mpBaseShape->isTexAnm(); - BOOL is_tex_crd_anm = mpBaseShape->isTexCrdAnm(); - BOOL is_prj_tex = mpBaseShape->isPrjTex(); - BOOL is_enable_scale_anm = mpExtraShape != NULL && mpExtraShape->isEnableScaleAnm(); - BOOL is_enable_alpha_anm = mpExtraShape != NULL && mpExtraShape->isEnableAlphaAnm(); - BOOL is_enable_alpha_flick = mpExtraShape != NULL && mpExtraShape->isEnableAlphaAnm() - && mpExtraShape->isEnableAlphaFlick(); - BOOL is_enable_rotate_anm = mpExtraShape != NULL && mpExtraShape->isEnableRotateAnm(); + 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 != NULL && pEsp->isEnableScaleAnm(); + BOOL is_enable_alpha_anm = pEsp != NULL && pEsp->isEnableAlphaAnm(); + BOOL is_enable_alpha_flick = pEsp != NULL && pEsp->isEnableAlphaAnm() + && pEsp->isEnableAlphaFlick(); + BOOL is_enable_rotate_anm = pEsp != NULL && pEsp->isEnableRotateAnm(); BOOL is_rotate_on = is_enable_rotate_anm - || (mpChildShape != NULL && mpChildShape->isRotateOn()); - BOOL base_type_5_6 = mpBaseShape->getType() == 5 || mpBaseShape->getType() == 6; - BOOL base_type_0 = mpBaseShape->getType() == 0; - BOOL base_type_0_1 = mpBaseShape->getType() == 0 || mpBaseShape->getType() == 1; - BOOL child_type_5_6 = mpChildShape != NULL - && (mpChildShape->getType() == 5 || mpChildShape->getType() == 6); - BOOL child_type_0 = mpChildShape != NULL && mpChildShape->getType() == 0; - BOOL child_type_0_1 = mpChildShape != NULL - && (mpChildShape->getType() == 0 || mpChildShape->getType() == 1); - BOOL is_draw_parent = !mpBaseShape->isNoDrawParent(); - BOOL is_draw_child = !mpBaseShape->isNoDrawChild(); + || (pCsp != NULL && 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 != NULL + && (pCsp->getType() == 5 || pCsp->getType() == 6); + BOOL child_type_0 = pCsp != NULL && pCsp->getType() == 0; + BOOL child_type_0_1 = pCsp != NULL + && (pCsp->getType() == 0 || pCsp->getType() == 1); + BOOL is_draw_parent = !pBsp->isNoDrawParent(); + BOOL is_draw_child = !pBsp->isNoDrawChild(); + int func_no = 0; if (is_glbl_tex_anm && is_tex_anm) { mpCalcEmitterFuncListNum++; @@ -119,10 +105,10 @@ void JPAResource::init(JKRHeap* heap) { (EmitterFunc*)JKRAllocFromHeap(heap, mpCalcEmitterFuncListNum * 4, 4); } - int func_no = 0; + func_no = 0; if (is_glbl_tex_anm && is_tex_anm) { - switch (mpBaseShape->getTexAnmType()) { + switch (pBsp->getTexAnmType()) { case 0: mpCalcEmitterFuncList[func_no] = &JPACalcTexIdxNormal; break; @@ -152,7 +138,7 @@ void JPAResource::init(JKRHeap* heap) { func_no++; } if (is_prm_anm || is_env_anm) { - switch (mpBaseShape->getClrAnmType()) { + switch (pBsp->getClrAnmType()) { case 0: mpCalcEmitterFuncList[func_no] = &JPACalcClrIdxNormal; break; @@ -169,6 +155,7 @@ void JPAResource::init(JKRHeap* heap) { mpCalcEmitterFuncList[func_no] = &JPACalcClrIdxRandom; break; } + func_no++; } } @@ -195,9 +182,9 @@ void JPAResource::init(JKRHeap* heap) { } if (is_enable_scale_anm) { - if (mpBaseShape->getType() != 0) { - if (mpExtraShape->isScaleXYDiff()) { - if (mpExtraShape->getScaleAnmTypeX() == 0 && mpExtraShape->getScaleAnmTypeY() == 0) { + if (pBsp->getType() != 0) { + if (pEsp->isScaleXYDiff()) { + if (pEsp->getScaleAnmTypeX() == 0 && pEsp->getScaleAnmTypeY() == 0) { mpCalcParticleFuncListNum++; } else { mpCalcParticleFuncListNum++; @@ -219,7 +206,7 @@ void JPAResource::init(JKRHeap* heap) { func_no = 0; if (!is_glbl_tex_anm && is_tex_anm) { - switch (mpBaseShape->getTexAnmType()) { + switch (pBsp->getTexAnmType()) { case 0: mpCalcParticleFuncList[func_no] = &JPACalcTexIdxNormal; break; @@ -259,7 +246,7 @@ void JPAResource::init(JKRHeap* heap) { func_no++; } if (is_prm_anm || is_env_anm) { - switch (mpBaseShape->getClrAnmType()) { + switch (pBsp->getClrAnmType()) { case 0: mpCalcParticleFuncList[func_no] = &JPACalcClrIdxNormal; break; @@ -284,12 +271,12 @@ void JPAResource::init(JKRHeap* heap) { } if (is_enable_scale_anm) { - if (mpBaseShape->getType() != 0) { - if (mpExtraShape->isScaleXYDiff()) { + if (pBsp->getType() != 0) { + if (pEsp->isScaleXYDiff()) { mpCalcParticleFuncList[func_no] = &JPACalcScaleY; func_no++; - if (mpExtraShape->getScaleAnmTypeY() != 0 || mpExtraShape->getScaleAnmTypeX() != 0) { - switch (mpExtraShape->getScaleAnmTypeY()) { + if (pEsp->getScaleAnmTypeY() != 0 || pEsp->getScaleAnmTypeX() != 0) { + switch (pEsp->getScaleAnmTypeY()) { case 0: mpCalcParticleFuncList[func_no] = &JPACalcScaleAnmNormal; break; @@ -309,7 +296,7 @@ void JPAResource::init(JKRHeap* heap) { } mpCalcParticleFuncList[func_no] = &JPACalcScaleX; func_no++; - switch (mpExtraShape->getScaleAnmTypeX()) { + switch (pEsp->getScaleAnmTypeX()) { case 0: mpCalcParticleFuncList[func_no] = &JPACalcScaleAnmNormal; break; @@ -320,13 +307,14 @@ void JPAResource::init(JKRHeap* heap) { mpCalcParticleFuncList[func_no] = &JPACalcScaleAnmReverseX; break; } + func_no++; } - if (mpChildShape != NULL && mpChildShape->isScaleOutOn()) { + if (pCsp != NULL && pCsp->isScaleOutOn()) { mpCalcParticleChildFuncListNum++; } - if (mpChildShape != NULL && mpChildShape->isAlphaOutOn()) { + if (pCsp != NULL && pCsp->isAlphaOutOn()) { mpCalcParticleChildFuncListNum++; } @@ -337,13 +325,14 @@ void JPAResource::init(JKRHeap* heap) { func_no = 0; - if (mpChildShape != NULL && mpChildShape->isScaleOutOn()) { + if (pCsp != NULL && pCsp->isScaleOutOn()) { mpCalcParticleChildFuncList[func_no] = &JPACalcChildScaleOut; func_no++; } - if (mpChildShape != NULL && mpChildShape->isAlphaOutOn()) { + if (pCsp != NULL && pCsp->isAlphaOutOn()) { mpCalcParticleChildFuncList[func_no] = &JPACalcChildAlphaOut; + func_no++; } if (is_draw_parent && base_type_5_6) { @@ -352,7 +341,7 @@ void JPAResource::init(JKRHeap* heap) { mpDrawEmitterFuncListNum++; - if (mpExTexShape != NULL) { + if (pEts != NULL) { mpDrawEmitterFuncListNum++; } @@ -382,7 +371,7 @@ void JPAResource::init(JKRHeap* heap) { func_no = 0; if (is_draw_parent && base_type_5_6) { - if (mpBaseShape->getType() == 5) { + if (pBsp->getType() == 5) { mpDrawEmitterFuncList[func_no] = &JPADrawStripe; func_no++; } else { @@ -394,7 +383,7 @@ void JPAResource::init(JKRHeap* heap) { mpDrawEmitterFuncList[func_no] = &JPADrawEmitterCallBackB; func_no++; - if (mpExTexShape != NULL) { + if (pEts != NULL) { mpDrawEmitterFuncList[func_no] = &JPALoadExTex; func_no++; } @@ -444,17 +433,22 @@ void JPAResource::init(JKRHeap* heap) { if (is_glbl_clr_anm) { if (base_type_5_6 || !is_enable_alpha_anm) { mpDrawEmitterFuncList[func_no] = &JPARegistPrmEnv; + func_no++; } else if (is_enable_alpha_anm) { mpDrawEmitterFuncList[func_no] = &JPARegistEnv; + func_no++; } } else if (!is_prm_anm && !is_enable_alpha_anm) { if (!is_env_anm) { mpDrawEmitterFuncList[func_no] = &JPARegistPrmEnv; + func_no++; } else { mpDrawEmitterFuncList[func_no] = &JPARegistPrm; + func_no++; } } else if (!is_env_anm) { mpDrawEmitterFuncList[func_no] = &JPARegistEnv; + func_no++; } if (is_draw_child && child_type_5_6) { @@ -467,8 +461,8 @@ void JPAResource::init(JKRHeap* heap) { mpDrawEmitterChildFuncListNum++; } - if (mpChildShape != NULL && !mpChildShape->isAlphaOutOn() && !mpChildShape->isAlphaInherited() - && !mpChildShape->isColorInherited()) { + if (pCsp != NULL && !pCsp->isAlphaOutOn() && !pCsp->isAlphaInherited() + && !pCsp->isColorInherited()) { mpDrawEmitterChildFuncListNum++; } @@ -480,7 +474,7 @@ void JPAResource::init(JKRHeap* heap) { func_no = 0; if (is_draw_child && child_type_5_6) { - if (mpChildShape->getType() == 5) { + if (pCsp->getType() == 5) { mpDrawEmitterChildFuncList[func_no] = &JPADrawStripe; func_no++; } else { @@ -497,9 +491,10 @@ void JPAResource::init(JKRHeap* heap) { func_no++; } - if (mpChildShape != NULL && !mpChildShape->isAlphaOutOn() && !mpChildShape->isAlphaInherited() - && !mpChildShape->isColorInherited()) { + if (pCsp != NULL && !pCsp->isAlphaOutOn() && !pCsp->isAlphaInherited() + && !pCsp->isColorInherited()) { mpDrawEmitterChildFuncList[func_no] = &JPARegistChildPrmEnv; + func_no++; } if (is_draw_parent && !base_type_5_6) { @@ -529,7 +524,7 @@ void JPAResource::init(JKRHeap* heap) { func_no = 0; if (is_draw_parent && !base_type_5_6) { - switch (mpBaseShape->getType()) { + switch (pBsp->getType()) { case 2: if (is_enable_rotate_anm) { mpDrawParticleFuncList[func_no] = &JPADrawRotBillboard; @@ -594,23 +589,29 @@ void JPAResource::init(JKRHeap* heap) { if (is_prm_anm) { if (is_env_anm) { mpDrawParticleFuncList[func_no] = &JPARegistPrmAlphaEnv; + func_no++; } else { mpDrawParticleFuncList[func_no] = &JPARegistPrmAlpha; + func_no++; } } else if (is_enable_alpha_anm) { if (is_env_anm) { mpDrawParticleFuncList[func_no] = &JPARegistAlphaEnv; + func_no++; } else { mpDrawParticleFuncList[func_no] = &JPARegistAlpha; + func_no++; } } else if (is_env_anm) { mpDrawParticleFuncList[func_no] = &JPARegistEnv; + func_no++; } } else if (is_enable_alpha_anm && !base_type_5_6) { mpDrawParticleFuncList[func_no] = &JPARegistAlpha; + func_no++; } - if (is_draw_child && mpChildShape != NULL && !child_type_5_6) { + if (is_draw_child && pCsp != NULL && !child_type_5_6) { mpDrawParticleChildFuncListNum++; } @@ -620,8 +621,8 @@ void JPAResource::init(JKRHeap* heap) { mpDrawParticleChildFuncListNum++; } - if (mpChildShape != NULL && (mpChildShape->isAlphaOutOn() || mpChildShape->isAlphaInherited() - || mpChildShape->isColorInherited())) { + if (pCsp != NULL && (pCsp->isAlphaOutOn() || pCsp->isAlphaInherited() + || pCsp->isColorInherited())) { mpDrawParticleChildFuncListNum++; } @@ -632,8 +633,8 @@ void JPAResource::init(JKRHeap* heap) { func_no = 0; - if (is_draw_child && mpChildShape != NULL && !child_type_5_6) { - switch (mpChildShape->getType()) { + if (is_draw_child && pCsp != NULL && !child_type_5_6) { + switch (pCsp->getType()) { case 2: if (is_rotate_on) { mpDrawParticleChildFuncList[func_no] = &JPADrawRotBillboard; @@ -686,9 +687,10 @@ void JPAResource::init(JKRHeap* heap) { } } - if (mpChildShape != NULL && (mpChildShape->isAlphaOutOn() || mpChildShape->isAlphaInherited() - || mpChildShape->isColorInherited())) { + if (pCsp != NULL && (pCsp->isAlphaOutOn() || pCsp->isAlphaInherited() + || pCsp->isColorInherited())) { mpDrawParticleChildFuncList[func_no] = &JPARegistPrmAlphaEnv; + func_no++; } } @@ -720,8 +722,8 @@ bool JPAResource::calc(JPAEmitterWorkData* work, JPABaseEmitter* emtr) { } else { calcKey(work); - for (int i = mFieldBlockNum - 1; i >= 0; i--) { - mpFieldBlocks[i]->initOpParam(); + for (int i = fldNum - 1; i >= 0; i--) { + ppFld[i]->initOpParam(); } if (emtr->mpEmtrCallBack != NULL) { @@ -737,12 +739,12 @@ bool JPAResource::calc(JPAEmitterWorkData* work, JPABaseEmitter* emtr) { (*mpCalcEmitterFuncList[i])(work); } - for (int i = mFieldBlockNum - 1; i >= 0; i--) { - mpFieldBlocks[i]->prepare(work); + for (int i = fldNum - 1; i >= 0; i--) { + ppFld[i]->prepare(work); } if (!emtr->checkStatus(8)) { - mpDynamicsBlock->create(work); + pDyn->create(work); } if (emtr->mpEmtrCallBack != NULL) { @@ -752,23 +754,19 @@ bool JPAResource::calc(JPAEmitterWorkData* work, JPABaseEmitter* emtr) { } } - JPANode<JPABaseParticle>* node = emtr->mAlivePtclBase.getFirst(); - JPANode<JPABaseParticle>* next; - while (node != emtr->mAlivePtclBase.getEnd()) { + JPANode<JPABaseParticle>* next = NULL; + for (JPANode<JPABaseParticle>* node = emtr->mAlivePtclBase.getFirst(); node != emtr->mAlivePtclBase.getEnd(); node = next) { next = node->getNext(); if (node->getObject()->calc_p(work)) { emtr->mpPtclPool->push_front(emtr->mAlivePtclBase.erase(node)); } - node = next; } - node = emtr->mAlivePtclChld.getFirst(); - while (node != emtr->mAlivePtclChld.getEnd()) { + for (JPANode<JPABaseParticle>* node = emtr->mAlivePtclChld.getFirst(); node != emtr->mAlivePtclChld.getEnd(); node = next) { next = node->getNext(); if (node->getObject()->calc_c(work)) { emtr->mpPtclPool->push_front(emtr->mAlivePtclChld.erase(node)); } - node = next; } emtr->mTick++; @@ -782,13 +780,13 @@ void JPAResource::draw(JPAEmitterWorkData* work, JPABaseEmitter* emtr) { work->mpRes = this; work->mDrawCount = 0; calcWorkData_d(work); - mpBaseShape->setGX(work); + pBsp->setGX(work); for (s32 i = 1; i <= emtr->getDrawTimes(); i++) { work->mDrawCount++; - if (mpBaseShape->isDrawPrntAhead() && mpChildShape != NULL) + if (pBsp->isDrawPrntAhead() && pCsp != NULL) drawC(work); drawP(work); - if (!mpBaseShape->isDrawPrntAhead() && mpChildShape != NULL) + if (!pBsp->isDrawPrntAhead() && pCsp != NULL) drawC(work); } } @@ -796,28 +794,28 @@ void JPAResource::draw(JPAEmitterWorkData* work, JPABaseEmitter* emtr) { void JPAResource::drawP(JPAEmitterWorkData* work) { work->mpEmtr->clearStatus(0x80); - work->mGlobalPtclScl.x = work->mpEmtr->mGlobalPScl.x * mpBaseShape->getBaseSizeX(); - work->mGlobalPtclScl.y = work->mpEmtr->mGlobalPScl.y * mpBaseShape->getBaseSizeY(); + work->mGlobalPtclScl.x = work->mpEmtr->mGlobalPScl.x * pBsp->getBaseSizeX(); + work->mGlobalPtclScl.y = work->mpEmtr->mGlobalPScl.y * pBsp->getBaseSizeY(); - if (mpBaseShape->getType() == 0) { + if (pBsp->getType() == 0) { work->mGlobalPtclScl.x *= 1.02f; - } else if (mpBaseShape->getType() == 1) { + } else if (pBsp->getType() == 1) { work->mGlobalPtclScl.x *= 1.02f; work->mGlobalPtclScl.y *= 0.4f; } - if (mpExtraShape != NULL && mpExtraShape->isEnableScaleAnm()) { - work->mPivot.x = mpExtraShape->getScaleCenterX() - 1.0f; - work->mPivot.y = mpExtraShape->getScaleCenterY() - 1.0f; + if (pEsp != NULL && pEsp->isEnableScaleAnm()) { + work->mPivot.x = pEsp->getScaleCenterX() - 1.0f; + work->mPivot.y = pEsp->getScaleCenterY() - 1.0f; } else { work->mPivot.x = work->mPivot.y = 0.0f; } - work->mDirType = mpBaseShape->getDirType(); - work->mRotType = mpBaseShape->getRotType(); - work->mDLType = mpBaseShape->getType() == 4 || mpBaseShape->getType() == 8; - work->mPlaneType = work->mDLType ? 2 : mpBaseShape->getBasePlaneType(); - work->mPrjType = mpBaseShape->isPrjTex() ? (mpBaseShape->isTexCrdAnm() ? 2 : 1) : 0; + work->mDirType = pBsp->getDirType(); + work->mRotType = pBsp->getRotType(); + work->mDLType = pBsp->getType() == 4 || pBsp->getType() == 8; + work->mPlaneType = work->mDLType ? 2 : pBsp->getBasePlaneType(); + work->mPrjType = pBsp->isPrjTex() ? (pBsp->isTexCrdAnm() ? 2 : 1) : 0; work->mpAlivePtcl = &work->mpEmtr->mAlivePtclBase; setPTev(); @@ -826,7 +824,7 @@ void JPAResource::drawP(JPAEmitterWorkData* work) { (*mpDrawEmitterFuncList[i])(work); } - if (mpBaseShape->isDrawFwdAhead()) { + if (pBsp->isDrawFwdAhead()) { JPANode<JPABaseParticle>* node = work->mpEmtr->mAlivePtclBase.getLast(); for (; node != work->mpEmtr->mAlivePtclBase.getEnd(); node = node->getPrev()) { work->mpCurNode = node; @@ -858,27 +856,27 @@ void JPAResource::drawP(JPAEmitterWorkData* work) { void JPAResource::drawC(JPAEmitterWorkData* work) { work->mpEmtr->setStatus(0x80); - if (mpChildShape->isScaleInherited()) { - work->mGlobalPtclScl.x = work->mpEmtr->mGlobalPScl.x * mpBaseShape->getBaseSizeX(); - work->mGlobalPtclScl.y = work->mpEmtr->mGlobalPScl.y * mpBaseShape->getBaseSizeY(); + if (pCsp->isScaleInherited()) { + work->mGlobalPtclScl.x = work->mpEmtr->mGlobalPScl.x * pBsp->getBaseSizeX(); + work->mGlobalPtclScl.y = work->mpEmtr->mGlobalPScl.y * pBsp->getBaseSizeY(); } else { - work->mGlobalPtclScl.x = work->mpEmtr->mGlobalPScl.x * mpChildShape->getScaleX(); - work->mGlobalPtclScl.y = work->mpEmtr->mGlobalPScl.y * mpChildShape->getScaleY(); + work->mGlobalPtclScl.x = work->mpEmtr->mGlobalPScl.x * pCsp->getScaleX(); + work->mGlobalPtclScl.y = work->mpEmtr->mGlobalPScl.y * pCsp->getScaleY(); } - if (mpChildShape->getType() == 0) { + if (pCsp->getType() == 0) { work->mGlobalPtclScl.x *= 1.02f; - } else if (mpChildShape->getType() == 1) { + } else if (pCsp->getType() == 1) { work->mGlobalPtclScl.x *= 1.02f; work->mGlobalPtclScl.y *= 0.4f; } work->mPivot.x = work->mPivot.y = 0.0f; - work->mDirType = mpChildShape->getDirType(); - work->mRotType = mpChildShape->getRotType(); - work->mDLType = mpChildShape->getType() == 4 || mpChildShape->getType() == 8; - work->mPlaneType = work->mDLType ? 2 : mpChildShape->getBasePlaneType(); + work->mDirType = pCsp->getDirType(); + work->mRotType = pCsp->getRotType(); + work->mDLType = pCsp->getType() == 4 || pCsp->getType() == 8; + work->mPlaneType = work->mDLType ? 2 : pCsp->getBasePlaneType(); work->mPrjType = 0; work->mpAlivePtcl = &work->mpEmtr->mAlivePtclChld; @@ -888,7 +886,7 @@ void JPAResource::drawC(JPAEmitterWorkData* work) { (*mpDrawEmitterChildFuncList[i])(work); } - if (mpBaseShape->isDrawFwdAhead()) { + if (pBsp->isDrawFwdAhead()) { JPANode<JPABaseParticle>* node = work->mpEmtr->mAlivePtclChld.getLast(); for (; node != work->mpEmtr->mAlivePtclChld.getEnd(); node = node->getPrev()) { work->mpCurNode = node; @@ -923,33 +921,27 @@ void JPAResource::setPTev() { u8 tex_gens = 1; u8 ind_stages = 0; - int base_plane_type = (mpBaseShape->getType() == 3 || mpBaseShape->getType() == 7) ? - mpBaseShape->getBasePlaneType() : 0; - int center_offset; - if (mpExtraShape != NULL) { - center_offset = - (mpExtraShape->getScaleCenterX() + 3 * mpExtraShape->getScaleCenterY()) * 0xC; - } else { - center_offset = 0x30; - } + int base_plane_type = (pBsp->getType() == 3 || pBsp->getType() == 7) ? + pBsp->getBasePlaneType() : 0; + int center_offset = pEsp != NULL ? (pEsp->getScaleCenterX() + 3 * pEsp->getScaleCenterY()) * 0xC : 0x30; int pos_offset = center_offset + base_plane_type * 0x6C; - int crd_offset = (mpBaseShape->getTilingS() + 2 * mpBaseShape->getTilingT()) * 8; + 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 (mpExTexShape != NULL) { - if (mpExTexShape->isUseIndirect()) { - GXSetIndTexOrder(GX_INDTEXSTAGE0, GX_TEXCOORD1, GX_TEXMAP2); + if (pEts != NULL) { + if (pEts->isUseIndirect()) { + GXSetIndTexOrder(GX_INDTEXSTAGE0, tex_coord, GX_TEXMAP2); GXSetIndTexCoordScale(GX_INDTEXSTAGE0, GX_ITS_1, GX_ITS_1); - GXSetIndTexMtx(GX_ITM_0, (f32(*)[3])mpExTexShape->getIndTexMtx(), mpExTexShape->getExpScale()); + GXSetIndTexMtx(GX_ITM_0, (f32(*)[3])pEts->getIndTexMtx(), pEts->getExpScale()); GXSetTevIndirect(GX_TEVSTAGE0, GX_INDTEXSTAGE0, GX_ITF_8, GX_ITB_STU, GX_ITM_0, GX_ITW_OFF, GX_ITW_OFF, 0, 0, GX_ITBA_OFF); ind_stages++; tex_gens++; tex_coord = GX_TEXCOORD2; } - if (mpExTexShape->isUseSecTex()) { + if (pEts->isUseSecTex()) { GXSetTevOrder(GX_TEVSTAGE1, tex_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); @@ -964,7 +956,7 @@ void JPAResource::setPTev() { GXSetNumTevStages(tev_stages); GXSetNumIndStages(ind_stages); - if (mpBaseShape->isClipOn()) { + if (pBsp->isClipOn()) { GXSetMisc(GX_MT_XF_FLUSH, 8); GXSetClipMode(GX_CLIP_ENABLE); } else { @@ -974,8 +966,8 @@ void JPAResource::setPTev() { } void JPAResource::setCTev(JPAEmitterWorkData* work) { - int base_plane_type = (mpChildShape->getType() == 3 || mpChildShape->getType() == 7) ? - mpChildShape->getBasePlaneType() : 0; + 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); @@ -984,14 +976,14 @@ void JPAResource::setCTev(JPAEmitterWorkData* work) { GXSetTevDirect(GX_TEVSTAGE0); GXSetNumTevStages(1); GXSetNumIndStages(0); - if (mpChildShape->isClipOn()) { + if (pCsp->isClipOn()) { GXSetMisc(GX_MT_XF_FLUSH, 8); GXSetClipMode(GX_CLIP_ENABLE); } else { GXSetClipMode(GX_CLIP_DISABLE); } GXSetNumTexGens(1); - work->mpResMgr->load(work->mpRes->getTexIdx(mpChildShape->getTexIdx()), GX_TEXMAP1); + work->mpResMgr->load(work->mpRes->getTexIdx(pCsp->getTexIdx()), GX_TEXMAP1); } void JPAResource::calc_p(JPAEmitterWorkData* work, JPABaseParticle* ptcl) { @@ -1011,15 +1003,15 @@ void JPAResource::calc_c(JPAEmitterWorkData* work, JPABaseParticle* ptcl) { } void JPAResource::calcField(JPAEmitterWorkData* work, JPABaseParticle* ptcl) { - for (int i = mFieldBlockNum - 1; i >= 0; i--) { - mpFieldBlocks[i]->calc(work, ptcl); + for (int i = fldNum - 1; i >= 0; i--) { + ppFld[i]->calc(work, ptcl); } } void JPAResource::calcKey(JPAEmitterWorkData* work) { - for (int i = mKeyBlockNum - 1; i >= 0; i--) { - f32 val = mpKeyBlocks[i]->calc(work->mpEmtr->mTick); - switch (mpKeyBlocks[i]->getID()) { + for (int i = keyNum - 1; i >= 0; i--) { + f32 val = ppKey[i]->calc(work->mpEmtr->mTick); + switch (ppKey[i]->getID()) { case 0: work->mpEmtr->mRate = val; break; @@ -1047,6 +1039,9 @@ void JPAResource::calcKey(JPAEmitterWorkData* work) { case 10: work->mpEmtr->mScaleOut = val; break; + default: + JUT_WARN(917, "%s", "JPA : WRONG ID in key data\n"); + break; } } } @@ -1055,10 +1050,9 @@ void JPAResource::calcWorkData_c(JPAEmitterWorkData* work) { work->mVolumeSize = work->mpEmtr->mVolumeSize; work->mVolumeMinRad = work->mpEmtr->mVolumeMinRad; work->mVolumeSweep = work->mpEmtr->mVolumeSweep; - work->mVolumeX = 0; - work->mVolumeAngleNum = 0; + work->mVolumeAngleNum = work->mVolumeX = 0; work->mVolumeAngleMax = 1; - work->mDivNumber = mpDynamicsBlock->getDivNumber() * 2 + 1; + work->mDivNumber = pDyn->getDivNumber() * 2 + 1; Mtx local_scl_mtx, local_rot_mtx, global_mtx; MTXScale(local_scl_mtx, work->mpEmtr->mLocalScl.x, work->mpEmtr->mLocalScl.y, work->mpEmtr->mLocalScl.z); diff --git a/src/JSystem/JParticle/JPAResourceLoader.cpp b/src/JSystem/JParticle/JPAResourceLoader.cpp index e065ee72b3..d0f3c8ebd4 100644 --- a/src/JSystem/JParticle/JPAResourceLoader.cpp +++ b/src/JSystem/JParticle/JPAResourceLoader.cpp @@ -12,12 +12,35 @@ #include "JSystem/JParticle/JPAResource.h" #include "JSystem/JParticle/JPAResourceManager.h" +static void dummy1() { + JUT_WARN(0, "JPA : wrong version file %s\n"); + OS_REPORT("JPA : no jpa file\n"); +} + JPAResourceLoader::JPAResourceLoader(u8 const* data, JPAResourceManager* mgr) { if (*(u32*)(data + 4) == '2-10') { load_jpc(data, mgr); + } else { + JUT_WARN(48, "JPA : wrong version file\n"); } } +static void dummy2() { + OS_REPORT("tex_num && \"a resource have to use one or more texture\""); + OS_REPORT("p_res != 0"); + OS_REPORT("(p_res->ppFld != 0) || (p_res->fldNum == 0)"); + OS_REPORT("(p_res->ppKey != 0) || (p_res->keyNum == 0)"); + OS_REPORT("(p_res->texIdxTbl != 0) || (p_res->texNum == 0)"); + OS_REPORT("p_res->ppFld[fld_no] != 0"); + OS_REPORT("p_res->ppKey[key_no] != 0"); + OS_REPORT("p_res->pDyn != 0"); + OS_REPORT("p_res->pBsp != 0"); + OS_REPORT("p_res->pEsp != 0"); + OS_REPORT("p_res->pCsp != 0"); + OS_REPORT("p_res->pEts != 0"); + OS_REPORT("JPA : wrong type block in jpc file %x\n"); +} + struct JPAResourceHeader { /* 0x0 */ u16 mUsrIdx; /* 0x2 */ u16 mBlockNum; @@ -26,74 +49,89 @@ struct JPAResourceHeader { /* 0x6 */ u8 mTDB1Num; }; -void JPAResourceLoader::load_jpc(u8 const* data, JPAResourceManager* mgr) { - JKRHeap* heap = mgr->mpHeap; - mgr->mResMax = *(u16*)(data + 8); - mgr->mTexMax = *(u16*)(data + 0xA); - mgr->mpResArr = new (heap, 0) JPAResource*[mgr->mResMax]; - mgr->mpTexArr = new (heap, 0) JPATexture*[mgr->mTexMax]; +void JPAResourceLoader::load_jpc(u8 const* data, JPAResourceManager* p_res_mgr) { + JKRHeap* heap = p_res_mgr->mpHeap; + p_res_mgr->resMaxNum = *(u16*)(data + 8); + p_res_mgr->texMaxNum = *(u16*)(data + 0xA); + p_res_mgr->pResAry = new (heap, 0) JPAResource*[p_res_mgr->resMaxNum]; + p_res_mgr->pTexAry = new (heap, 0) JPATexture*[p_res_mgr->texMaxNum]; + JUT_ASSERT(199, (p_res_mgr->pResAry != NULL) && (p_res_mgr->pTexAry != 0)); u32 offset = 0x10; for (int i = 0; i < *(u16*)(data + 8); i++) { JPAResourceHeader* header = (JPAResourceHeader*)(data + offset); - JPAResource* res = new (heap, 0) JPAResource(); - res->mFieldBlockNum = header->mFieldBlockNum; - res->mpFieldBlocks = res->mFieldBlockNum != 0 ? - new (heap, 0) JPAFieldBlock*[res->mFieldBlockNum] : NULL; - res->mKeyBlockNum = header->mKeyBlockNum; - res->mpKeyBlocks = res->mKeyBlockNum != 0 ? - new (heap, 0) JPAKeyBlock*[res->mKeyBlockNum] : NULL; - res->mTDB1Num = header->mTDB1Num; - res->mpTDB1 = NULL; - res->mUsrIdx = header->mUsrIdx; + JPAResource* p_res = new (heap, 0) JPAResource(); + JUT_ASSERT(211, p_res != NULL); + p_res->fldNum = header->mFieldBlockNum; + p_res->ppFld = p_res->fldNum != 0 ? + new (heap, 0) JPAFieldBlock*[p_res->fldNum] : NULL; + JUT_ASSERT(216, (p_res->ppFld != NULL) || (p_res->fldNum == 0)); + p_res->keyNum = header->mKeyBlockNum; + p_res->ppKey = p_res->keyNum != 0 ? + new (heap, 0) JPAKeyBlock*[p_res->keyNum] : NULL; + JUT_ASSERT(221, (p_res->ppKey != NULL) || (p_res->keyNum == 0)); + p_res->texNum = header->mTDB1Num; + p_res->mpTDB1 = NULL; + p_res->mUsrIdx = header->mUsrIdx; offset += 8; - u32 field_idx = 0; - u32 key_idx = 0; + u32 fld_no = 0; + u32 key_no = 0; for (int j = 0; j < header->mBlockNum; j++) { u32 magic = *(u32*)(data + offset); u32 size = *(u32*)(data + offset + 4); switch (magic) { case 'FLD1': - res->mpFieldBlocks[field_idx] = new (heap, 0) JPAFieldBlock(data + offset, heap); - field_idx++; + p_res->ppFld[fld_no] = new (heap, 0) JPAFieldBlock(data + offset, heap); + JUT_ASSERT(244, p_res->ppFld[fld_no] != NULL); + fld_no++; break; case 'KFA1': - res->mpKeyBlocks[key_idx] = new (heap, 0) JPAKeyBlock(data + offset); - key_idx++; + p_res->ppKey[key_no] = new (heap, 0) JPAKeyBlock(data + offset); + JUT_ASSERT(249, p_res->ppKey[key_no] != NULL); + key_no++; break; case 'BEM1': - res->mpDynamicsBlock = new (heap, 0) JPADynamicsBlock(data + offset); + p_res->pDyn = new (heap, 0) JPADynamicsBlock(data + offset); + JUT_ASSERT(254, p_res->pDyn != NULL); break; case 'BSP1': - res->mpBaseShape = new (heap, 0) JPABaseShape(data + offset, heap); + p_res->pBsp = new (heap, 0) JPABaseShape(data + offset, heap); + JUT_ASSERT(258, p_res->pBsp != NULL); break; case 'ESP1': - res->mpExtraShape = new (heap, 0) JPAExtraShape(data + offset); + p_res->pEsp = new (heap, 0) JPAExtraShape(data + offset); + JUT_ASSERT(262, p_res->pEsp != NULL); break; case 'SSP1': - res->mpChildShape = new (heap, 0) JPAChildShape(data + offset); + p_res->pCsp = new (heap, 0) JPAChildShape(data + offset); + JUT_ASSERT(266, p_res->pCsp != NULL); break; case 'ETX1': - res->mpExTexShape = new (heap, 0) JPAExTexShape(data + offset); + p_res->pEts = new (heap, 0) JPAExTexShape(data + offset); + JUT_ASSERT(270, p_res->pEts != NULL); break; case 'TDB1': - res->mpTDB1 = (const u16*)(data + offset + 8); + p_res->mpTDB1 = (const u16*)(data + offset + 8); + break; + default: + JUT_WARN(275, "JPA : wrong type block in jpc file %d %x\n", header->mBlockNum, offset); break; } offset += size; } - res->init(heap); - mgr->registRes(res); + p_res->init(heap); + p_res_mgr->registRes(p_res); } offset = *(u32*)(data + 0xC); for (int i = 0; i < *(u16*)(data + 0xA); i++) { u32 size = *(u32*)(data + offset + 4); - JPATexture* tex = new (heap, 0) JPATexture(data + offset); - mgr->registTex(tex); + JPATexture* p_tex = new (heap, 0) JPATexture(data + offset); + JUT_ASSERT(298, p_tex != NULL); + p_res_mgr->registTex(p_tex); offset += size; } } diff --git a/src/JSystem/JParticle/JPAResourceManager.cpp b/src/JSystem/JParticle/JPAResourceManager.cpp index fba6d81ab7..e382a39110 100644 --- a/src/JSystem/JParticle/JPAResourceManager.cpp +++ b/src/JSystem/JParticle/JPAResourceManager.cpp @@ -9,37 +9,39 @@ struct JPAResourceLoader { JPAResourceLoader(u8 const*, JPAResourceManager*); }; -JPAResourceManager::JPAResourceManager(void const* pData, JKRHeap* pHeap) { - mpResArr = NULL; - mpTexArr = NULL; - mResMax = 0; - mResNum = 0; - mTexMax = 0; - mTexNum = 0; +JPAResourceManager::JPAResourceManager(void const* p_jpc, JKRHeap* pHeap) { + pResAry = NULL; + pTexAry = NULL; + resMaxNum = 0; + resRegNum = 0; + texMaxNum = 0; + texRegNum = 0; mpHeap = pHeap; - JPAResourceLoader loader((u8 const*)pData, this); + JUT_ASSERT(49, (p_jpc != 0) && (pHeap != 0)); + JPAResourceLoader loader((u8 const*)p_jpc, this); } JPAResource* JPAResourceManager::getResource(u16 usrIdx) const { - for (u16 i = 0; i < mResNum; i++) - if (mpResArr[i]->getUsrIdx() == usrIdx) - return mpResArr[i]; + for (u16 i = 0; i < resRegNum; i++) + if (pResAry[i]->getUsrIdx() == usrIdx) + return pResAry[i]; return NULL; } bool JPAResourceManager::checkUserIndexDuplication(u16 usrIdx) const { - for (s32 i = 0; i < mResNum; i++) - if (mpResArr[i]->getUsrIdx() == usrIdx) + for (s32 i = 0; i < resRegNum; i++) + if (pResAry[i]->getUsrIdx() == usrIdx) return true; return false; } const ResTIMG* JPAResourceManager::swapTexture(ResTIMG const* img, char const* swapName) { const ResTIMG* ret = NULL; + JUTTexture* tex = NULL; - for (s32 i = 0; i < mTexNum; i++) { - if (strcmp(swapName, mpTexArr[i]->getName()) == 0) { - JUTTexture* tex = mpTexArr[i]->getJUTTexture(); + for (s32 i = 0; i < texRegNum; i++) { + if (strcmp(swapName, pTexAry[i]->getName()) == 0) { + tex = pTexAry[i]->getJUTTexture(); ret = tex->getTexInfo(); tex->storeTIMG(img, (u8)0); break; @@ -50,13 +52,15 @@ const ResTIMG* JPAResourceManager::swapTexture(ResTIMG const* img, char const* s } void JPAResourceManager::registRes(JPAResource* res) { - mpResArr[mResNum] = res; - mResNum++; + JUT_ASSERT(151, resRegNum < resMaxNum); + pResAry[resRegNum] = res; + resRegNum++; } void JPAResourceManager::registTex(JPATexture* tex) { - mpTexArr[mTexNum] = tex; - mTexNum++; + JUT_ASSERT(166, texRegNum < texMaxNum); + pTexAry[texRegNum] = tex; + texRegNum++; } u32 JPAResourceManager::getResUserWork(u16 usrIdx) const { diff --git a/src/d/d_particle.cpp b/src/d/d_particle.cpp index b0597577b6..9a1b395dec 100644 --- a/src/d/d_particle.cpp +++ b/src/d/d_particle.cpp @@ -1907,7 +1907,7 @@ u16 dPa_control_c::setCommonPoly(u32* param_0, cBgS_PolyInfo* param_1, cXyz cons void dPa_wbPcallBack_c::execute(JPABaseEmitter* i_emitter, JPABaseParticle* param_1) { UNUSED(i_emitter); JGeometry::TVec3<f32> local_18; - param_1->getGlobalPosition(local_18); + param_1->getGlobalPosition(&local_18); cXyz cStack_24(local_18.x, local_18.y, local_18.z); if (fopAcM_wt_c::waterCheck(&cStack_24) && cStack_24.y > fopAcM_wt_c::getWaterY()) { param_1->setInvisibleParticleFlag(); @@ -1992,7 +1992,7 @@ void dPa_light8PcallBack::draw(JPABaseEmitter* param_1, JPABaseParticle* param_2 MTXRotAxisRad(auStack_90, &local_178, (M_PI / 180.0f) * fVar3); MTXConcat(local_60, auStack_90, local_60); } - param_2->getGlobalPosition(local_100); + param_2->getGlobalPosition(&local_100); local_60[0][3] = local_100.x; local_60[1][3] = local_100.y; local_60[2][3] = local_100.z; @@ -2078,7 +2078,7 @@ void dPa_gen_b_light8PcallBack::draw(JPABaseEmitter* param_1, JPABaseParticle* p JGeometry::TVec3<f32> local_e0; JGeometry::TVec3<f32> local_ec; JGeometry::TVec3<f32> local_f8; - param_2->getGlobalPosition(local_8c); + param_2->getGlobalPosition(&local_8c); MTXMultVec(j3dSys.getViewMtx(), &local_8c, &local_8c); f32 dVar9 = JMASSin(param_2->getRotateAngle()); f32 dVar10 = JMASCos(param_2->getRotateAngle()); @@ -2172,7 +2172,7 @@ void dPa_gen_d_light8PcallBack::draw(JPABaseEmitter* param_1, JPABaseParticle* p MTXIdentity(local_60); MTXIdentity(auStack_90); param_2->getBaseAxis(local_10c); - param_2->getLocalPosition(local_118); + param_2->getLocalPosition(&local_118); if (local_118.isZero()) { local_118.set(0.0f, 1.0f, 0.0f); } else { @@ -2201,7 +2201,7 @@ void dPa_gen_d_light8PcallBack::draw(JPABaseEmitter* param_1, JPABaseParticle* p MTXRotAxisRad(auStack_90, &local_178, (M_PI / 180.0f) * fVar3); MTXConcat(local_60, auStack_90, local_60); } - param_2->getGlobalPosition(local_100); + param_2->getGlobalPosition(&local_100); local_60[0][3] = local_100.x; local_60[1][3] = local_100.y; local_60[2][3] = local_100.z; |