From 63abf9f6d2d52ed9d1309473bf4dc1123ca1ce5b Mon Sep 17 00:00:00 2001 From: Caroline Madsen <69010899+randomsalience@users.noreply.github.com> Date: Sun, 3 Nov 2024 13:39:41 -0500 Subject: [PATCH] JParticle mostly done (#2235) --- configure.py | 6 +- include/JSystem/JGeometry.h | 119 +- include/JSystem/JMath/JMath.h | 4 +- include/JSystem/JParticle/JPABaseShape.h | 82 +- include/JSystem/JParticle/JPAChildShape.h | 42 +- include/JSystem/JParticle/JPADynamicsBlock.h | 3 + include/JSystem/JParticle/JPAEmitter.h | 14 +- include/JSystem/JParticle/JPAExTexShape.h | 6 +- include/JSystem/JParticle/JPAExtraShape.h | 31 + include/JSystem/JParticle/JPAFieldBlock.h | 168 ++ include/JSystem/JParticle/JPAKeyBlock.h | 4 +- include/JSystem/JParticle/JPAList.h | 38 +- include/JSystem/JParticle/JPAParticle.h | 20 +- include/JSystem/JParticle/JPARandom.h | 7 +- include/JSystem/JParticle/JPAResource.h | 16 +- include/JSystem/JParticle/JPAResourceLoader.h | 10 + include/dolphin/mtx/vec.h | 4 +- src/JSystem/JParticle/JPABaseShape.cpp | 3 +- src/JSystem/JParticle/JPAChildShape.cpp | 15 +- src/JSystem/JParticle/JPADynamicsBlock.cpp | 153 +- src/JSystem/JParticle/JPAEmitterManager.cpp | 98 +- src/JSystem/JParticle/JPAExtraShape.cpp | 7 +- src/JSystem/JParticle/JPAFieldBlock.cpp | 572 +++--- src/JSystem/JParticle/JPAKeyBlock.cpp | 24 +- src/JSystem/JParticle/JPAParticle.cpp | 379 +++- src/JSystem/JParticle/JPAResource.cpp | 1599 +++++++++++------ src/JSystem/JParticle/JPAResourceLoader.cpp | 176 +- src/d/actor/d_a_ep.cpp | 7 +- 28 files changed, 2138 insertions(+), 1469 deletions(-) diff --git a/configure.py b/configure.py index 20407b6e17c..5a79cf27513 100644 --- a/configure.py +++ b/configure.py @@ -680,7 +680,7 @@ config.libs = [ "JParticle", [ Object(Matching, "JSystem/JParticle/JPAResourceManager.cpp"), - Object(NonMatching, "JSystem/JParticle/JPAResource.cpp"), + Object(Equivalent, "JSystem/JParticle/JPAResource.cpp"), Object(Matching, "JSystem/JParticle/JPABaseShape.cpp"), Object(Matching, "JSystem/JParticle/JPAExtraShape.cpp"), Object(Matching, "JSystem/JParticle/JPAChildShape.cpp"), @@ -689,8 +689,8 @@ config.libs = [ Object(NonMatching, "JSystem/JParticle/JPAFieldBlock.cpp"), Object(Matching, "JSystem/JParticle/JPAKeyBlock.cpp"), Object(Matching, "JSystem/JParticle/JPATexture.cpp"), - Object(NonMatching, "JSystem/JParticle/JPAResourceLoader.cpp"), - Object(NonMatching, "JSystem/JParticle/JPAEmitterManager.cpp"), + Object(Matching, "JSystem/JParticle/JPAResourceLoader.cpp"), + Object(Equivalent, "JSystem/JParticle/JPAEmitterManager.cpp"), Object(Matching, "JSystem/JParticle/JPAEmitter.cpp"), Object(NonMatching, "JSystem/JParticle/JPAParticle.cpp"), Object(Matching, "JSystem/JParticle/JPAMath.cpp"), diff --git a/include/JSystem/JGeometry.h b/include/JSystem/JGeometry.h index 4f82b1152c4..141b6723669 100644 --- a/include/JSystem/JGeometry.h +++ b/include/JSystem/JGeometry.h @@ -3,9 +3,54 @@ #include "dolphin/mtx/vec.h" #include "math.h" +#include "JSystem/JMath/JMath.h" namespace JGeometry { +template +struct TUtil { + static inline T clamp(T v, T min, T max) { + if (v < min) { + return min; + } + if (v > max) { + return max; + } + return v; + } +}; + +template<> +struct TUtil { + static inline f32 clamp(f32 v, f32 min, f32 max) { + if (v < min) { + return min; + } + if (v > max) { + return max; + } + return v; + } + static inline f32 epsilon() { return 32.0f * FLT_EPSILON; } + static inline f32 PI() { return 3.1415927f; } + static inline f32 inv_sqrt(f32 x) { + if (x <= 0.0f) { + return x; + } + f32 root = __frsqrte(x); + return 0.5f * root * (3.0f - x * (root * root)); + } +}; + +template<> +struct TUtil { + static inline double epsilon() { return 32.0f * FLT_EPSILON; } + static inline double one() { return 1.0; } + static inline double atan2(double x, double y) { return atan2(x, y); } + static inline double asin(double x) { return asin(x); } + static inline double halfPI() { return 1.5707963267948966; } +}; + template struct TVec3 { T x; @@ -155,6 +200,10 @@ struct TVec3 : public Vec { }; } + inline void mul(const TVec3& a) { + mul(*this, a); + } + inline TVec3& operator=(const Vec& b) { setTVec3f(&b.x, &this->x); return *this; @@ -250,6 +299,10 @@ struct TVec3 : public Vec { }; } + void scaleAdd(register f32 sc, const TVec3& a, const TVec3& b) { + JMAVECScaleAdd(&a, &b, this, sc); + } + void negateInternal(TVec3* dst) { register f32* rdst = &dst->x; const register f32* src = &x; @@ -286,7 +339,7 @@ struct TVec3 : public Vec { } void setLength(f32 len) { - f32 sq = squared(); + f32 sq = squared(); if (sq <= FLT_EPSILON * 32.0f) { return; } @@ -299,21 +352,33 @@ struct TVec3 : public Vec { scale(norm * len); } + f32 setLength(const TVec3& other, f32 len) { + f32 sq = other.squared(); + if (sq <= TUtil::epsilon()) { + zero(); + return 0.0f; + } + f32 inv_norm = TUtil::inv_sqrt(sq); + scale(inv_norm * len, other); + return inv_norm * sq; + } + f32 dot(const TVec3& other) const { register const f32* pThis = &x; register const f32* pOther = &other.x; - register f32 otherReg; - register f32 thisyz; register f32 res; + register f32 thisyz; + register f32 otheryz; + register f32 otherxy; register f32 thisxy; asm { psq_l thisyz, 4(pThis), 0, 0 - psq_l otherReg, 4(pOther), 0, 0 - ps_mul thisyz, thisyz, otherReg + psq_l otheryz, 4(pOther), 0, 0 + ps_mul thisyz, thisyz, otheryz psq_l thisxy, 0(pThis), 0, 0 - psq_l otherReg, 0(pOther), 0, 0 - ps_madd res, thisxy, otherReg, thisyz - ps_sum0 res, res, thisyz, thisyz + psq_l otherxy, 0(pOther), 0, 0 + ps_madd otheryz, thisxy, otherxy, thisyz + ps_sum0 res, otheryz, thisyz, thisyz }; return res; } @@ -448,44 +513,6 @@ struct TBox2 : TBox > { void set(f32 x0, f32 y0, f32 x1, f32 y1) { i.set(x0, y0); f.set(x1, y1); } }; -template -struct TUtil { - static inline T clamp(T v, T min, T max) { - if (v < min) { - return min; - } - if (v > max) { - return max; - } - return v; - } -}; - -template<> -struct TUtil { - static inline f32 epsilon() { return 32.0f * FLT_EPSILON; } - static inline f32 PI() { return 3.1415927f; } - - static inline f32 clamp(f32 v, f32 min, f32 max) { - if (v < min) { - return min; - } - if (v > max) { - return max; - } - return v; - } -}; - -template<> -struct TUtil { - static inline double epsilon() { return 32.0f * FLT_EPSILON; } - static inline double one() { return 1.0; } - static inline double atan2(double x, double y) { return atan2(x, y); } - static inline double asin(double x) { return asin(x); } - static inline double halfPI() { return 1.5707963267948966; } -}; - // clang-format on } // namespace JGeometry diff --git a/include/JSystem/JMath/JMath.h b/include/JSystem/JMath/JMath.h index 51f5ce78e80..e37460e115f 100644 --- a/include/JSystem/JMath/JMath.h +++ b/include/JSystem/JMath/JMath.h @@ -6,7 +6,9 @@ void JMAMTXApplyScale(const Mtx, Mtx, f32, f32, f32); void JMAEulerToQuat(s16 param_0, s16 param_1, s16 param_2, Quaternion* param_3); void JMAQuatLerp(const Quaternion*, const Quaternion*, f32, Quaternion*); -void JMAFastVECNormalize(register const Vec* src, register Vec* dst); +void JMAFastVECNormalize(register const Vec* src, register Vec* dst); +void JMAVECScaleAdd(register const Vec* vec1, register const Vec* vec2, register Vec* dst, + register f32 scale); inline int JMAAbs(int value) { return (value >> 0x1f ^ value) - (value >> 0x1f); diff --git a/include/JSystem/JParticle/JPABaseShape.h b/include/JSystem/JParticle/JPABaseShape.h index 9f716cc2877..9f72c68a335 100644 --- a/include/JSystem/JParticle/JPABaseShape.h +++ b/include/JSystem/JParticle/JPABaseShape.h @@ -4,6 +4,7 @@ #include "dolphin/gx/GXStruct.h" class JPAEmitterWorkData; +class JPABaseParticle; class JKRHeap; /** @@ -78,21 +79,21 @@ public: 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) & 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 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 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); } + 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; } @@ -100,7 +101,7 @@ public: void getEnvClr(GXColor* dst) { *dst = mpData->mClrEnv; } void getEnvClr(s16 idx, GXColor* dst) { *dst = mpEnvClrAnmTbl[idx]; } - bool isTexAnm() const { return !!(mpData->mTexFlg & 0x01); } + BOOL isTexAnm() const { return mpData->mTexFlg & 0x01; } u8 getTexAnmType() const { return (mpData->mTexFlg >> 2) & 0x07; } u32 getTexIdx() const { return mpData->mTexIdx; } u8 getTexIdx(u8 idx) const { return mpTexIdxAnimTbl[idx]; } @@ -111,6 +112,7 @@ public: 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() { return mpData->mAnmRndm; } f32 getIncTransX() const { return ((f32*)mpTexCrdMtxAnmTbl)[5]; } f32 getInitTransX() const { return ((f32*)mpTexCrdMtxAnmTbl)[0]; } @@ -141,4 +143,68 @@ struct JPAClrAnmKeyData { /* 0x2 */ GXColor color; }; +void JPACalcTexIdxNormal(JPAEmitterWorkData*); +void JPACalcTexIdxRepeat(JPAEmitterWorkData*); +void JPACalcTexIdxReverse(JPAEmitterWorkData*); +void JPACalcTexIdxMerge(JPAEmitterWorkData*); +void JPACalcTexIdxRandom(JPAEmitterWorkData*); +void JPACalcPrm(JPAEmitterWorkData*); +void JPACalcEnv(JPAEmitterWorkData*); +void JPACalcClrIdxNormal(JPAEmitterWorkData*); +void JPACalcClrIdxRepeat(JPAEmitterWorkData*); +void JPACalcClrIdxReverse(JPAEmitterWorkData*); +void JPACalcClrIdxMerge(JPAEmitterWorkData*); +void JPACalcClrIdxRandom(JPAEmitterWorkData*); + +void JPACalcTexIdxNormal(JPAEmitterWorkData*, JPABaseParticle*); +void JPACalcTexIdxRepeat(JPAEmitterWorkData*, JPABaseParticle*); +void JPACalcTexIdxReverse(JPAEmitterWorkData*, JPABaseParticle*); +void JPACalcTexIdxMerge(JPAEmitterWorkData*, JPABaseParticle*); +void JPACalcTexIdxRandom(JPAEmitterWorkData*, JPABaseParticle*); +void JPACalcPrm(JPAEmitterWorkData*, JPABaseParticle*); +void JPACalcEnv(JPAEmitterWorkData*, JPABaseParticle*); +void JPACalcClrIdxNormal(JPAEmitterWorkData*, JPABaseParticle*); +void JPACalcClrIdxRepeat(JPAEmitterWorkData*, JPABaseParticle*); +void JPACalcClrIdxReverse(JPAEmitterWorkData*, JPABaseParticle*); +void JPACalcClrIdxMerge(JPAEmitterWorkData*, JPABaseParticle*); +void JPACalcClrIdxRandom(JPAEmitterWorkData*, JPABaseParticle*); +void JPACalcColorCopy(JPAEmitterWorkData*, JPABaseParticle*); + +void JPADrawStripe(JPAEmitterWorkData*); +void JPADrawStripeX(JPAEmitterWorkData*); +void JPADrawEmitterCallBackB(JPAEmitterWorkData*); +void JPALoadTex(JPAEmitterWorkData*); +void JPALoadTexAnm(JPAEmitterWorkData*); +void JPAGenTexCrdMtxIdt(JPAEmitterWorkData*); +void JPAGenCalcTexCrdMtxAnm(JPAEmitterWorkData*); +void JPAGenTexCrdMtxAnm(JPAEmitterWorkData*); +void JPAGenTexCrdMtxPrj(JPAEmitterWorkData*); +void JPALoadPosMtxCam(JPAEmitterWorkData*); +void JPASetLineWidth(JPAEmitterWorkData*); +void JPASetPointSize(JPAEmitterWorkData*); +void JPARegistPrm(JPAEmitterWorkData*); +void JPARegistEnv(JPAEmitterWorkData*); +void JPARegistPrmEnv(JPAEmitterWorkData*); + +void JPADrawPoint(JPAEmitterWorkData*, JPABaseParticle*); +void JPADrawLine(JPAEmitterWorkData*, JPABaseParticle*); +void JPADrawRotBillboard(JPAEmitterWorkData*, JPABaseParticle*); +void JPADrawBillboard(JPAEmitterWorkData*, JPABaseParticle*); +void JPADrawRotDirection(JPAEmitterWorkData*, JPABaseParticle*); +void JPADrawDirection(JPAEmitterWorkData*, JPABaseParticle*); +void JPADrawRotation(JPAEmitterWorkData*, JPABaseParticle*); +void JPADrawDBillboard(JPAEmitterWorkData*, JPABaseParticle*); +void JPADrawRotYBillboard(JPAEmitterWorkData*, JPABaseParticle*); +void JPADrawYBillboard(JPAEmitterWorkData*, JPABaseParticle*); +void JPADrawParticleCallBack(JPAEmitterWorkData*, JPABaseParticle*); +void JPALoadTexAnm(JPAEmitterWorkData*, JPABaseParticle*); +void JPASetPointSize(JPAEmitterWorkData*, JPABaseParticle*); +void JPASetLineWidth(JPAEmitterWorkData*, JPABaseParticle*); +void JPALoadCalcTexCrdMtxAnm(JPAEmitterWorkData*, JPABaseParticle*); +void JPARegistAlpha(JPAEmitterWorkData*, JPABaseParticle*); +void JPARegistEnv(JPAEmitterWorkData*, JPABaseParticle*); +void JPARegistAlphaEnv(JPAEmitterWorkData*, JPABaseParticle*); +void JPARegistPrmAlpha(JPAEmitterWorkData*, JPABaseParticle*); +void JPARegistPrmAlphaEnv(JPAEmitterWorkData*, JPABaseParticle*); + #endif /* JPABASESHAPE_H */ diff --git a/include/JSystem/JParticle/JPAChildShape.h b/include/JSystem/JParticle/JPAChildShape.h index 65a71ac453f..899cde4d18b 100644 --- a/include/JSystem/JParticle/JPAChildShape.h +++ b/include/JSystem/JParticle/JPAChildShape.h @@ -3,6 +3,9 @@ #include "dolphin/gx/GXStruct.h" +class JPAEmitterWorkData; +class JPABaseParticle; + /** * @ingroup jsystem-jparticle * @@ -41,11 +44,46 @@ class JPAChildShape { public: /* 8027B038 */ JPAChildShape(u8 const*); - void getPrmClr(GXColor* dst) { *dst = mpData->mPrmClr; } - void getEnvClr(GXColor* dst) { *dst = mpData->mEnvClr; } + f32 getPosRndm() const { return mpData->mPosRndm; } + f32 getBaseVel() const { return mpData->mBaseVel; } + f32 getBaseVelRndm() const { return mpData->mBaseVelRndm; } + f32 getVelInhRate() const { return mpData->mVelInfRate; } + f32 getGravity() const { return mpData->mGravity; } + f32 getScaleX() const { return mpData->mScaleX; } + f32 getScaleY() const { return mpData->mScaleY; } + f32 getScaleInhRate() const { return mpData->mInheritScale; } + f32 getAlphaInhRate() const { return mpData->mInheritAlpha; } + f32 getColorInhRate() const { return mpData->mInheritRGB; } + void getPrmClr(GXColor* dst) const { *dst = mpData->mPrmClr; } + u8 getPrmAlpha() const { return mpData->mPrmClr.a; } + void getEnvClr(GXColor* dst) const { *dst = mpData->mEnvClr; } + f32 getTiming() const { return mpData->mTiming; } + s16 getLife() const { return mpData->mLife; } + s16 getRate() const { return mpData->mRate; } + u8 getStep() const { return mpData->mStep; } + u8 getTexIdx() const { return mpData->mTexIdx; } + s16 getRotInitSpeed() const { return mpData->mRotSpeed; } + u32 getType() const { return mpData->mFlags & 0xF; } + u32 getDirType() const { return (mpData->mFlags >> 4) & 7; } + u32 getRotType() const { return (mpData->mFlags >> 7) & 7; } + u32 getBasePlaneType() const { return (mpData->mFlags >> 10) & 1; } + + BOOL isScaleInherited() const { return mpData->mFlags & 0x10000; } + BOOL isAlphaInherited() const { return mpData->mFlags & 0x20000; } + BOOL isColorInherited() const { return mpData->mFlags & 0x40000; } + BOOL isClipOn() const { return mpData->mFlags & 0x100000; } + BOOL isFieldAffected() const { return mpData->mFlags & 0x200000; } + BOOL isScaleOutOn() const { return mpData->mFlags & 0x400000; } + BOOL isAlphaOutOn() const { return mpData->mFlags & 0x800000; } + BOOL isRotateOn() const { return mpData->mFlags & 0x1000000; } public: /* 0x00 */ const JPAChildShapeData* mpData; }; +void JPARegistChildPrmEnv(JPAEmitterWorkData*); + +void JPACalcChildAlphaOut(JPAEmitterWorkData*, JPABaseParticle*); +void JPACalcChildScaleOut(JPAEmitterWorkData*, JPABaseParticle*); + #endif /* JPACHILDSHAPE_H */ diff --git a/include/JSystem/JParticle/JPADynamicsBlock.h b/include/JSystem/JParticle/JPADynamicsBlock.h index 5ef85f5a943..e408943769a 100644 --- a/include/JSystem/JParticle/JPADynamicsBlock.h +++ b/include/JSystem/JParticle/JPADynamicsBlock.h @@ -96,7 +96,10 @@ public: f32 getInitVelDir() { return mpData->mInitialVelDir; } f32 getInitVelDirSp() { return mpData->mSpread; } f32 getInitVelRndm() { return mpData->mInitialVelRndm; } + f32 getInitVelRatio() { return mpData->mInitialVelRatio; } f32 getAirRes() { return mpData->mAirResist; } + f32 getLifeTimeRndm() { return mpData->mLifeTimeRndm; } + f32 getMomentRndm() { return mpData->mMoment; } public: /* 0x00 */ const JPADynamicsBlockData* mpData; diff --git a/include/JSystem/JParticle/JPAEmitter.h b/include/JSystem/JParticle/JPAEmitter.h index c7dc0590865..f861d83f9b4 100644 --- a/include/JSystem/JParticle/JPAEmitter.h +++ b/include/JSystem/JParticle/JPAEmitter.h @@ -47,10 +47,10 @@ struct JPAEmitterWorkData { /* 0x1B4 */ Mtx mPrjMtx; /* 0x1E4 */ JPAList* mpAlivePtcl; /* 0x1E8 */ JPANode* mpCurNode; - /* 0x1EC */ u32 mVolumeAngleNum; - /* 0x1F0 */ u32 mVolumeAngleMax; - /* 0x1F4 */ u32 mVolumeX; - /* 0x1F8 */ u32 mDivNumber; + /* 0x1EC */ s32 mVolumeAngleNum; + /* 0x1F0 */ s32 mVolumeAngleMax; + /* 0x1F4 */ s32 mVolumeX; + /* 0x1F8 */ s32 mDivNumber; /* 0x1FC */ f32 mScaleAnm; /* 0x200 */ u32 mDirType; /* 0x204 */ u32 mRotType; @@ -93,8 +93,8 @@ enum { */ class JPABaseEmitter { public: - /* 8027E5EC */ ~JPABaseEmitter(); - /* 8027E64C */ JPABaseEmitter(); + /* 8027E5EC */ ~JPABaseEmitter() {} + /* 8027E64C */ JPABaseEmitter() : mLink(this) {} /* 8027E6EC */ void init(JPAEmitterManager*, JPAResource*); /* 8027EDD4 */ bool processTillStartFrame(); /* 8027EE14 */ bool processTermination(); @@ -223,7 +223,7 @@ public: /* 0x44 */ f32 mRndmDirSpeed; /* 0x48 */ f32 mAirResist; /* 0x4C */ JGeometry::TVec3 mLocalRot; - /* 0x52 */ u16 mLifeTime; + /* 0x52 */ s16 mLifeTime; /* 0x54 */ u16 mVolumeSize; /* 0x56 */ u8 mRateStep; /* 0x58 */ JSULink mLink; diff --git a/include/JSystem/JParticle/JPAExTexShape.h b/include/JSystem/JParticle/JPAExTexShape.h index 0ec6471d1eb..b202cc9d9c6 100644 --- a/include/JSystem/JParticle/JPAExTexShape.h +++ b/include/JSystem/JParticle/JPAExTexShape.h @@ -3,6 +3,8 @@ #include "dolphin/types.h" +class JPAEmitterWorkData; + /** * @ingroup jsystem-jparticle * @@ -28,7 +30,7 @@ public: /* 8027B13C */ JPAExTexShape(u8 const*); const f32* getIndTexMtx() const { return &mpData->mIndTexMtx[0][0]; } - s32 getExpScale() const { return mpData->mExpScale; } + 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); } @@ -38,4 +40,6 @@ public: const JPAExTexShapeData* mpData; }; +void JPALoadExTex(JPAEmitterWorkData*); + #endif /* JPAEXTEXSHAPE_H */ diff --git a/include/JSystem/JParticle/JPAExtraShape.h b/include/JSystem/JParticle/JPAExtraShape.h index 5a231348d9a..dbf46363411 100644 --- a/include/JSystem/JParticle/JPAExtraShape.h +++ b/include/JSystem/JParticle/JPAExtraShape.h @@ -3,6 +3,9 @@ #include "dolphin/types.h" +class JPAEmitterWorkData; +class JPABaseParticle; + /** * @ingroup jsystem-jparticle * @@ -52,6 +55,7 @@ public: f32 getScaleInValueY() const { return mpData->mScaleInValueY; } f32 getScaleOutValueX() const { return mpData->mScaleOutValueX; } f32 getScaleOutValueY() const { return mpData->mScaleOutValueY; } + f32 getScaleRndm() const { return mpData->mScaleOutRandom; } s16 getScaleAnmCycleX() const { return mpData->mScaleAnmCycleX; } s16 getScaleAnmCycleY() const { return mpData->mScaleAnmCycleY; } f32 getAlphaInTiming() const { return mpData->mAlphaInTiming; } @@ -60,7 +64,13 @@ public: f32 getAlphaOutValue() const { return mpData->mAlphaOutValue; } f32 getAlphaBaseValue() const { return mpData->mAlphaBaseValue; } f32 getAlphaFreq() const { return mpData->mAlphaWaveFrequency; } + f32 getAlphaFreqRndm() const { return mpData->mAlphaWaveRandom; } f32 getAlphaAmp() const { return mpData->mAlphaWaveAmplitude; } + f32 getRotateInitAngle() const { return mpData->mRotateAngle; } + f32 getRotateRndmAngle() const { return mpData->mRotateAngleRandom; } + f32 getRotateInitSpeed() const { return mpData->mRotateSpeed; } + f32 getRotateRndmSpeed() const { return mpData->mRotateSpeedRandom; } + f32 getRotateDirection() const { return mpData->mRotateDirection; } f32 getScaleIncRateX() const { return mScaleIncRateX; } f32 getScaleDecRateX() const { return mScaleDecRateX; } f32 getScaleIncRateY() const { return mScaleIncRateY; } @@ -68,6 +78,16 @@ public: f32 getAlphaIncRate() const { return mAlphaIncRate; } f32 getAlphaDecRate() const { return mAlphaDecRate; } + BOOL isEnableScaleAnm() const { return mpData->mFlags & 1; } + BOOL isScaleXYDiff() const { return mpData->mFlags & 2; } + u32 getScaleAnmTypeX() const { return (mpData->mFlags >> 8) & 3; } + u32 getScaleAnmTypeY() const { return (mpData->mFlags >> 10) & 3; } + u32 getScaleCenterX() const { return (mpData->mFlags >> 12) & 3; } + u32 getScaleCenterY() const { return (mpData->mFlags >> 14) & 3; } + BOOL isEnableAlphaAnm() const { return mpData->mFlags & 0x10000; } + BOOL isEnableAlphaFlick() const { return mpData->mFlags & 0x20000; } + BOOL isEnableRotateAnm() const { return mpData->mFlags & 0x1000000; } + private: /* 0x00 */ const JPAExtraShapeData* mpData; /* 0x04 */ f32 mAlphaIncRate; @@ -78,4 +98,15 @@ private: /* 0x18 */ f32 mScaleDecRateY; }; +void JPACalcAlphaFlickAnm(JPAEmitterWorkData*, JPABaseParticle*); +void JPACalcAlphaAnm(JPAEmitterWorkData*, JPABaseParticle*); +void JPACalcScaleX(JPAEmitterWorkData*, JPABaseParticle*); +void JPACalcScaleY(JPAEmitterWorkData*, JPABaseParticle*); +void JPACalcScaleCopy(JPAEmitterWorkData*, JPABaseParticle*); +void JPACalcScaleAnmNormal(JPAEmitterWorkData*, JPABaseParticle*); +void JPACalcScaleAnmRepeatX(JPAEmitterWorkData*, JPABaseParticle*); +void JPACalcScaleAnmReverseX(JPAEmitterWorkData*, JPABaseParticle*); +void JPACalcScaleAnmRepeatY(JPAEmitterWorkData*, JPABaseParticle*); +void JPACalcScaleAnmReverseY(JPAEmitterWorkData*, JPABaseParticle*); + #endif /* JPAEXTRASHAPE_H */ diff --git a/include/JSystem/JParticle/JPAFieldBlock.h b/include/JSystem/JParticle/JPAFieldBlock.h index 61ab305f058..5df9365d97a 100644 --- a/include/JSystem/JParticle/JPAFieldBlock.h +++ b/include/JSystem/JParticle/JPAFieldBlock.h @@ -1,6 +1,174 @@ #ifndef JPAFIELDBLOCK_H #define JPAFIELDBLOCK_H +#include "JSystem/JGeometry.h" #include "dolphin/types.h" +class JKRHeap; +class JPAEmitterWorkData; +class JPABaseParticle; +class JPAFieldBlock; + +class JPAFieldBase { +public: + /* 8027BDEC */ void calcAffect(JPAFieldBlock*, JPABaseParticle*); + /* 8027BF18 */ f32 calcFadeAffect(JPAFieldBlock*, f32) const; + + /* 8027D3AC */ virtual ~JPAFieldBase() {} + /* 80276A8C */ virtual void prepare(JPAEmitterWorkData*, JPAFieldBlock*) {} + virtual void calc(JPAEmitterWorkData*, JPAFieldBlock*, JPABaseParticle*) = 0; + + /* 0x04 */ JGeometry::TVec3 mAccel; +}; + +class JPAFieldVortex : public JPAFieldBase { +public: + /* 8027C56C */ void prepare(JPAEmitterWorkData*, JPAFieldBlock*); + /* 8027C674 */ void calc(JPAEmitterWorkData*, JPAFieldBlock*, JPABaseParticle*); + /* 8027D564 */ ~JPAFieldVortex() {} + + /* 0x10 */ JGeometry::TVec3 field_0x10; + /* 0x1C */ f32 field_0x1c; + /* 0x20 */ f32 field_0x20; +}; + +class JPAFieldSpin : public JPAFieldBase { +public: + /* 8027CE64 */ void prepare(JPAEmitterWorkData*, JPAFieldBlock*); + /* 8027CFA8 */ void calc(JPAEmitterWorkData*, JPAFieldBlock*, JPABaseParticle*); + /* 8027D3F4 */ ~JPAFieldSpin() {} + + /* 0x10 */ JGeometry::TVec3 field_0x10; + /* 0x1C */ JGeometry::TVec3 field_0x1c; + /* 0x28 */ JGeometry::TVec3 field_0x28; +}; + +class JPAFieldRandom : public JPAFieldBase { +public: + /* 8027CCCC */ void calc(JPAEmitterWorkData*, JPAFieldBlock*, JPABaseParticle*); + /* 8027D4AC */ ~JPAFieldRandom() {} +}; + +class JPAFieldNewton : public JPAFieldBase { +public: + /* 8027C36C */ void prepare(JPAEmitterWorkData*, JPAFieldBlock*); + /* 8027C3E0 */ void calc(JPAEmitterWorkData*, JPAFieldBlock*, JPABaseParticle*); + /* 8027D5C0 */ ~JPAFieldNewton() {} + + /* 0x10 */ JGeometry::TVec3 mDir; + /* 0x1C */ f32 mCutoff; +}; + +class JPAFieldMagnet : public JPAFieldBase { +public: + /* 8027C24C */ void prepare(JPAEmitterWorkData*, JPAFieldBlock*); + /* 8027C29C */ void calc(JPAEmitterWorkData*, JPAFieldBlock*, JPABaseParticle*); + /* 8027D61C */ ~JPAFieldMagnet() {} + + /* 0x10 */ JGeometry::TVec3 mDir; +}; + +class JPAFieldGravity : public JPAFieldBase { +public: + /* 8027BFB4 */ void prepare(JPAEmitterWorkData*, JPAFieldBlock*); + /* 8027C054 */ void calc(JPAEmitterWorkData*, JPAFieldBlock*, JPABaseParticle*); + /* 8027D6D4 */ ~JPAFieldGravity() {} +}; + +class JPAFieldDrag : public JPAFieldBase { +public: + /* 8027CDE4 */ void calc(JPAEmitterWorkData*, JPAFieldBlock*, JPABaseParticle*); + /* 8027D450 */ ~JPAFieldDrag() {} +}; + +class JPAFieldConvection : public JPAFieldBase { +public: + /* 8027C814 */ void prepare(JPAEmitterWorkData*, JPAFieldBlock*); + /* 8027CA94 */ void calc(JPAEmitterWorkData*, JPAFieldBlock*, JPABaseParticle*); + /* 8027D508 */ ~JPAFieldConvection() {} + + /* 0x10 */ JGeometry::TVec3 field_0x10; + /* 0x1C */ JGeometry::TVec3 field_0x1c; + /* 0x28 */ JGeometry::TVec3 field_0x28; +}; + +class JPAFieldAir : public JPAFieldBase { +public: + /* 8027C07C */ void prepare(JPAEmitterWorkData*, JPAFieldBlock*); + /* 8027C1B8 */ void calc(JPAEmitterWorkData*, JPAFieldBlock*, JPABaseParticle*); + /* 8027D678 */ ~JPAFieldAir() {} +}; + +// unknown name +class JPAFieldBlockData { +public: + /* 0x00 */ u8 mMagic[4]; + /* 0x04 */ u32 mSize; + /* 0x08 */ u32 mFlags; + /* 0x0C */ JGeometry::TVec3 mPos; + /* 0x18 */ JGeometry::TVec3 mDir; + /* 0x24 */ f32 mMag; + /* 0x28 */ f32 mMagRndm; + /* 0x2C */ f32 mVal1; + /* 0x30 */ f32 mFadeInTime; + /* 0x34 */ f32 mFadeOutTime; + /* 0x38 */ f32 mEnTime; + /* 0x3C */ f32 mDisTime; + /* 0x40 */ u8 mCycle; +}; + +class JPAFieldBlock { +public: + /* 8027D088 */ JPAFieldBlock(u8 const*, JKRHeap*); + /* 8027D0C0 */ 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(); } + f32 getMagRndm() { return mpData->mMagRndm; } + f32 getVal1() { 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& getPos() { return mPos; } + JGeometry::TVec3& getDir() { return mDir; } + f32 getMag() { return mMag; } + void getPosOrig(JGeometry::TVec3* pos) { pos->set(mpData->mPos); } + void getDirOrig(JGeometry::TVec3* dir) { dir->set(mpData->mDir); } + f32 getMagOrig() { 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); } + +private: + /* 0x00 */ const JPAFieldBlockData* mpData; + /* 0x04 */ JPAFieldBase* mpField; + /* 0x08 */ f32 mFadeInRate; + /* 0x0C */ f32 mFadeOutRate; + /* 0x10 */ JGeometry::TVec3 mPos; + /* 0x1C */ JGeometry::TVec3 mDir; + /* 0x28 */ f32 mMag; + + enum Type { + /* 0x0 */ FIELD_GRAVITY, + /* 0x1 */ FIELD_AIR, + /* 0x2 */ FIELD_MAGNET, + /* 0x3 */ FIELD_NEWTON, + /* 0x4 */ FIELD_VORTEX, + /* 0x5 */ FIELD_RANDOM, + /* 0x6 */ FIELD_DRAG, + /* 0x7 */ FIELD_CONVECTION, + /* 0x8 */ FIELD_SPIN, + }; +}; + #endif /* JPAFIELDBLOCK_H */ diff --git a/include/JSystem/JParticle/JPAKeyBlock.h b/include/JSystem/JParticle/JPAKeyBlock.h index 3c457a110e3..3d79e854f4f 100644 --- a/include/JSystem/JParticle/JPAKeyBlock.h +++ b/include/JSystem/JParticle/JPAKeyBlock.h @@ -9,7 +9,9 @@ */ struct JPAKeyBlock { /* 8027D730 */ JPAKeyBlock(u8 const*); - /* 8027D740 */ void calc(f32); + /* 8027D740 */ f32 calc(f32); + + u8 getID() { return mDataStart[8]; } const u8* mDataStart; const f32* field_0x4; diff --git a/include/JSystem/JParticle/JPAList.h b/include/JSystem/JParticle/JPAList.h index 2a1fe7ece55..b5caf50a76d 100644 --- a/include/JSystem/JParticle/JPAList.h +++ b/include/JSystem/JParticle/JPAList.h @@ -1,6 +1,8 @@ #ifndef JPALIST_H #define JPALIST_H +#include "dolphin/types.h" + /** * @ingroup jsystem-jparticle * @@ -15,9 +17,10 @@ struct JPANode { JPANode* getPrev() { return mpPrev; } JPANode* getNext() { return mpNext; } T* getObject() { return &mData; } - JPANode* mpPrev; - JPANode* mpNext; - T mData; + + /* 0x00 */ JPANode* mpPrev; + /* 0x04 */ JPANode* mpNext; + /* 0x08 */ T mData; }; /** @@ -26,9 +29,9 @@ struct JPANode { */ template struct JPAList { - JPANode* mpFirst; - JPANode* mpLast; - u32 mNum; + /* 0x00 */ JPANode* mpFirst; + /* 0x04 */ JPANode* mpLast; + /* 0x08 */ u32 mNum; JPAList() : mpFirst(NULL), mpLast(NULL), mNum() {} @@ -104,6 +107,27 @@ struct JPAList { return ret; } + + JPANode* erase(JPANode* node) { + if (node->mpNext != NULL && node->mpPrev != NULL) { + node->mpPrev->mpNext = node->mpNext; + node->mpNext->mpPrev = node->mpPrev; + mNum--; + } else if (node->mpNext != NULL) { + node->mpNext->mpPrev = NULL; + mpFirst = node->mpNext; + mNum--; + } else if (node->mpPrev != NULL) { + node->mpPrev->mpNext = NULL; + mpLast = node->mpPrev; + mNum--; + } else { + mpLast = NULL; + mpFirst = NULL; + mNum--; + } + return node; + } }; -#endif \ No newline at end of file +#endif diff --git a/include/JSystem/JParticle/JPAParticle.h b/include/JSystem/JParticle/JPAParticle.h index ed303c3b426..c02b11fc936 100644 --- a/include/JSystem/JParticle/JPAParticle.h +++ b/include/JSystem/JParticle/JPAParticle.h @@ -2,11 +2,8 @@ #define JPAPARTICLE_H #include "dolphin/gx/GXStruct.h" - #include "JSystem/JGeometry.h" -#include "JSystem/JParticle/JPAList.h" - class JKRHeap; class JPABaseEmitter; class JPABaseParticle; @@ -24,9 +21,9 @@ class JPABaseParticle { public: /* 8027EFEC */ void init_p(JPAEmitterWorkData*); /* 8027F8C8 */ void init_c(JPAEmitterWorkData*, JPABaseParticle*); - /* 8027FFD0 */ void calc_p(JPAEmitterWorkData*); - /* 80280260 */ void calc_c(JPAEmitterWorkData*); - /* 802804C8 */ void canCreateChild(JPAEmitterWorkData*); + /* 8027FFD0 */ bool calc_p(JPAEmitterWorkData*); + /* 80280260 */ bool calc_c(JPAEmitterWorkData*); + /* 802804C8 */ bool canCreateChild(JPAEmitterWorkData*); /* 80280548 */ f32 getWidth(JPABaseEmitter const*) const; /* 80280568 */ f32 getHeight(JPABaseEmitter const*) const; int getAge() { return mAge; } @@ -39,6 +36,7 @@ public: f32 getParticleScaleY() const { return mParticleScaleY; } void setStatus(u32 flag) { mStatus |= flag; } u32 checkStatus(u32 flag) { return mStatus & flag; } + void initStatus(u32 status) { mStatus = status; } void setInvisibleParticleFlag() { setStatus(8); } void setDeleteParticleFlag() { setStatus(2); } void getVelVec(JGeometry::TVec3& vec) const { vec.set(mVelocity); } @@ -50,9 +48,9 @@ public: /* 0x0C */ JGeometry::TVec3 mLocalPosition; /* 0x18 */ JGeometry::TVec3 mOffsetPosition; /* 0x24 */ JGeometry::TVec3 mVelocity; - /* 0x30 */ Vec mVelType1; - /* 0x3C */ Vec mVelType0; - /* 0x48 */ Vec mVelType2; + /* 0x30 */ JGeometry::TVec3 mVelType1; + /* 0x3C */ JGeometry::TVec3 mVelType0; + /* 0x48 */ JGeometry::TVec3 mVelType2; /* 0x54 */ JGeometry::TVec3 mBaseAxis; /* 0x60 */ f32 mParticleScaleX; /* 0x64 */ f32 mParticleScaleY; @@ -63,10 +61,10 @@ public: /* 0x78 */ u32 field_0x78; /* 0x7C */ u32 mStatus; /* 0x80 */ s16 mAge; - /* 0x82 */ u16 mLifeTime; + /* 0x82 */ s16 mLifeTime; /* 0x84 */ f32 mTime; /* 0x88 */ u16 mRotateAngle; - /* 0x8A */ u16 mRotateSpeed; + /* 0x8A */ s16 mRotateSpeed; /* 0x8C */ GXColor mPrmClr; /* 0x90 */ GXColor mEnvClr; /* 0x94 */ u8 mTexAnmIdx; diff --git a/include/JSystem/JParticle/JPARandom.h b/include/JSystem/JParticle/JPARandom.h index b76c46d7b5c..25c3046a438 100644 --- a/include/JSystem/JParticle/JPARandom.h +++ b/include/JSystem/JParticle/JPARandom.h @@ -1,6 +1,8 @@ #ifndef JPARANDOM_H #define JPARANDOM_H +#include "dolphin/types.h" + /** * @ingroup jsystem-jparticle * @@ -27,8 +29,7 @@ public: } f32 get_rndm_zh() { - f32 f = get_rndm_f(); - return f - 0.5f; + return get_rndm_f() - 0.5f; } s16 get_rndm_ss() { return (s16)(get_rndm_u() >> 16); } @@ -37,4 +38,4 @@ public: u32 mSeed; }; -#endif \ No newline at end of file +#endif diff --git a/include/JSystem/JParticle/JPAResource.h b/include/JSystem/JParticle/JPAResource.h index a041daf3023..4b953233388 100644 --- a/include/JSystem/JParticle/JPAResource.h +++ b/include/JSystem/JParticle/JPAResource.h @@ -47,13 +47,15 @@ public: u16 getUsrIdx() const { return mUsrIdx; } public: - /* 0x00 */ void** mpCalcEmitterFuncList; - /* 0x04 */ void** mpDrawEmitterFuncList; - /* 0x08 */ void** mpDrawEmitterChildFuncList; - /* 0x0C */ void** mpCalcParticleFuncList; - /* 0x10 */ void** mpDrawParticleFuncList; - /* 0x14 */ void** mpCalcParticleChildFuncList; - /* 0x18 */ void** mpDrawParticleChildFuncList; + typedef void (*EmitterFunc)(JPAEmitterWorkData*); + typedef void (*ParticleFunc)(JPAEmitterWorkData*, JPABaseParticle*); + /* 0x00 */ EmitterFunc* mpCalcEmitterFuncList; + /* 0x04 */ EmitterFunc* mpDrawEmitterFuncList; + /* 0x08 */ EmitterFunc* mpDrawEmitterChildFuncList; + /* 0x0C */ ParticleFunc* mpCalcParticleFuncList; + /* 0x10 */ ParticleFunc* mpDrawParticleFuncList; + /* 0x14 */ ParticleFunc* mpCalcParticleChildFuncList; + /* 0x18 */ ParticleFunc* mpDrawParticleChildFuncList; /* 0x1C */ JPABaseShape* mpBaseShape; /* 0x20 */ JPAExtraShape* mpExtraShape; diff --git a/include/JSystem/JParticle/JPAResourceLoader.h b/include/JSystem/JParticle/JPAResourceLoader.h index 47be34de180..10ff1e38b64 100644 --- a/include/JSystem/JParticle/JPAResourceLoader.h +++ b/include/JSystem/JParticle/JPAResourceLoader.h @@ -1,4 +1,14 @@ #ifndef JPARESOURCELOADER_H #define JPARESOURCELOADER_H +#include "dolphin/types.h" + +class JPAResourceManager; + +class JPAResourceLoader { +public: + /* 8027D8A0 */ JPAResourceLoader(u8 const*, JPAResourceManager*); + /* 8027D8E0 */ void load_jpc(u8 const*, JPAResourceManager*); +}; + #endif /* JPARESOURCELOADER_H */ diff --git a/include/dolphin/mtx/vec.h b/include/dolphin/mtx/vec.h index 0184fd47faf..91216e74642 100644 --- a/include/dolphin/mtx/vec.h +++ b/include/dolphin/mtx/vec.h @@ -42,8 +42,8 @@ inline void C_VECAdd(register const Vec* a, register const Vec* b, register Vec* asm { psq_l axy, 0(a), 0, 0 psq_l bxy, 0(b), 0, 0 - ps_add axy, axy, bxy - psq_st axy, 0(ab), 0, 0 + ps_add bxy, axy, bxy + psq_st bxy, 0(ab), 0, 0 psq_l az, 8(a), 1, 0 psq_l bz, 8(b), 1, 0 ps_add sumz, az, bz diff --git a/src/JSystem/JParticle/JPABaseShape.cpp b/src/JSystem/JParticle/JPABaseShape.cpp index ba5cf8593ae..78353594d96 100644 --- a/src/JSystem/JParticle/JPABaseShape.cpp +++ b/src/JSystem/JParticle/JPABaseShape.cpp @@ -148,7 +148,6 @@ void JPARegistEnv(JPAEmitterWorkData* work, JPABaseParticle* ptcl) { */ void JPACalcClrIdxNormal(JPAEmitterWorkData* work) { JPABaseShape* bsp = work->mpRes->getBsp(); - // can't get the extsh to appear in the right spot... s16 keyFrame; if (work->mpEmtr->mTick < bsp->getClrAnmMaxFrm()) { keyFrame = work->mpEmtr->mTick; @@ -1447,4 +1446,4 @@ void JPABaseShape::setGX(JPAEmitterWorkData* work) const { GXSetTevDirect(GX_TEVSTAGE0); GXSetTevDirect(GX_TEVSTAGE1); GXSetZCompLoc(getZCompLoc()); -} \ No newline at end of file +} diff --git a/src/JSystem/JParticle/JPAChildShape.cpp b/src/JSystem/JParticle/JPAChildShape.cpp index d46f606e5ac..cbc24cbb06d 100644 --- a/src/JSystem/JParticle/JPAChildShape.cpp +++ b/src/JSystem/JParticle/JPAChildShape.cpp @@ -9,18 +9,6 @@ #include "dolphin/gx.h" #include "dolphin/os.h" -// -// Types: -// - -// -// Forward References: -// - -// -// Declarations: -// - /* 8027AEBC-8027AFDC 2757FC 0120+00 0/0 1/1 0/0 .text JPARegistChildPrmEnv__FP18JPAEmitterWorkData */ void JPARegistChildPrmEnv(JPAEmitterWorkData* work) { @@ -50,7 +38,6 @@ void JPACalcChildAlphaOut(JPAEmitterWorkData* work, JPABaseParticle* ptcl) { /* 8027B008-8027B038 275948 0030+00 0/0 1/1 0/0 .text * JPACalcChildScaleOut__FP18JPAEmitterWorkDataP15JPABaseParticle */ void JPACalcChildScaleOut(JPAEmitterWorkData* work, JPABaseParticle* ptcl) { - // literal ptcl->mParticleScaleX = ptcl->mScaleOut * (1.0f - ptcl->mTime); ptcl->mParticleScaleY = ptcl->mAlphaWaveRandom * (1.0f - ptcl->mTime); } @@ -58,4 +45,4 @@ void JPACalcChildScaleOut(JPAEmitterWorkData* work, JPABaseParticle* ptcl) { /* 8027B038-8027B040 -00001 0008+00 0/0 0/0 0/0 .text __ct__13JPAChildShapeFPCUc */ JPAChildShape::JPAChildShape(u8 const* pData) { mpData = (JPAChildShapeData*)pData; -} \ No newline at end of file +} diff --git a/src/JSystem/JParticle/JPADynamicsBlock.cpp b/src/JSystem/JParticle/JPADynamicsBlock.cpp index d7003def531..0277dfed32e 100644 --- a/src/JSystem/JParticle/JPADynamicsBlock.cpp +++ b/src/JSystem/JParticle/JPADynamicsBlock.cpp @@ -4,57 +4,8 @@ // #include "JSystem/JParticle/JPADynamicsBlock.h" +#include "JSystem/JMath/JMATrigonometric.h" #include "JSystem/JParticle/JPAEmitter.h" -#include "dol2asm.h" - -// -// Types: -// - -// -// Forward References: -// - -extern "C" static void JPAVolumePoint(JPAEmitterWorkData*); -extern "C" static void JPAVolumeLine(JPAEmitterWorkData*); -extern "C" static void JPAVolumeCircle(JPAEmitterWorkData*); -extern "C" static void JPAVolumeCube(JPAEmitterWorkData*); -extern "C" static void JPAVolumeSphere(JPAEmitterWorkData*); -extern "C" static void JPAVolumeCylinder(JPAEmitterWorkData*); -extern "C" static void JPAVolumeTorus(JPAEmitterWorkData*); -extern "C" void __ct__16JPADynamicsBlockFPCUc(); -extern "C" void init__16JPADynamicsBlockFv(); -extern "C" void create__16JPADynamicsBlockFP18JPAEmitterWorkData(); - -// -// External References: -// - -extern "C" void createParticle__14JPABaseEmitterFv(); -extern "C" u8 sincosTable___5JMath[65536]; - -// -// Declarations: -// - -/* ############################################################################################## */ -/* 80455310-80455314 003910 0004+00 7/7 0/0 0/0 .sdata2 @2287 */ -SECTION_SDATA2 static u8 lit_2287[4] = { - 0x00, - 0x00, - 0x00, - 0x00, -}; - -/* 80455314-80455318 003914 0004+00 7/7 0/0 0/0 .sdata2 @2288 */ -SECTION_SDATA2 static f32 lit_2288 = 1.0f; - -/* 80455318-80455320 003918 0004+04 3/3 0/0 0/0 .sdata2 @2289 */ -SECTION_SDATA2 static f32 lit_2289[1 + 1 /* padding */] = { - 0.5f, - /* padding */ - 0.0f, -}; /* 8027B144-8027B220 275A84 00DC+00 1/1 0/0 0/0 .text JPAVolumePoint__FP18JPAEmitterWorkData */ void JPAVolumePoint(JPAEmitterWorkData* work) { @@ -64,12 +15,6 @@ void JPAVolumePoint(JPAEmitterWorkData* work) { work->mVelAxis.set(work->mVelOmni.x, 0.0f, work->mVelOmni.z); } - - -/* ############################################################################################## */ -/* 80455320-80455328 003920 0008+00 6/6 0/0 0/0 .sdata2 @2321 */ -SECTION_SDATA2 static f64 lit_2321 = 4503601774854144.0 /* cast s32 to float */; - /* 8027B220-8027B33C 275B60 011C+00 1/1 0/0 0/0 .text JPAVolumeLine */ void JPAVolumeLine(JPAEmitterWorkData* work) { if (work->mpEmtr->checkFlag(JPADynFlag_FixedInterval)) { @@ -85,17 +30,13 @@ void JPAVolumeLine(JPAEmitterWorkData* work) { work->mVelAxis.set(0.0f, 0.0f, work->mVolumePos.z); } - - /* 8027B33C-8027B4E8 275C7C 01AC+00 1/1 0/0 0/0 .text JPAVolumeCircle */ -// regalloc. Could be issue with mul asm implementations -#ifdef NONMATCHING +// NONMATCHING regalloc. Could be issue with mul asm implementations void JPAVolumeCircle(JPAEmitterWorkData* work) { s16 thetai; f32 theta; f32 distance; f32 sizeXZ; - f32 temp; if (work->mpEmtr->checkFlag(JPADynFlag_FixedInterval)) { theta = (s16)((work->mVolumeEmitIdx << 16) / work->mEmitCount); thetai = theta * work->mVolumeSweep; @@ -116,14 +57,6 @@ void JPAVolumeCircle(JPAEmitterWorkData* work) { work->mVelAxis.set(work->mVolumePos.x, 0.0f, work->mVolumePos.z); } -#else - -static void JPAVolumeCircle(JPAEmitterWorkData* param_0) { - // NONMATCHING -} - -#endif - /* 8027B4E8-8027B5F0 275E28 0108+00 1/1 0/0 0/0 .text JPAVolumeCube */ void JPAVolumeCube(JPAEmitterWorkData* work) { work->mVolumePos.set(work->mpEmtr->get_r_zh() * work->mVolumeSize, @@ -133,32 +66,64 @@ void JPAVolumeCube(JPAEmitterWorkData* work) { work->mVelAxis.set(work->mVolumePos.x, 0.0f, work->mVolumePos.z); } - - -/* ############################################################################################## */ -/* 80455328-80455330 003928 0004+04 1/1 0/0 0/0 .sdata2 @2501 */ -SECTION_SDATA2 static f32 lit_2501[1 + 1 /* padding */] = { - 32768.0f, - /* padding */ - 0.0f, -}; - -/* 80455330-80455338 003930 0008+00 1/1 0/0 0/0 .sdata2 @2503 */ -SECTION_SDATA2 static f64 lit_2503 = 4503599627370496.0 /* cast u32 to float */; - /* 8027B5F0-8027B87C 275F30 028C+00 1/1 0/0 0/0 .text JPAVolumeSphere__FP18JPAEmitterWorkData */ -static void JPAVolumeSphere(JPAEmitterWorkData* param_0) { - // NONMATCHING +static void JPAVolumeSphere(JPAEmitterWorkData* work) { + s16 phi, theta; + 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; + work->mVolumeAngleNum++; + if (work->mVolumeAngleNum == work->mVolumeAngleMax) { + work->mVolumeAngleNum = 0; + work->mVolumeX++; + if (work->mVolumeX * 2 < work->mDivNumber) { + work->mVolumeAngleMax = work->mVolumeAngleMax != 1 ? + work->mVolumeAngleMax + 4 : work->mVolumeAngleMax + 3; + } else { + work->mVolumeAngleMax = work->mVolumeAngleMax != 4 ? work->mVolumeAngleMax - 4 : 1; + } + } + } else { + phi = work->mpEmtr->get_r_ss() >> 1; + theta = work->mVolumeSweep * work->mpEmtr->get_r_ss(); + } + + f32 rnd = work->mpEmtr->get_r_f(); + if (work->mpEmtr->checkFlag(JPADynFlag_FixedDensity)) { + rnd = 1.0f - rnd * rnd * rnd; + } + f32 rad = work->mVolumeSize * (work->mVolumeMinRad + rnd * (1.0f - work->mVolumeMinRad)); + work->mVolumePos.set(rad * JMASCos(phi) * JMASSin(theta), -rad * JMASSin(phi), + rad * JMASCos(phi) * JMASCos(theta)); + work->mVelOmni.mul(work->mVolumePos, work->mGlobalScl); + work->mVelAxis.set(work->mVolumePos.x, 0.0f, work->mVolumePos.z); } /* 8027B87C-8027B9F8 2761BC 017C+00 1/1 0/0 0/0 .text JPAVolumeCylinder__FP18JPAEmitterWorkData */ -static void JPAVolumeCylinder(JPAEmitterWorkData* param_0) { - // NONMATCHING +static void JPAVolumeCylinder(JPAEmitterWorkData* work) { + s16 theta = work->mVolumeSweep * work->mpEmtr->get_r_ss(); + f32 rnd = work->mpEmtr->get_r_f(); + if (work->mpEmtr->checkFlag(JPADynFlag_FixedDensity)) { + rnd = 1.0f - rnd * rnd; + } + f32 rad = work->mVolumeSize * (work->mVolumeMinRad + rnd * (1.0f - work->mVolumeMinRad)); + work->mVolumePos.set(rad * JMASSin(theta), work->mVolumeSize * work->mpEmtr->get_r_zp(), + rad * JMASCos(theta)); + work->mVelOmni.mul(work->mVolumePos, work->mGlobalScl); + work->mVelAxis.set(work->mVolumePos.x, 0.0f, work->mVolumePos.z); } /* 8027B9F8-8027BB18 276338 0120+00 1/1 0/0 0/0 .text JPAVolumeTorus__FP18JPAEmitterWorkData */ -static void JPAVolumeTorus(JPAEmitterWorkData* param_0) { - // NONMATCHING +static void JPAVolumeTorus(JPAEmitterWorkData* work) { + s16 theta = work->mVolumeSweep * work->mpEmtr->get_r_ss(); + s16 phi = work->mpEmtr->get_r_ss(); + f32 rad = work->mVolumeSize * work->mVolumeMinRad; + work->mVelAxis.set(rad * JMASSin(theta) * JMASCos(phi), rad * JMASSin(phi), + rad * JMASCos(theta) * JMASCos(phi)); + work->mVolumePos.set(work->mVelAxis.x + work->mVolumeSize * JMASSin(theta), work->mVelAxis.y, + work->mVelAxis.z + work->mVolumeSize * JMASCos(theta)); + work->mVelOmni.mul(work->mVolumePos, work->mGlobalScl); } /* 8027BB18-8027BB4C 276458 0034+00 0/0 1/1 0/0 .text __ct__16JPADynamicsBlockFPCUc */ @@ -206,10 +171,6 @@ void JPADynamicsBlock::init() { /* 8027BBE8-8027BDEC 276528 0204+00 0/0 1/1 0/0 .text * create__16JPADynamicsBlockFP18JPAEmitterWorkData */ - -#ifdef NONMATCHING - -// literal only void JPADynamicsBlock::create(JPAEmitterWorkData* work) { if (work->mpEmtr->checkStatus(JPAEmtrStts_RateStepEmit)) { s32 emitCount; @@ -263,11 +224,3 @@ void JPADynamicsBlock::create(JPAEmitterWorkData* work) { work->mpEmtr->clearStatus(JPAEmtrStts_FirstEmit); } - -#else - -void JPADynamicsBlock::create(JPAEmitterWorkData* param_0) { - // NONMATCHING -} - -#endif \ No newline at end of file diff --git a/src/JSystem/JParticle/JPAEmitterManager.cpp b/src/JSystem/JParticle/JPAEmitterManager.cpp index 34719c53abb..f15bab2c4fb 100644 --- a/src/JSystem/JParticle/JPAEmitterManager.cpp +++ b/src/JSystem/JParticle/JPAEmitterManager.cpp @@ -4,72 +4,14 @@ // #include "JSystem/JParticle/JPAEmitterManager.h" +#include "JSystem/JKernel/JKRHeap.h" #include "JSystem/JParticle/JPAEmitter.h" +#include "JSystem/JParticle/JPAParticle.h" #include "JSystem/JParticle/JPAResourceManager.h" #include "dolphin/gx.h" -// -// Types: -// - -// -// Forward References: -// - -extern "C" void __ct__17JPAEmitterManagerFUlUlP7JKRHeapUcUc(); -extern "C" void func_8027DEBC(); -extern "C" void calc__17JPAEmitterManagerFUc(); -extern "C" void draw__17JPAEmitterManagerFPC11JPADrawInfoUc(); -extern "C" void forceDeleteAllEmitter__17JPAEmitterManagerFv(); -extern "C" void forceDeleteGroupEmitter__17JPAEmitterManagerFUc(); -extern "C" void forceDeleteEmitter__17JPAEmitterManagerFP14JPABaseEmitter(); -extern "C" void entryResourceManager__17JPAEmitterManagerFP18JPAResourceManagerUc(); -extern "C" void clearResourceManager__17JPAEmitterManagerFUc(); -extern "C" void calcYBBCam__17JPAEmitterManagerFv(); -extern "C" void func_8027E51C(void* _this); -extern "C" void func_8027E54C(void* _this); -extern "C" void func_8027E588(void* _this); -extern "C" void func_8027E598(void* _this); -extern "C" void __dt__14JPABaseEmitterFv(); -extern "C" void __ct__14JPABaseEmitterFv(); - -// -// External References: -// - -extern "C" void getResource__18JPAResourceManagerCFUs(); -extern "C" void calc__11JPAResourceFP18JPAEmitterWorkDataP14JPABaseEmitter(); -extern "C" void draw__11JPAResourceFP18JPAEmitterWorkDataP14JPABaseEmitter(); -extern "C" void init__14JPABaseEmitterFP17JPAEmitterManagerP11JPAResource(); -extern "C" void deleteAllParticle__14JPABaseEmitterFv(); -extern "C" void* __nw__FUlP7JKRHeapi(); -extern "C" void* __nwa__FUlP7JKRHeapi(); -extern "C" void __dl__FPv(); -extern "C" void __ct__10JSUPtrLinkFPv(); -extern "C" void __dt__10JSUPtrLinkFv(); -extern "C" void __dt__10JSUPtrListFv(); -extern "C" void initiate__10JSUPtrListFv(); -extern "C" void append__10JSUPtrListFP10JSUPtrLink(); -extern "C" void prepend__10JSUPtrListFP10JSUPtrLink(); -extern "C" void remove__10JSUPtrListFP10JSUPtrLink(); -extern "C" void __construct_new_array(); -extern "C" void _savegpr_24(); -extern "C" void _savegpr_26(); -extern "C" void _savegpr_27(); -extern "C" void _savegpr_29(); -extern "C" void _restgpr_24(); -extern "C" void _restgpr_26(); -extern "C" void _restgpr_27(); -extern "C" void _restgpr_29(); - -// -// Declarations: -// - /* 8027DCA0-8027DEBC 2785E0 021C+00 0/0 1/1 0/0 .text __ct__17JPAEmitterManagerFUlUlP7JKRHeapUcUc */ -// template ctors are at the end of the TU for some reason -#ifdef NONMATCHING JPAEmitterManager::JPAEmitterManager(u32 ptclMax, u32 emtrMax, JKRHeap* pHeap, u8 grpMax, u8 resMax) { mEmtrMax = emtrMax; @@ -93,12 +35,6 @@ JPAEmitterManager::JPAEmitterManager(u32 ptclMax, u32 emtrMax, JKRHeap* pHeap, u mpWorkData = new (pHeap, 0) JPAEmitterWorkData(); } -#else -JPAEmitterManager::JPAEmitterManager(u32 param_0, u32 param_1, JKRHeap* param_2, u8 param_3, - u8 param_4) { - // NONMATCHING -} -#endif /* 8027DEBC-8027DFA0 2787FC 00E4+00 0/0 3/3 0/0 .text * createSimpleEmitterID__17JPAEmitterManagerFRCQ29JGeometry8TVec3UsUcUcP18JPAEmitterCallBackP19JPAParticleCallBack @@ -222,8 +158,6 @@ void JPAEmitterManager::clearResourceManager(u8 resMgrID) { mpResMgrAry[resMgrID] = NULL; } -/* ############################################################################################## */ - /* 8027E3F4-8027E51C 278D34 0128+00 1/1 0/0 0/0 .text calcYBBCam__17JPAEmitterManagerFv */ void JPAEmitterManager::calcYBBCam() { @@ -243,31 +177,3 @@ void JPAEmitterManager::calcYBBCam() { mpWorkData->mYBBCamMtx[2][2] = v.y; mpWorkData->mYBBCamMtx[2][3] = mpWorkData->mPosCamMtx[2][3]; } - -/* 8027E51C-8027E54C 278E5C 0030+00 1/1 0/0 0/0 .text __ct__25JSUList<14JPABaseEmitter>Fv - */ -extern "C" void func_8027E51C(void* _this) { - // NONMATCHING -} - -/* 8027E54C-8027E588 278E8C 003C+00 1/1 0/0 0/0 .text __dt__26JPANode<15JPABaseParticle>Fv */ -extern "C" void func_8027E54C(void* _this) { - // NONMATCHING -} - -/* 8027E588-8027E598 278EC8 0010+00 1/1 0/0 0/0 .text __ct__26JPANode<15JPABaseParticle>Fv */ -extern "C" void func_8027E588(void* _this) { - // NONMATCHING -} - -/* 8027E598-8027E5EC 278ED8 0054+00 1/1 0/0 0/0 .text __dt__25JSUList<14JPABaseEmitter>Fv - */ -extern "C" void func_8027E598(void* _this) { - // NONMATCHING -} - -/* 8027E5EC-8027E64C 278F2C 0060+00 1/1 0/0 0/0 .text __dt__14JPABaseEmitterFv */ -JPABaseEmitter::~JPABaseEmitter() {} - -/* 8027E64C-8027E6A4 278F8C 0058+00 1/1 0/0 0/0 .text __ct__14JPABaseEmitterFv */ -JPABaseEmitter::JPABaseEmitter() : mLink(this) {} \ No newline at end of file diff --git a/src/JSystem/JParticle/JPAExtraShape.cpp b/src/JSystem/JParticle/JPAExtraShape.cpp index 350c5c85374..2c269a31063 100644 --- a/src/JSystem/JParticle/JPAExtraShape.cpp +++ b/src/JSystem/JParticle/JPAExtraShape.cpp @@ -8,11 +8,6 @@ #include "JSystem/JParticle/JPAParticle.h" #include "JSystem/JParticle/JPAEmitter.h" #include "dolphin/os.h" -#include "dolphin/types.h" - -// -// Types: -// /* 8027A918-8027A990 275258 0078+00 0/0 1/1 0/0 .text * JPACalcScaleX__FP18JPAEmitterWorkDataP15JPABaseParticle */ @@ -154,4 +149,4 @@ void JPAExtraShape::init() { } else { mScaleDecRateX = mScaleDecRateY = 1.0f; } -} \ No newline at end of file +} diff --git a/src/JSystem/JParticle/JPAFieldBlock.cpp b/src/JSystem/JParticle/JPAFieldBlock.cpp index 4c60eb14485..244d888e15b 100644 --- a/src/JSystem/JParticle/JPAFieldBlock.cpp +++ b/src/JSystem/JParticle/JPAFieldBlock.cpp @@ -4,443 +4,299 @@ // #include "JSystem/JParticle/JPAFieldBlock.h" -#include "dol2asm.h" - -// -// Types: -// - -struct JPAEmitterWorkData {}; - -struct JKRHeap {}; - -struct JPAFieldBlock { - /* 8027D088 */ JPAFieldBlock(u8 const*, JKRHeap*); - /* 8027D0C0 */ void init(JKRHeap*); -}; - -struct JPABaseParticle {}; - -struct JPAFieldVortex { - /* 8027C56C */ void prepare(JPAEmitterWorkData*, JPAFieldBlock*); - /* 8027C674 */ void calc(JPAEmitterWorkData*, JPAFieldBlock*, JPABaseParticle*); - /* 8027D564 */ ~JPAFieldVortex(); -}; - -struct JPAFieldSpin { - /* 8027CE64 */ void prepare(JPAEmitterWorkData*, JPAFieldBlock*); - /* 8027CFA8 */ void calc(JPAEmitterWorkData*, JPAFieldBlock*, JPABaseParticle*); - /* 8027D3F4 */ ~JPAFieldSpin(); -}; - -struct JPAFieldRandom { - /* 8027CCCC */ void calc(JPAEmitterWorkData*, JPAFieldBlock*, JPABaseParticle*); - /* 8027D4AC */ ~JPAFieldRandom(); -}; - -struct JPAFieldNewton { - /* 8027C36C */ void prepare(JPAEmitterWorkData*, JPAFieldBlock*); - /* 8027C3E0 */ void calc(JPAEmitterWorkData*, JPAFieldBlock*, JPABaseParticle*); - /* 8027D5C0 */ ~JPAFieldNewton(); -}; - -struct JPAFieldMagnet { - /* 8027C24C */ void prepare(JPAEmitterWorkData*, JPAFieldBlock*); - /* 8027C29C */ void calc(JPAEmitterWorkData*, JPAFieldBlock*, JPABaseParticle*); - /* 8027D61C */ ~JPAFieldMagnet(); -}; - -struct JPAFieldGravity { - /* 8027BFB4 */ void prepare(JPAEmitterWorkData*, JPAFieldBlock*); - /* 8027C054 */ void calc(JPAEmitterWorkData*, JPAFieldBlock*, JPABaseParticle*); - /* 8027D6D4 */ ~JPAFieldGravity(); -}; - -struct JPAFieldDrag { - /* 8027CDE4 */ void calc(JPAEmitterWorkData*, JPAFieldBlock*, JPABaseParticle*); - /* 8027D450 */ ~JPAFieldDrag(); -}; - -struct JPAFieldConvection { - /* 8027C814 */ void prepare(JPAEmitterWorkData*, JPAFieldBlock*); - /* 8027CA94 */ void calc(JPAEmitterWorkData*, JPAFieldBlock*, JPABaseParticle*); - /* 8027D508 */ ~JPAFieldConvection(); -}; - -struct JPAFieldBase { - /* 80276A8C */ void prepare(JPAEmitterWorkData*, JPAFieldBlock*); - /* 8027BDEC */ void calcAffect(JPAFieldBlock*, JPABaseParticle*); - /* 8027BF18 */ void calcFadeAffect(JPAFieldBlock*, f32) const; - /* 8027D3AC */ ~JPAFieldBase(); -}; - -struct JPAFieldAir { - /* 8027C07C */ void prepare(JPAEmitterWorkData*, JPAFieldBlock*); - /* 8027C1B8 */ void calc(JPAEmitterWorkData*, JPAFieldBlock*, JPABaseParticle*); - /* 8027D678 */ ~JPAFieldAir(); -}; - -// -// Forward References: -// - -extern "C" void calcAffect__12JPAFieldBaseFP13JPAFieldBlockP15JPABaseParticle(); -extern "C" void calcFadeAffect__12JPAFieldBaseCFP13JPAFieldBlockf(); -extern "C" void prepare__15JPAFieldGravityFP18JPAEmitterWorkDataP13JPAFieldBlock(); -extern "C" void calc__15JPAFieldGravityFP18JPAEmitterWorkDataP13JPAFieldBlockP15JPABaseParticle(); -extern "C" void prepare__11JPAFieldAirFP18JPAEmitterWorkDataP13JPAFieldBlock(); -extern "C" void calc__11JPAFieldAirFP18JPAEmitterWorkDataP13JPAFieldBlockP15JPABaseParticle(); -extern "C" void prepare__14JPAFieldMagnetFP18JPAEmitterWorkDataP13JPAFieldBlock(); -extern "C" void calc__14JPAFieldMagnetFP18JPAEmitterWorkDataP13JPAFieldBlockP15JPABaseParticle(); -extern "C" void prepare__14JPAFieldNewtonFP18JPAEmitterWorkDataP13JPAFieldBlock(); -extern "C" void calc__14JPAFieldNewtonFP18JPAEmitterWorkDataP13JPAFieldBlockP15JPABaseParticle(); -extern "C" void prepare__14JPAFieldVortexFP18JPAEmitterWorkDataP13JPAFieldBlock(); -extern "C" void calc__14JPAFieldVortexFP18JPAEmitterWorkDataP13JPAFieldBlockP15JPABaseParticle(); -extern "C" void prepare__18JPAFieldConvectionFP18JPAEmitterWorkDataP13JPAFieldBlock(); -extern "C" void -calc__18JPAFieldConvectionFP18JPAEmitterWorkDataP13JPAFieldBlockP15JPABaseParticle(); -extern "C" void calc__14JPAFieldRandomFP18JPAEmitterWorkDataP13JPAFieldBlockP15JPABaseParticle(); -extern "C" void calc__12JPAFieldDragFP18JPAEmitterWorkDataP13JPAFieldBlockP15JPABaseParticle(); -extern "C" void prepare__12JPAFieldSpinFP18JPAEmitterWorkDataP13JPAFieldBlock(); -extern "C" void calc__12JPAFieldSpinFP18JPAEmitterWorkDataP13JPAFieldBlockP15JPABaseParticle(); -extern "C" void __ct__13JPAFieldBlockFPCUcP7JKRHeap(); -extern "C" void init__13JPAFieldBlockFP7JKRHeap(); -extern "C" void __dt__12JPAFieldBaseFv(); -extern "C" void __dt__12JPAFieldSpinFv(); -extern "C" void __dt__12JPAFieldDragFv(); -extern "C" void __dt__14JPAFieldRandomFv(); -extern "C" void __dt__18JPAFieldConvectionFv(); -extern "C" void __dt__14JPAFieldVortexFv(); -extern "C" void __dt__14JPAFieldNewtonFv(); -extern "C" void __dt__14JPAFieldMagnetFv(); -extern "C" void __dt__11JPAFieldAirFv(); -extern "C" void __dt__15JPAFieldGravityFv(); - -// -// External References: -// - -extern "C" void prepare__12JPAFieldBaseFP18JPAEmitterWorkDataP13JPAFieldBlock(); -extern "C" void* __nw__FUlP7JKRHeapi(); -extern "C" void __dl__FPv(); -extern "C" void PSMTXRotAxisRad(); -extern "C" void PSMTXMultVecSR(); -extern "C" void PSVECMag(); -extern "C" void PSVECCrossProduct(); -extern "C" void _savegpr_29(); -extern "C" void _restgpr_29(); -extern "C" extern u32 __float_epsilon; - -// -// Declarations: -// +#include "JSystem/JKernel/JKRHeap.h" +#include "JSystem/JParticle/JPAEmitter.h" +#include "JSystem/JParticle/JPAParticle.h" /* 8027BDEC-8027BF18 27672C 012C+00 8/8 0/0 0/0 .text * calcAffect__12JPAFieldBaseFP13JPAFieldBlockP15JPABaseParticle */ -void JPAFieldBase::calcAffect(JPAFieldBlock* param_0, JPABaseParticle* param_1) { - // NONMATCHING +void JPAFieldBase::calcAffect(JPAFieldBlock* block, JPABaseParticle* ptcl) { + JGeometry::TVec3 vec = mAccel; + if (!ptcl->checkStatus(4) && block->checkStatus(0x78)) { + vec.scale(calcFadeAffect(block, ptcl->mTime)); + } + + switch (block->getAddType()) { + case 0: + ptcl->mVelType0.add(vec); + break; + case 1: + ptcl->mVelType1.add(vec); + break; + case 2: + ptcl->mVelType2.add(vec); + break; + } } -/* ############################################################################################## */ -/* 80455338-8045533C 003938 0004+00 6/6 0/0 0/0 .sdata2 @2353 */ -SECTION_SDATA2 static f32 lit_2353 = 1.0f; - -/* 8045533C-80455340 00393C 0004+00 11/11 0/0 0/0 .sdata2 @2354 */ -SECTION_SDATA2 static u8 lit_2354[4] = { - 0x00, - 0x00, - 0x00, - 0x00, -}; - /* 8027BF18-8027BFB4 276858 009C+00 2/2 0/0 0/0 .text * calcFadeAffect__12JPAFieldBaseCFP13JPAFieldBlockf */ -void JPAFieldBase::calcFadeAffect(JPAFieldBlock* param_0, f32 param_1) const { - // NONMATCHING +f32 JPAFieldBase::calcFadeAffect(JPAFieldBlock* block, f32 time) const { + f32 fade = 1.0f; + if ((block->checkStatus(8) && time < block->getEnTime()) + || (block->checkStatus(0x10) && time >= block->getDisTime())) + { + fade = 0.0f; + } else if (block->checkStatus(0x40) && time >= block->getFadeOutTime()) { + fade = (block->getDisTime() - time) * block->getFadeOutRate(); + } else if (block->checkStatus(0x20) && time < block->getFadeInTime()) { + fade = (time - block->getEnTime()) * block->getFadeInRate(); + } + return fade; } /* 8027BFB4-8027C054 2768F4 00A0+00 1/0 0/0 0/0 .text * prepare__15JPAFieldGravityFP18JPAEmitterWorkDataP13JPAFieldBlock */ -void JPAFieldGravity::prepare(JPAEmitterWorkData* param_0, JPAFieldBlock* param_1) { - // NONMATCHING +void JPAFieldGravity::prepare(JPAEmitterWorkData* work, JPAFieldBlock* block) { + if (block->checkStatus(2)) { + mAccel.scale(block->getMag(), block->getDir()); + } else { + MTXMultVecSR(work->mRotationMtx, &block->getDir(), &mAccel); + mAccel.scale(block->getMag()); + } } /* 8027C054-8027C07C 276994 0028+00 1/0 0/0 0/0 .text * calc__15JPAFieldGravityFP18JPAEmitterWorkDataP13JPAFieldBlockP15JPABaseParticle */ -void JPAFieldGravity::calc(JPAEmitterWorkData* param_0, JPAFieldBlock* param_1, - JPABaseParticle* param_2) { - // NONMATCHING +void JPAFieldGravity::calc(JPAEmitterWorkData* work, JPAFieldBlock* block, JPABaseParticle* ptcl) { + calcAffect(block, ptcl); } -/* ############################################################################################## */ -/* 80455340-80455344 003940 0004+00 8/8 0/0 0/0 .sdata2 @2459 */ -SECTION_SDATA2 static f32 lit_2459 = 32.0f; - -/* 80455344-80455348 003944 0004+00 9/9 0/0 0/0 .sdata2 @2460 */ -SECTION_SDATA2 static f32 lit_2460 = 0.5f; - -/* 80455348-8045534C 003948 0004+00 8/8 0/0 0/0 .sdata2 @2461 */ -SECTION_SDATA2 static f32 lit_2461 = 3.0f; - /* 8027C07C-8027C1B8 2769BC 013C+00 1/0 0/0 0/0 .text * prepare__11JPAFieldAirFP18JPAEmitterWorkDataP13JPAFieldBlock */ -void JPAFieldAir::prepare(JPAEmitterWorkData* param_0, JPAFieldBlock* param_1) { - // NONMATCHING +void JPAFieldAir::prepare(JPAEmitterWorkData* work, JPAFieldBlock* block) { + JGeometry::TVec3 vec; + vec.normalize(block->getDir()); + if (block->checkStatus(2)) { + mAccel.scale(block->getMag(), vec); + } else { + MTXMultVecSR(work->mRotationMtx, vec, mAccel); + mAccel.scale(block->getMag()); + } } /* 8027C1B8-8027C24C 276AF8 0094+00 1/0 0/0 0/0 .text * calc__11JPAFieldAirFP18JPAEmitterWorkDataP13JPAFieldBlockP15JPABaseParticle */ -void JPAFieldAir::calc(JPAEmitterWorkData* param_0, JPAFieldBlock* param_1, - JPABaseParticle* param_2) { - // NONMATCHING +void JPAFieldAir::calc(JPAEmitterWorkData* work, JPAFieldBlock* block, JPABaseParticle* ptcl) { + calcAffect(block, ptcl); + if (block->checkStatus(4)) { + f32 len = ptcl->mVelType1.length(); + if (len > block->getMagRndm()) { + ptcl->mVelType1.scale(block->getMagRndm() / len); + } + } } /* 8027C24C-8027C29C 276B8C 0050+00 1/0 0/0 0/0 .text * prepare__14JPAFieldMagnetFP18JPAEmitterWorkDataP13JPAFieldBlock */ -void JPAFieldMagnet::prepare(JPAEmitterWorkData* param_0, JPAFieldBlock* param_1) { - // NONMATCHING +void JPAFieldMagnet::prepare(JPAEmitterWorkData* work, JPAFieldBlock* block) { + mDir.sub(block->getPos(), work->mEmitterPos); + MTXMultVecSR(work->mRotationMtx, &mDir, &mDir); } /* 8027C29C-8027C36C 276BDC 00D0+00 1/0 0/0 0/0 .text * calc__14JPAFieldMagnetFP18JPAEmitterWorkDataP13JPAFieldBlockP15JPABaseParticle */ -void JPAFieldMagnet::calc(JPAEmitterWorkData* param_0, JPAFieldBlock* param_1, - JPABaseParticle* param_2) { - // NONMATCHING +void JPAFieldMagnet::calc(JPAEmitterWorkData* work, JPAFieldBlock* block, JPABaseParticle* ptcl) { + mAccel.sub(mDir, ptcl->mLocalPosition); + mAccel.setLength(block->getMag()); + calcAffect(block, ptcl); } /* 8027C36C-8027C3E0 276CAC 0074+00 1/0 0/0 0/0 .text * prepare__14JPAFieldNewtonFP18JPAEmitterWorkDataP13JPAFieldBlock */ -void JPAFieldNewton::prepare(JPAEmitterWorkData* param_0, JPAFieldBlock* param_1) { - // NONMATCHING +void JPAFieldNewton::prepare(JPAEmitterWorkData* work, JPAFieldBlock* block) { + mDir.sub(block->getPos(), work->mEmitterPos); + MTXMultVecSR(work->mRotationMtx, &mDir, &mDir); + mCutoff = block->getVal1() * block->getVal1(); } -/* ############################################################################################## */ -/* 8045534C-80455350 00394C 0004+00 1/1 0/0 0/0 .sdata2 @2656 */ -SECTION_SDATA2 static f32 lit_2656 = 10.0f; - /* 8027C3E0-8027C56C 276D20 018C+00 1/0 0/0 0/0 .text * calc__14JPAFieldNewtonFP18JPAEmitterWorkDataP13JPAFieldBlockP15JPABaseParticle */ -void JPAFieldNewton::calc(JPAEmitterWorkData* param_0, JPAFieldBlock* param_1, - JPABaseParticle* param_2) { - // NONMATCHING +void JPAFieldNewton::calc(JPAEmitterWorkData* work, JPAFieldBlock* block, JPABaseParticle* ptcl) { + mAccel.sub(mDir, ptcl->mLocalPosition); + f32 len_sq = mAccel.squared(); + if (len_sq > mCutoff) { + mAccel.setLength(mCutoff * (block->getMag() * 10.0f) / len_sq); + } else { + mAccel.setLength(block->getMag() * 10.0f); + } + calcAffect(block, ptcl); } /* 8027C56C-8027C674 276EAC 0108+00 1/0 0/0 0/0 .text * prepare__14JPAFieldVortexFP18JPAEmitterWorkDataP13JPAFieldBlock */ -void JPAFieldVortex::prepare(JPAEmitterWorkData* param_0, JPAFieldBlock* param_1) { - // NONMATCHING +void JPAFieldVortex::prepare(JPAEmitterWorkData* work, JPAFieldBlock* block) { + MTXMultVecSR(work->mGlobalRot, &block->getDir(), &field_0x10); + field_0x10.normalize(); + field_0x1c = block->getPos().z * block->getPos().z; + field_0x20 = 1.0f / field_0x1c; } /* 8027C674-8027C814 276FB4 01A0+00 1/0 0/0 0/0 .text * calc__14JPAFieldVortexFP18JPAEmitterWorkDataP13JPAFieldBlockP15JPABaseParticle */ -void JPAFieldVortex::calc(JPAEmitterWorkData* param_0, JPAFieldBlock* param_1, - JPABaseParticle* param_2) { - // NONMATCHING +// NONMATCHING regalloc. may need to rewrite dot in a way that doesn't break Z2Audience::calcPitchDoppler_ +void JPAFieldVortex::calc(JPAEmitterWorkData* work, JPAFieldBlock* block, JPABaseParticle* ptcl) { + JGeometry::TVec3 vec; + vec.scale(field_0x10.dot(ptcl->mLocalPosition), field_0x10); + vec.sub(ptcl->mLocalPosition, vec); + f32 mag = vec.squared(); + if (mag > field_0x1c) { + mag = block->getMagRndm(); + } else { + mag *= field_0x20; + mag = (1.0f - mag) * block->getMag() + mag * block->getMagRndm(); + } + vec.normalize(); + mAccel.cross(vec, field_0x10); + mAccel.scale(mag); + calcAffect(block, ptcl); } /* 8027C814-8027CA94 277154 0280+00 1/0 0/0 0/0 .text * prepare__18JPAFieldConvectionFP18JPAEmitterWorkDataP13JPAFieldBlock */ -void JPAFieldConvection::prepare(JPAEmitterWorkData* param_0, JPAFieldBlock* param_1) { - // NONMATCHING +void JPAFieldConvection::prepare(JPAEmitterWorkData* work, JPAFieldBlock* block) { + JGeometry::TVec3 vec1, vec2; + 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, &vec2, &field_0x28); + field_0x10.normalize(); + field_0x1c.normalize(); + field_0x28.normalize(); } /* 8027CA94-8027CCCC 2773D4 0238+00 1/0 0/0 0/0 .text * calc__18JPAFieldConvectionFP18JPAEmitterWorkDataP13JPAFieldBlockP15JPABaseParticle */ -void JPAFieldConvection::calc(JPAEmitterWorkData* param_0, JPAFieldBlock* param_1, - JPABaseParticle* param_2) { - // NONMATCHING +// NONMATCHING regalloc problems with TVec3 inlines +void JPAFieldConvection::calc(JPAEmitterWorkData* work, JPAFieldBlock* block, + JPABaseParticle* ptcl) { + JGeometry::TVec3 vec1, vec2, vec3; + vec1.scale(field_0x10.dot(ptcl->mLocalPosition), field_0x10); + vec3.scale(field_0x28.dot(ptcl->mLocalPosition), field_0x28); + vec1.add(vec3); + vec1.setLength(vec1, block->getVal1()); + vec2.sub(ptcl->mLocalPosition, vec1); + vec3.cross(field_0x1c, vec1); + mAccel.cross(vec3, vec2); + mAccel.setLength(block->getMag()); + calcAffect(block, ptcl); } /* 8027CCCC-8027CDE4 27760C 0118+00 1/0 0/0 0/0 .text * calc__14JPAFieldRandomFP18JPAEmitterWorkDataP13JPAFieldBlockP15JPABaseParticle */ -void JPAFieldRandom::calc(JPAEmitterWorkData* param_0, JPAFieldBlock* param_1, - JPABaseParticle* param_2) { - // NONMATCHING +// NONMATCHING missing clrlwi +void JPAFieldRandom::calc(JPAEmitterWorkData* work, JPAFieldBlock* block, JPABaseParticle* ptcl) { + if (ptcl->mAge == 0 || (block->getCycle() != 0 && ptcl->mAge % block->getCycle() == 0)) { + JPABaseEmitter* emtr = work->mpEmtr; + mAccel.set(emtr->get_r_zh(), emtr->get_r_zh(), emtr->get_r_zh()); + mAccel.scale(block->getMag()); + calcAffect(block, ptcl); + } } /* 8027CDE4-8027CE64 277724 0080+00 1/0 0/0 0/0 .text * calc__12JPAFieldDragFP18JPAEmitterWorkDataP13JPAFieldBlockP15JPABaseParticle */ -void JPAFieldDrag::calc(JPAEmitterWorkData* param_0, JPAFieldBlock* param_1, - JPABaseParticle* param_2) { - // NONMATCHING +void JPAFieldDrag::calc(JPAEmitterWorkData* work, JPAFieldBlock* block, JPABaseParticle* ptcl) { + if (!ptcl->checkStatus(4)) { + f32 fade = calcFadeAffect(block, ptcl->mTime); + ptcl->mDrag *= 1.0f - fade * (1.0f - block->getMag()); + } else { + ptcl->mDrag *= block->getMag(); + } } /* 8027CE64-8027CFA8 2777A4 0144+00 1/0 0/0 0/0 .text * prepare__12JPAFieldSpinFP18JPAEmitterWorkDataP13JPAFieldBlock */ -void JPAFieldSpin::prepare(JPAEmitterWorkData* param_0, JPAFieldBlock* param_1) { - // NONMATCHING +void JPAFieldSpin::prepare(JPAEmitterWorkData* work, JPAFieldBlock* block) { + JGeometry::TVec3 axis; + MTXMultVecSR(work->mGlobalRot, &block->getDir(), &axis); + axis.normalize(); + Mtx mtx; + MTXRotAxisRad(mtx, &axis, block->getMag()); + field_0x10.set(mtx[0][0], mtx[1][0], mtx[2][0]); + field_0x1c.set(mtx[0][1], mtx[1][1], mtx[2][1]); + field_0x28.set(mtx[0][2], mtx[1][2], mtx[2][2]); } /* 8027CFA8-8027D088 2778E8 00E0+00 1/0 0/0 0/0 .text * calc__12JPAFieldSpinFP18JPAEmitterWorkDataP13JPAFieldBlockP15JPABaseParticle */ -void JPAFieldSpin::calc(JPAEmitterWorkData* param_0, JPAFieldBlock* param_1, - JPABaseParticle* param_2) { - // NONMATCHING +void JPAFieldSpin::calc(JPAEmitterWorkData* work, JPAFieldBlock* block, JPABaseParticle* ptcl) { + Mtx mtx; + mtx[0][0] = field_0x10.x; + mtx[1][0] = field_0x10.y; + mtx[2][0] = field_0x10.z; + mtx[0][1] = field_0x1c.x; + mtx[1][1] = field_0x1c.y; + mtx[2][1] = field_0x1c.z; + mtx[0][2] = field_0x28.x; + mtx[1][2] = field_0x28.y; + mtx[2][2] = field_0x28.z; + mtx[0][3] = mtx[1][3] = mtx[2][3] = 0.0f; + Vec vec; + MTXMultVecSR(mtx, &ptcl->mLocalPosition, &vec); + mAccel.set(vec.x - ptcl->mLocalPosition.x, vec.y - ptcl->mLocalPosition.y, + vec.z - ptcl->mLocalPosition.z); + calcAffect(block, ptcl); } /* 8027D088-8027D0C0 2779C8 0038+00 0/0 1/1 0/0 .text __ct__13JPAFieldBlockFPCUcP7JKRHeap */ -JPAFieldBlock::JPAFieldBlock(u8 const* param_0, JKRHeap* param_1) { - // NONMATCHING +JPAFieldBlock::JPAFieldBlock(u8 const* data, JKRHeap* heap) + : mpData((const JPAFieldBlockData*)data) { + init(heap); } -/* ############################################################################################## */ -/* 803C44A8-803C44CC -00001 0024+00 1/1 0/0 0/0 .data @3259 */ -SECTION_DATA static void* lit_3259[9] = { - (void*)(((char*)init__13JPAFieldBlockFP7JKRHeap) + 0xFC), - (void*)(((char*)init__13JPAFieldBlockFP7JKRHeap) + 0x130), - (void*)(((char*)init__13JPAFieldBlockFP7JKRHeap) + 0x164), - (void*)(((char*)init__13JPAFieldBlockFP7JKRHeap) + 0x198), - (void*)(((char*)init__13JPAFieldBlockFP7JKRHeap) + 0x1CC), - (void*)(((char*)init__13JPAFieldBlockFP7JKRHeap) + 0x200), - (void*)(((char*)init__13JPAFieldBlockFP7JKRHeap) + 0x234), - (void*)(((char*)init__13JPAFieldBlockFP7JKRHeap) + 0x268), - (void*)(((char*)init__13JPAFieldBlockFP7JKRHeap) + 0x29C), -}; - -/* 803C44CC-803C44E0 0215EC 0014+00 11/11 0/0 0/0 .data __vt__12JPAFieldBase */ -SECTION_DATA extern void* __vt__12JPAFieldBase[5] = { - (void*)NULL /* RTTI */, - (void*)NULL, - (void*)__dt__12JPAFieldBaseFv, - (void*)prepare__12JPAFieldBaseFP18JPAEmitterWorkDataP13JPAFieldBlock, - (void*)NULL, -}; - -/* 803C44E0-803C44F4 021600 0014+00 2/2 0/0 0/0 .data __vt__12JPAFieldSpin */ -SECTION_DATA extern void* __vt__12JPAFieldSpin[5] = { - (void*)NULL /* RTTI */, - (void*)NULL, - (void*)__dt__12JPAFieldSpinFv, - (void*)prepare__12JPAFieldSpinFP18JPAEmitterWorkDataP13JPAFieldBlock, - (void*)calc__12JPAFieldSpinFP18JPAEmitterWorkDataP13JPAFieldBlockP15JPABaseParticle, -}; - -/* 803C44F4-803C4508 021614 0014+00 2/2 0/0 0/0 .data __vt__12JPAFieldDrag */ -SECTION_DATA extern void* __vt__12JPAFieldDrag[5] = { - (void*)NULL /* RTTI */, - (void*)NULL, - (void*)__dt__12JPAFieldDragFv, - (void*)prepare__12JPAFieldBaseFP18JPAEmitterWorkDataP13JPAFieldBlock, - (void*)calc__12JPAFieldDragFP18JPAEmitterWorkDataP13JPAFieldBlockP15JPABaseParticle, -}; - -/* 803C4508-803C451C 021628 0014+00 2/2 0/0 0/0 .data __vt__14JPAFieldRandom */ -SECTION_DATA extern void* __vt__14JPAFieldRandom[5] = { - (void*)NULL /* RTTI */, - (void*)NULL, - (void*)__dt__14JPAFieldRandomFv, - (void*)prepare__12JPAFieldBaseFP18JPAEmitterWorkDataP13JPAFieldBlock, - (void*)calc__14JPAFieldRandomFP18JPAEmitterWorkDataP13JPAFieldBlockP15JPABaseParticle, -}; - -/* 803C451C-803C4530 02163C 0014+00 2/2 0/0 0/0 .data __vt__18JPAFieldConvection */ -SECTION_DATA extern void* __vt__18JPAFieldConvection[5] = { - (void*)NULL /* RTTI */, - (void*)NULL, - (void*)__dt__18JPAFieldConvectionFv, - (void*)prepare__18JPAFieldConvectionFP18JPAEmitterWorkDataP13JPAFieldBlock, - (void*)calc__18JPAFieldConvectionFP18JPAEmitterWorkDataP13JPAFieldBlockP15JPABaseParticle, -}; - -/* 803C4530-803C4544 021650 0014+00 2/2 0/0 0/0 .data __vt__14JPAFieldVortex */ -SECTION_DATA extern void* __vt__14JPAFieldVortex[5] = { - (void*)NULL /* RTTI */, - (void*)NULL, - (void*)__dt__14JPAFieldVortexFv, - (void*)prepare__14JPAFieldVortexFP18JPAEmitterWorkDataP13JPAFieldBlock, - (void*)calc__14JPAFieldVortexFP18JPAEmitterWorkDataP13JPAFieldBlockP15JPABaseParticle, -}; - -/* 803C4544-803C4558 021664 0014+00 2/2 0/0 0/0 .data __vt__14JPAFieldNewton */ -SECTION_DATA extern void* __vt__14JPAFieldNewton[5] = { - (void*)NULL /* RTTI */, - (void*)NULL, - (void*)__dt__14JPAFieldNewtonFv, - (void*)prepare__14JPAFieldNewtonFP18JPAEmitterWorkDataP13JPAFieldBlock, - (void*)calc__14JPAFieldNewtonFP18JPAEmitterWorkDataP13JPAFieldBlockP15JPABaseParticle, -}; - -/* 803C4558-803C456C 021678 0014+00 2/2 0/0 0/0 .data __vt__14JPAFieldMagnet */ -SECTION_DATA extern void* __vt__14JPAFieldMagnet[5] = { - (void*)NULL /* RTTI */, - (void*)NULL, - (void*)__dt__14JPAFieldMagnetFv, - (void*)prepare__14JPAFieldMagnetFP18JPAEmitterWorkDataP13JPAFieldBlock, - (void*)calc__14JPAFieldMagnetFP18JPAEmitterWorkDataP13JPAFieldBlockP15JPABaseParticle, -}; - -/* 803C456C-803C4580 02168C 0014+00 2/2 0/0 0/0 .data __vt__11JPAFieldAir */ -SECTION_DATA extern void* __vt__11JPAFieldAir[5] = { - (void*)NULL /* RTTI */, - (void*)NULL, - (void*)__dt__11JPAFieldAirFv, - (void*)prepare__11JPAFieldAirFP18JPAEmitterWorkDataP13JPAFieldBlock, - (void*)calc__11JPAFieldAirFP18JPAEmitterWorkDataP13JPAFieldBlockP15JPABaseParticle, -}; - -/* 803C4580-803C4598 0216A0 0014+04 2/2 0/0 0/0 .data __vt__15JPAFieldGravity */ -SECTION_DATA extern void* __vt__15JPAFieldGravity[5 + 1 /* padding */] = { - (void*)NULL /* RTTI */, - (void*)NULL, - (void*)__dt__15JPAFieldGravityFv, - (void*)prepare__15JPAFieldGravityFP18JPAEmitterWorkDataP13JPAFieldBlock, - (void*)calc__15JPAFieldGravityFP18JPAEmitterWorkDataP13JPAFieldBlockP15JPABaseParticle, - /* padding */ - NULL, -}; - /* 8027D0C0-8027D3AC 277A00 02EC+00 2/1 0/0 0/0 .text init__13JPAFieldBlockFP7JKRHeap */ -void JPAFieldBlock::init(JKRHeap* param_0) { - // NONMATCHING -} +void JPAFieldBlock::init(JKRHeap* heap) { + mFadeInRate = getFadeInTime() - getEnTime(); + if (mFadeInRate == 0.0f) { + mFadeInRate = 1.0f; + } else { + mFadeInRate = 1.0f / mFadeInRate; + } -/* 8027D3AC-8027D3F4 277CEC 0048+00 1/0 0/0 0/0 .text __dt__12JPAFieldBaseFv */ -JPAFieldBase::~JPAFieldBase() { - // NONMATCHING -} + mFadeOutRate = getDisTime() - getFadeOutTime(); + if (mFadeOutRate == 0.0f) { + mFadeOutRate = 1.0f; + } else { + mFadeOutRate = 1.0f / mFadeOutRate; + } -/* 8027D3F4-8027D450 277D34 005C+00 1/0 0/0 0/0 .text __dt__12JPAFieldSpinFv */ -JPAFieldSpin::~JPAFieldSpin() { - // NONMATCHING -} + getPosOrig(&mPos); + getDirOrig(&mDir); + mMag = getMagOrig(); -/* 8027D450-8027D4AC 277D90 005C+00 1/0 0/0 0/0 .text __dt__12JPAFieldDragFv */ -JPAFieldDrag::~JPAFieldDrag() { - // NONMATCHING + switch (getType()) { + case FIELD_GRAVITY: + mpField = new (heap, 0) JPAFieldGravity(); + break; + case FIELD_AIR: + mpField = new (heap, 0) JPAFieldAir(); + break; + case FIELD_MAGNET: + mpField = new (heap, 0) JPAFieldMagnet(); + break; + case FIELD_NEWTON: + mpField = new (heap, 0) JPAFieldNewton(); + break; + case FIELD_VORTEX: + mpField = new (heap, 0) JPAFieldVortex(); + break; + case FIELD_RANDOM: + mpField = new (heap, 0) JPAFieldRandom(); + break; + case FIELD_DRAG: + mpField = new (heap, 0) JPAFieldDrag(); + break; + case FIELD_CONVECTION: + mpField = new (heap, 0) JPAFieldConvection(); + break; + case FIELD_SPIN: + mpField = new (heap, 0) JPAFieldSpin(); + break; + default: + mpField = NULL; + break; + } } - -/* 8027D4AC-8027D508 277DEC 005C+00 1/0 0/0 0/0 .text __dt__14JPAFieldRandomFv */ -JPAFieldRandom::~JPAFieldRandom() { - // NONMATCHING -} - -/* 8027D508-8027D564 277E48 005C+00 1/0 0/0 0/0 .text __dt__18JPAFieldConvectionFv */ -JPAFieldConvection::~JPAFieldConvection() { - // NONMATCHING -} - -/* 8027D564-8027D5C0 277EA4 005C+00 1/0 0/0 0/0 .text __dt__14JPAFieldVortexFv */ -JPAFieldVortex::~JPAFieldVortex() { - // NONMATCHING -} - -/* 8027D5C0-8027D61C 277F00 005C+00 1/0 0/0 0/0 .text __dt__14JPAFieldNewtonFv */ -JPAFieldNewton::~JPAFieldNewton() { - // NONMATCHING -} - -/* 8027D61C-8027D678 277F5C 005C+00 1/0 0/0 0/0 .text __dt__14JPAFieldMagnetFv */ -JPAFieldMagnet::~JPAFieldMagnet() { - // NONMATCHING -} - -/* 8027D678-8027D6D4 277FB8 005C+00 1/0 0/0 0/0 .text __dt__11JPAFieldAirFv */ -JPAFieldAir::~JPAFieldAir() { - // NONMATCHING -} - -/* 8027D6D4-8027D730 278014 005C+00 1/0 0/0 0/0 .text __dt__15JPAFieldGravityFv */ -JPAFieldGravity::~JPAFieldGravity() { - // NONMATCHING -} \ No newline at end of file diff --git a/src/JSystem/JParticle/JPAKeyBlock.cpp b/src/JSystem/JParticle/JPAKeyBlock.cpp index 01ea3bf4651..fdb1e8e6c5d 100644 --- a/src/JSystem/JParticle/JPAKeyBlock.cpp +++ b/src/JSystem/JParticle/JPAKeyBlock.cpp @@ -6,22 +6,6 @@ #include "JSystem/JParticle/JPAKeyBlock.h" #include "JSystem/JParticle/JPAMath.h" -// -// Types: -// - -// -// Forward References: -// - -// -// External References: -// - -// -// Declarations: -// - /* 8027D730-8027D740 278070 0010+00 0/0 1/1 0/0 .text __ct__11JPAKeyBlockFPCUc */ JPAKeyBlock::JPAKeyBlock(const u8* data) : mDataStart(data) @@ -29,15 +13,13 @@ JPAKeyBlock::JPAKeyBlock(const u8* data) { } -/* ############################################################################################## */ - /* 8027D740-8027D7D4 278080 0094+00 0/0 1/1 0/0 .text calc__11JPAKeyBlockFf */ -void JPAKeyBlock::calc(float p1) { +f32 JPAKeyBlock::calc(float p1) { if (mDataStart[0xB] != '\0') { int v1 = (int)field_0x4[(mDataStart[9] - 1) * 4] + 1; // p1 -= (v1 * ((int)p1 / v1)); int v2 = ((int)p1 / v1); p1 = p1 - (v2 * v1); } - JPACalcKeyAnmValue(p1, mDataStart[9], field_0x4); -} \ No newline at end of file + return JPACalcKeyAnmValue(p1, mDataStart[9], field_0x4); +} diff --git a/src/JSystem/JParticle/JPAParticle.cpp b/src/JSystem/JParticle/JPAParticle.cpp index ac8f7f75487..e5b7121d04a 100644 --- a/src/JSystem/JParticle/JPAParticle.cpp +++ b/src/JSystem/JParticle/JPAParticle.cpp @@ -4,127 +4,332 @@ // #include "JSystem/JParticle/JPAParticle.h" +#include "JSystem/JParticle/JPABaseShape.h" +#include "JSystem/JParticle/JPAChildShape.h" #include "JSystem/JParticle/JPAEmitter.h" #include "JSystem/JParticle/JPAEmitterManager.h" -#include "dol2asm.h" - -// -// Forward References: -// - -extern "C" void __dt__19JPAParticleCallBackFv(); -extern "C" void init_p__15JPABaseParticleFP18JPAEmitterWorkData(); -extern "C" void init_c__15JPABaseParticleFP18JPAEmitterWorkDataP15JPABaseParticle(); -extern "C" void calc_p__15JPABaseParticleFP18JPAEmitterWorkData(); -extern "C" void calc_c__15JPABaseParticleFP18JPAEmitterWorkData(); -extern "C" void canCreateChild__15JPABaseParticleFP18JPAEmitterWorkData(); -extern "C" void getWidth__15JPABaseParticleCFPC14JPABaseEmitter(); -extern "C" void getHeight__15JPABaseParticleCFPC14JPABaseEmitter(); - -// -// External References: -// - -extern "C" void calc_p__11JPAResourceFP18JPAEmitterWorkDataP15JPABaseParticle(); -extern "C" void calc_c__11JPAResourceFP18JPAEmitterWorkDataP15JPABaseParticle(); -extern "C" void calcField__11JPAResourceFP18JPAEmitterWorkDataP15JPABaseParticle(); -extern "C" void createChild__14JPABaseEmitterFP15JPABaseParticle(); -extern "C" void JPAGetYZRotateMtx__FssPA4_f(); -extern "C" void __dl__FPv(); -extern "C" void JMAVECScaleAdd__FPC3VecPC3VecP3Vecf(); -extern "C" void _savegpr_26(); -extern "C" void _savegpr_29(); -extern "C" void _restgpr_26(); -extern "C" void _restgpr_29(); -extern "C" extern void* __vt__19JPAParticleCallBack[5]; - -// -// Declarations: -// +#include "JSystem/JParticle/JPAExtraShape.h" /* 8027EFA4-8027EFEC 2798E4 0048+00 0/0 11/11 1/1 .text __dt__19JPAParticleCallBackFv */ JPAParticleCallBack::~JPAParticleCallBack() { - // NONMATCHING + /* empty function */ } -/* ############################################################################################## */ -/* 80455388-8045538C 003988 0004+00 2/2 0/0 0/0 .sdata2 @2565 */ -SECTION_SDATA2 static f32 lit_2565 = 1.0f; - -/* 8045538C-80455390 00398C 0004+00 4/4 0/0 0/0 .sdata2 @2566 */ -SECTION_SDATA2 static u8 lit_2566[4] = { - 0x00, - 0x00, - 0x00, - 0x00, -}; - -/* 80455390-80455394 003990 0004+00 2/2 0/0 0/0 .sdata2 @2567 */ -SECTION_SDATA2 static f32 lit_2567 = 32.0f; - -/* 80455394-80455398 003994 0004+00 2/2 0/0 0/0 .sdata2 @2568 */ -SECTION_SDATA2 static f32 lit_2568 = 0.5f; - -/* 80455398-8045539C 003998 0004+00 2/2 0/0 0/0 .sdata2 @2569 */ -SECTION_SDATA2 static f32 lit_2569 = 3.0f; - -/* 8045539C-804553A0 00399C 0004+00 1/1 0/0 0/0 .sdata2 @2570 */ -SECTION_SDATA2 static f32 lit_2570 = 32768.0f; - -/* 804553A0-804553A8 0039A0 0008+00 4/4 0/0 0/0 .sdata2 @2572 */ -SECTION_SDATA2 static f64 lit_2572 = 4503601774854144.0 /* cast s32 to float */; - -/* 804553A8-804553B0 0039A8 0008+00 2/2 0/0 0/0 .sdata2 @2574 */ -SECTION_SDATA2 static f64 lit_2574 = 4503599627370496.0 /* cast u32 to float */; - /* 8027EFEC-8027F8C8 27992C 08DC+00 0/0 1/1 0/0 .text * init_p__15JPABaseParticleFP18JPAEmitterWorkData */ -void JPABaseParticle::init_p(JPAEmitterWorkData* param_0) { - // NONMATCHING +// NONMATCHING a couple problems, likely issues with setLength and get_r_ss +void JPABaseParticle::init_p(JPAEmitterWorkData* work) { + JPABaseEmitter* emtr = work->mpEmtr; + JPAExtraShape* esp = work->mpRes->getEsp(); + JPABaseShape* bsp = work->mpRes->getBsp(); + JPADynamicsBlock* dyn = work->mpRes->getDyn(); + + mAge = -1; + mLifeTime = (1.0f - dyn->getLifeTimeRndm() * emtr->get_r_f()) * emtr->mLifeTime; + mTime = 0.0f; + + initStatus(0); + MTXMultVecSR(work->mGlobalSR, &work->mVolumePos, &mLocalPosition); + if (emtr->checkFlag(8)) { + setStatus(0x20); + } + + mOffsetPosition.set(work->mGlobalPos); + mPosition.set(mOffsetPosition.x + mLocalPosition.x * work->mPublicScale.x, + mOffsetPosition.y + mLocalPosition.y * work->mPublicScale.y, + mOffsetPosition.z + mLocalPosition.z * work->mPublicScale.z); + + JGeometry::TVec3 velOmni; + if (emtr->mAwayFromCenterSpeed) { + velOmni.setLength(work->mVelOmni, emtr->mAwayFromCenterSpeed); + } else { + velOmni.zero(); + } + + JGeometry::TVec3 velAxis; + if (emtr->mAwayFromAxisSpeed) { + velAxis.setLength(work->mVelAxis, emtr->mAwayFromAxisSpeed); + } else { + velAxis.zero(); + } + + JGeometry::TVec3 velDir; + if (emtr->mDirSpeed) { + Mtx mtx; + s16 angleY = emtr->get_r_ss(); + s16 angleZ = emtr->get_r_zp() * 0x8000 * emtr->mSpread; + JPAGetYZRotateMtx(angleY, angleZ, mtx); + MTXConcat(work->mDirectionMtx, mtx, mtx); + velDir.set(emtr->mDirSpeed * mtx[0][2], + emtr->mDirSpeed * mtx[1][2], + emtr->mDirSpeed * mtx[2][2]); + } else { + velDir.zero(); + } + + JGeometry::TVec3 velRndm; + if (emtr->mRndmDirSpeed) { + velRndm.set(emtr->mRndmDirSpeed * emtr->get_r_zh(), + emtr->mRndmDirSpeed * emtr->get_r_zh(), + emtr->mRndmDirSpeed * emtr->get_r_zh()); + } else { + velRndm.zero(); + } + + f32 ratio = emtr->get_r_zp() * dyn->getInitVelRatio() + 1.0f; + mVelType1.set(ratio * (velOmni.x + velAxis.x + velDir.x + velRndm.x), + ratio * (velOmni.y + velAxis.y + velDir.y + velRndm.y), + ratio * (velOmni.z + velAxis.z + velDir.z + velRndm.z)); + + if (emtr->checkFlag(4)) { + mVelType1.mul(emtr->mLocalScl); + } + MTXMultVecSR(work->mGlobalRot, &mVelType1, &mVelType1); + + mVelType0.zero(); + + mMoment = 1.0f - dyn->getMomentRndm() * emtr->get_r_f(); + mDrag = 1.0f; + field_0x78 = 0; + + mBaseAxis.set(work->mGlobalRot[0][1], work->mGlobalRot[1][1], work->mGlobalRot[2][1]); + + mPrmClr = emtr->mPrmClr; + mEnvClr = emtr->mEnvClr; + + mAnmRandom = emtr->get_r_f() * bsp->getLoopOfstValue(); + + if (esp != NULL && esp->isEnableScaleAnm()) { + f32 scale = emtr->mScaleOut * (emtr->get_r_zp() * esp->getScaleRndm() + 1.0f); + mParticleScaleX = mParticleScaleY = mScaleOut = scale; + } else { + mParticleScaleX = mParticleScaleY = mScaleOut = emtr->mScaleOut; + } + + mPrmColorAlphaAnm = 0xff; + + if (esp != NULL && esp->isEnableAlphaFlick()) { + mAlphaWaveRandom = emtr->get_r_zp() * esp->getAlphaFreqRndm() + 1.0f; + } else { + mAlphaWaveRandom = 1.0f; + } + + if (esp != NULL) { + if (esp->isEnableRotateAnm()) { + mRotateAngle = esp->getRotateInitAngle() + esp->getRotateRndmAngle() * emtr->get_r_zh(); + mRotateSpeed = esp->getRotateInitSpeed() * + (esp->getRotateRndmSpeed() * emtr->get_r_zp() + 1.0f); + mRotateSpeed = emtr->get_r_zp() < esp->getRotateDirection() ? + mRotateSpeed : (s16)-mRotateSpeed; + } else { + mRotateAngle = 0; + mRotateSpeed = 0; + } + } else { + mRotateAngle = 0; + mRotateSpeed = 0; + } } /* 8027F8C8-8027FFD0 27A208 0708+00 0/0 1/1 0/0 .text * init_c__15JPABaseParticleFP18JPAEmitterWorkDataP15JPABaseParticle */ -void JPABaseParticle::init_c(JPAEmitterWorkData* param_0, JPABaseParticle* param_1) { - // NONMATCHING +void JPABaseParticle::init_c(JPAEmitterWorkData* work, JPABaseParticle* parent) { + JPABaseEmitter* emtr = work->mpEmtr; + JPAChildShape* csp = work->mpRes->getCsp(); + + mAge = -1; + mLifeTime = csp->getLife(); + mTime = 0.0f; + initStatus(4); + mLocalPosition.set(parent->mLocalPosition); + + f32 pos_rndm = csp->getPosRndm(); + if (pos_rndm != 0.0f) { + JGeometry::TVec3 rnd(emtr->get_r_zh(), emtr->get_r_zh(), emtr->get_r_zh()); + rnd.setLength(pos_rndm * emtr->get_r_f()); + mLocalPosition.add(rnd); + } + + if (emtr->checkFlag(0x10)) { + setStatus(0x20); + } + + mOffsetPosition.set(parent->mOffsetPosition); + + f32 base_speed = csp->getBaseVel() * (csp->getBaseVelRndm() * emtr->get_r_zp() + 1.0f); + JGeometry::TVec3 base_vel(emtr->get_r_zp(), emtr->get_r_zp(), emtr->get_r_zp()); + base_vel.setLength(base_speed); + mVelType1.scaleAdd(csp->getVelInhRate(), parent->mVelType1, base_vel); + mVelType0.scale(csp->getVelInhRate(), parent->mVelType2); + + mMoment = parent->mMoment; + if (csp->isFieldAffected()) { + mDrag = parent->mDrag; + } else { + setStatus(0x40); + mDrag = 1.0f; + } + field_0x78 = parent->field_0x78; + + mVelType2.set(mVelType0); + f32 ratio = mMoment * mDrag; + mVelocity.set(ratio * (mVelType1.x + mVelType2.x), + ratio * (mVelType1.y + mVelType2.y), + ratio * (mVelType1.z + mVelType2.z)); + + mBaseAxis.set(parent->mBaseAxis); + + if (csp->isScaleInherited()) { + mParticleScaleX = mScaleOut = parent->mParticleScaleX * csp->getScaleInhRate(); + mParticleScaleY = mAlphaWaveRandom = parent->mParticleScaleY * csp->getScaleInhRate(); + } else { + mParticleScaleX = mScaleOut = mParticleScaleY = mAlphaWaveRandom = 1.0f; + } + + if (csp->isColorInherited()) { + mPrmClr.r = parent->mPrmClr.r * csp->getColorInhRate(); + mPrmClr.g = parent->mPrmClr.g * csp->getColorInhRate(); + mPrmClr.b = parent->mPrmClr.b * csp->getColorInhRate(); + mEnvClr.r = parent->mEnvClr.r * csp->getColorInhRate(); + mEnvClr.g = parent->mEnvClr.g * csp->getColorInhRate(); + mEnvClr.b = parent->mEnvClr.b * csp->getColorInhRate(); + } else { + csp->getPrmClr(&mPrmClr); + csp->getEnvClr(&mEnvClr); + } + + mPrmColorAlphaAnm = 0xff; + if (csp->isAlphaInherited()) { + mPrmClr.a = COLOR_MULTI(parent->mPrmClr.a, parent->mPrmColorAlphaAnm) + * csp->getAlphaInhRate(); + } else { + mPrmClr.a = csp->getPrmAlpha(); + } + + mRotateAngle = parent->mRotateAngle; + if (csp->isRotateOn()) { + mRotateSpeed = csp->getRotInitSpeed(); + } else { + mRotateSpeed = 0; + } + + mTexAnmIdx = 0; } /* 8027FFD0-80280260 27A910 0290+00 0/0 1/1 0/0 .text * calc_p__15JPABaseParticleFP18JPAEmitterWorkData */ -void JPABaseParticle::calc_p(JPAEmitterWorkData* param_0) { - // NONMATCHING +bool JPABaseParticle::calc_p(JPAEmitterWorkData* work) { + if (++mAge >= mLifeTime) { + return true; + } + mTime = (f32)mAge / (f32)mLifeTime; + + if (checkStatus(0x20)) { + mOffsetPosition.set(work->mGlobalPos); + } + + mVelType2.zero(); + if (!checkStatus(0x40)) { + work->mpRes->calcField(work, this); + } + mVelType2.add(mVelType0); + mVelType1.scale(work->mpEmtr->mAirResist); + f32 ratio = mMoment * mDrag; + mVelocity.set(ratio * (mVelType1.x + mVelType2.x), + ratio * (mVelType1.y + mVelType2.y), + ratio * (mVelType1.z + mVelType2.z)); + + if (work->mpEmtr->mpPtclCallBack != NULL) { + work->mpEmtr->mpPtclCallBack->execute(work->mpEmtr, this); + } + + if (checkStatus(2)) { + return true; + } + + work->mpRes->calc_p(work, this); + mRotateAngle += mRotateSpeed; + + if (work->mpRes->getCsp() != NULL && canCreateChild(work)) { + for (int i = work->mpRes->getCsp()->getRate(); i > 0; i--) { + work->mpEmtr->createChild(this); + } + } + + mLocalPosition.add(mVelocity); + mPosition.set(mOffsetPosition.x + mLocalPosition.x * work->mPublicScale.x, + mOffsetPosition.y + mLocalPosition.y * work->mPublicScale.y, + mOffsetPosition.z + mLocalPosition.z * work->mPublicScale.z); + + return false; } /* 80280260-802804C8 27ABA0 0268+00 0/0 1/1 0/0 .text * calc_c__15JPABaseParticleFP18JPAEmitterWorkData */ -void JPABaseParticle::calc_c(JPAEmitterWorkData* param_0) { - // NONMATCHING +bool JPABaseParticle::calc_c(JPAEmitterWorkData* work) { + if (++mAge >= mLifeTime) { + return true; + } + mTime = (f32)mAge / (f32)mLifeTime; + + if (mAge != 0) { + if (checkStatus(0x20)) { + mOffsetPosition.set(work->mGlobalPos); + } + + mVelType1.y -= work->mpRes->getCsp()->getGravity(); + mVelType2.zero(); + if (!checkStatus(0x40)) { + work->mpRes->calcField(work, this); + } + mVelType2.add(mVelType0); + mVelType1.scale(work->mpEmtr->mAirResist); + f32 ratio = mMoment * mDrag; + mVelocity.set(ratio * (mVelType1.x + mVelType2.x), + ratio * (mVelType1.y + mVelType2.y), + ratio * (mVelType1.z + mVelType2.z)); + } + + if (work->mpEmtr->mpPtclCallBack != NULL) { + work->mpEmtr->mpPtclCallBack->execute(work->mpEmtr, this); + } + + if (checkStatus(2)) { + return true; + } + + work->mpRes->calc_c(work, this); + mRotateAngle += mRotateSpeed; + mLocalPosition.add(mVelocity); + mPosition.set(mOffsetPosition.x + mLocalPosition.x * work->mPublicScale.x, + mOffsetPosition.y + mLocalPosition.y * work->mPublicScale.y, + mOffsetPosition.z + mLocalPosition.z * work->mPublicScale.z); + + return false; } /* 802804C8-80280548 27AE08 0080+00 1/1 0/0 0/0 .text * canCreateChild__15JPABaseParticleFP18JPAEmitterWorkData */ -void JPABaseParticle::canCreateChild(JPAEmitterWorkData* param_0) { - // NONMATCHING +bool JPABaseParticle::canCreateChild(JPAEmitterWorkData* work) { + JPAChildShape* csp = work->mpRes->getCsp(); + bool ret = false; + int time = mAge - (int)((mLifeTime - 1) * csp->getTiming()); + if (time >= 0 && time % (csp->getStep() + 1) == 0) { + ret = true; + } + return ret; } -/* ############################################################################################## */ -/* 804553B0-804553B8 0039B0 0004+04 2/2 0/0 0/0 .sdata2 @3010 */ -SECTION_SDATA2 static f32 lit_3010[1 + 1 /* padding */] = { - 2.0f, - /* padding */ - 0.0f, -}; - /* 80280548-80280568 27AE88 0020+00 0/0 3/3 0/0 .text * getWidth__15JPABaseParticleCFPC14JPABaseEmitter */ f32 JPABaseParticle::getWidth(JPABaseEmitter const* emtr) const { - f32 scale = lit_3010[0] * mParticleScaleX; + f32 scale = 2.0f * mParticleScaleX; return scale * emtr->mpEmtrMgr->mpWorkData->mGlobalPtclScl.x; } /* 80280568-80280588 27AEA8 0020+00 0/0 3/3 0/0 .text * getHeight__15JPABaseParticleCFPC14JPABaseEmitter */ f32 JPABaseParticle::getHeight(JPABaseEmitter const* emtr) const { - f32 scale = lit_3010[0] * mParticleScaleY; + f32 scale = 2.0f * mParticleScaleY; return scale * emtr->mpEmtrMgr->mpWorkData->mGlobalPtclScl.y; -} \ No newline at end of file +} diff --git a/src/JSystem/JParticle/JPAResource.cpp b/src/JSystem/JParticle/JPAResource.cpp index ab887a2b3be..aa77011939b 100644 --- a/src/JSystem/JParticle/JPAResource.cpp +++ b/src/JSystem/JParticle/JPAResource.cpp @@ -4,147 +4,17 @@ // #include "JSystem/JParticle/JPAResource.h" +#include "JSystem/JKernel/JKRHeap.h" #include "JSystem/JParticle/JPABaseShape.h" +#include "JSystem/JParticle/JPAChildShape.h" #include "JSystem/JParticle/JPAEmitter.h" -#include "dol2asm.h" +#include "JSystem/JParticle/JPAExTexShape.h" +#include "JSystem/JParticle/JPAExtraShape.h" +#include "JSystem/JParticle/JPAFieldBlock.h" +#include "JSystem/JParticle/JPAKeyBlock.h" +#include "JSystem/JParticle/JPAParticle.h" +#include "JSystem/JParticle/JPAResourceManager.h" #include "dolphin/gx.h" -#include "dolphin/types.h" - -// -// Types: -// - -struct JPAKeyBlock { - /* 8027D740 */ void calc(f32); -}; - -struct JPAFieldBlock {}; - -struct JPAFieldBase { - /* 80276A8C */ void prepare(JPAEmitterWorkData*, JPAFieldBlock*); -}; - -// -// Forward References: -// - -extern "C" void __ct__11JPAResourceFv(); -extern "C" void init__11JPAResourceFP7JKRHeap(); -extern "C" void calc__11JPAResourceFP18JPAEmitterWorkDataP14JPABaseEmitter(); -extern "C" void draw__11JPAResourceFP18JPAEmitterWorkDataP14JPABaseEmitter(); -extern "C" void drawP__11JPAResourceFP18JPAEmitterWorkData(); -extern "C" void drawC__11JPAResourceFP18JPAEmitterWorkData(); -extern "C" void setPTev__11JPAResourceFv(); -extern "C" void setCTev__11JPAResourceFP18JPAEmitterWorkData(); -extern "C" void calc_p__11JPAResourceFP18JPAEmitterWorkDataP15JPABaseParticle(); -extern "C" void calc_c__11JPAResourceFP18JPAEmitterWorkDataP15JPABaseParticle(); -extern "C" void calcField__11JPAResourceFP18JPAEmitterWorkDataP15JPABaseParticle(); -extern "C" void calcKey__11JPAResourceFP18JPAEmitterWorkData(); -extern "C" void calcWorkData_c__11JPAResourceFP18JPAEmitterWorkData(); -extern "C" void calcWorkData_d__11JPAResourceFP18JPAEmitterWorkData(); -extern "C" void prepare__12JPAFieldBaseFP18JPAEmitterWorkDataP13JPAFieldBlock(); - -// -// External References: -// - -extern "C" void JPASetPointSize__FP18JPAEmitterWorkData(); -extern "C" void JPASetLineWidth__FP18JPAEmitterWorkData(); -extern "C" void JPASetPointSize__FP18JPAEmitterWorkDataP15JPABaseParticle(); -extern "C" void JPASetLineWidth__FP18JPAEmitterWorkDataP15JPABaseParticle(); -extern "C" void JPARegistPrm__FP18JPAEmitterWorkData(); -extern "C" void JPARegistEnv__FP18JPAEmitterWorkData(); -extern "C" void JPARegistPrmEnv__FP18JPAEmitterWorkData(); -extern "C" void JPARegistAlpha__FP18JPAEmitterWorkDataP15JPABaseParticle(); -extern "C" void JPARegistPrmAlpha__FP18JPAEmitterWorkDataP15JPABaseParticle(); -extern "C" void JPARegistPrmAlphaEnv__FP18JPAEmitterWorkDataP15JPABaseParticle(); -extern "C" void JPARegistAlphaEnv__FP18JPAEmitterWorkDataP15JPABaseParticle(); -extern "C" void JPARegistEnv__FP18JPAEmitterWorkDataP15JPABaseParticle(); -extern "C" void JPACalcClrIdxNormal__FP18JPAEmitterWorkData(); -extern "C" void JPACalcClrIdxNormal__FP18JPAEmitterWorkDataP15JPABaseParticle(); -extern "C" void JPACalcClrIdxRepeat__FP18JPAEmitterWorkData(); -extern "C" void JPACalcClrIdxRepeat__FP18JPAEmitterWorkDataP15JPABaseParticle(); -extern "C" void JPACalcClrIdxReverse__FP18JPAEmitterWorkData(); -extern "C" void JPACalcClrIdxReverse__FP18JPAEmitterWorkDataP15JPABaseParticle(); -extern "C" void JPACalcClrIdxMerge__FP18JPAEmitterWorkData(); -extern "C" void JPACalcClrIdxMerge__FP18JPAEmitterWorkDataP15JPABaseParticle(); -extern "C" void JPACalcClrIdxRandom__FP18JPAEmitterWorkData(); -extern "C" void JPACalcClrIdxRandom__FP18JPAEmitterWorkDataP15JPABaseParticle(); -extern "C" void JPACalcPrm__FP18JPAEmitterWorkData(); -extern "C" void JPACalcPrm__FP18JPAEmitterWorkDataP15JPABaseParticle(); -extern "C" void JPACalcEnv__FP18JPAEmitterWorkData(); -extern "C" void JPACalcEnv__FP18JPAEmitterWorkDataP15JPABaseParticle(); -extern "C" void JPACalcColorCopy__FP18JPAEmitterWorkDataP15JPABaseParticle(); -extern "C" void JPAGenTexCrdMtxIdt__FP18JPAEmitterWorkData(); -extern "C" void JPAGenTexCrdMtxAnm__FP18JPAEmitterWorkData(); -extern "C" void JPAGenTexCrdMtxPrj__FP18JPAEmitterWorkData(); -extern "C" void JPAGenCalcTexCrdMtxAnm__FP18JPAEmitterWorkData(); -extern "C" void JPALoadCalcTexCrdMtxAnm__FP18JPAEmitterWorkDataP15JPABaseParticle(); -extern "C" void JPALoadTex__FP18JPAEmitterWorkData(); -extern "C" void JPALoadTexAnm__FP18JPAEmitterWorkData(); -extern "C" void JPALoadTexAnm__FP18JPAEmitterWorkDataP15JPABaseParticle(); -extern "C" void JPACalcTexIdxNormal__FP18JPAEmitterWorkData(); -extern "C" void JPACalcTexIdxNormal__FP18JPAEmitterWorkDataP15JPABaseParticle(); -extern "C" void JPACalcTexIdxRepeat__FP18JPAEmitterWorkData(); -extern "C" void JPACalcTexIdxRepeat__FP18JPAEmitterWorkDataP15JPABaseParticle(); -extern "C" void JPACalcTexIdxReverse__FP18JPAEmitterWorkData(); -extern "C" void JPACalcTexIdxReverse__FP18JPAEmitterWorkDataP15JPABaseParticle(); -extern "C" void JPACalcTexIdxMerge__FP18JPAEmitterWorkData(); -extern "C" void JPACalcTexIdxMerge__FP18JPAEmitterWorkDataP15JPABaseParticle(); -extern "C" void JPACalcTexIdxRandom__FP18JPAEmitterWorkData(); -extern "C" void JPACalcTexIdxRandom__FP18JPAEmitterWorkDataP15JPABaseParticle(); -extern "C" void JPALoadPosMtxCam__FP18JPAEmitterWorkData(); -extern "C" void JPADrawBillboard__FP18JPAEmitterWorkDataP15JPABaseParticle(); -extern "C" void JPADrawRotBillboard__FP18JPAEmitterWorkDataP15JPABaseParticle(); -extern "C" void JPADrawYBillboard__FP18JPAEmitterWorkDataP15JPABaseParticle(); -extern "C" void JPADrawRotYBillboard__FP18JPAEmitterWorkDataP15JPABaseParticle(); -extern "C" void JPADrawDirection__FP18JPAEmitterWorkDataP15JPABaseParticle(); -extern "C" void JPADrawRotDirection__FP18JPAEmitterWorkDataP15JPABaseParticle(); -extern "C" void JPADrawDBillboard__FP18JPAEmitterWorkDataP15JPABaseParticle(); -extern "C" void JPADrawRotation__FP18JPAEmitterWorkDataP15JPABaseParticle(); -extern "C" void JPADrawPoint__FP18JPAEmitterWorkDataP15JPABaseParticle(); -extern "C" void JPADrawLine__FP18JPAEmitterWorkDataP15JPABaseParticle(); -extern "C" void JPADrawStripe__FP18JPAEmitterWorkData(); -extern "C" void JPADrawStripeX__FP18JPAEmitterWorkData(); -extern "C" void JPADrawEmitterCallBackB__FP18JPAEmitterWorkData(); -extern "C" void JPADrawParticleCallBack__FP18JPAEmitterWorkDataP15JPABaseParticle(); -extern "C" void setGX__12JPABaseShapeCFP18JPAEmitterWorkData(); -extern "C" void JPACalcScaleX__FP18JPAEmitterWorkDataP15JPABaseParticle(); -extern "C" void JPACalcScaleY__FP18JPAEmitterWorkDataP15JPABaseParticle(); -extern "C" void JPACalcScaleCopy__FP18JPAEmitterWorkDataP15JPABaseParticle(); -extern "C" void JPACalcScaleAnmNormal__FP18JPAEmitterWorkDataP15JPABaseParticle(); -extern "C" void JPACalcScaleAnmRepeatX__FP18JPAEmitterWorkDataP15JPABaseParticle(); -extern "C" void JPACalcScaleAnmRepeatY__FP18JPAEmitterWorkDataP15JPABaseParticle(); -extern "C" void JPACalcScaleAnmReverseX__FP18JPAEmitterWorkDataP15JPABaseParticle(); -extern "C" void JPACalcScaleAnmReverseY__FP18JPAEmitterWorkDataP15JPABaseParticle(); -extern "C" void JPACalcAlphaAnm__FP18JPAEmitterWorkDataP15JPABaseParticle(); -extern "C" void JPACalcAlphaFlickAnm__FP18JPAEmitterWorkDataP15JPABaseParticle(); -extern "C" void JPARegistChildPrmEnv__FP18JPAEmitterWorkData(); -extern "C" void JPACalcChildAlphaOut__FP18JPAEmitterWorkDataP15JPABaseParticle(); -extern "C" void JPACalcChildScaleOut__FP18JPAEmitterWorkDataP15JPABaseParticle(); -extern "C" void JPALoadExTex__FP18JPAEmitterWorkData(); -extern "C" void create__16JPADynamicsBlockFP18JPAEmitterWorkData(); -extern "C" void calc__11JPAKeyBlockFf(); -extern "C" void processTillStartFrame__14JPABaseEmitterFv(); -extern "C" void processTermination__14JPABaseEmitterFv(); -extern "C" void calc_p__15JPABaseParticleFP18JPAEmitterWorkData(); -extern "C" void calc_c__15JPABaseParticleFP18JPAEmitterWorkData(); -extern "C" void func_80280588(); -extern "C" void JPAGetXYZRotateMtx__FsssPA4_f(); -extern "C" void alloc__7JKRHeapFUliP7JKRHeap(); -extern "C" void load__10JUTTextureF11_GXTexMapID(); -extern "C" void _savegpr_14(); -extern "C" void _savegpr_25(); -extern "C" void _savegpr_27(); -extern "C" void _savegpr_28(); -extern "C" void _restgpr_14(); -extern "C" void _restgpr_25(); -extern "C" void _restgpr_27(); -extern "C" void _restgpr_28(); - -// -// Declarations: -// /* 80274010-80274080 26E950 0070+00 0/0 1/1 0/0 .text __ct__11JPAResourceFv */ JPAResource::JPAResource() { @@ -176,409 +46,743 @@ JPAResource::JPAResource() { mUsrIdx = 0; } -/* ############################################################################################## */ /* 803C40C0-803C4220 0211E0 0144+1C 2/2 0/0 0/0 .data jpa_pos */ -SECTION_DATA static u8 jpa_pos[324 + 28 /* padding */] ALIGN_DECL(32) = { - 0x00, - 0x00, - 0x00, - 0x32, - 0x00, - 0x00, - 0x32, - 0xCE, - 0x00, - 0x00, - 0xCE, - 0x00, - 0xE7, - 0x00, - 0x00, - 0x19, - 0x00, - 0x00, - 0x19, - 0xCE, - 0x00, - 0xE7, - 0xCE, - 0x00, - 0xCE, - 0x00, - 0x00, - 0x00, - 0x00, - 0x00, - 0x00, - 0xCE, - 0x00, - 0xCE, - 0xCE, - 0x00, - 0x00, - 0x19, - 0x00, - 0x32, - 0x19, - 0x00, - 0x32, - 0xE7, - 0x00, - 0x00, - 0xE7, - 0x00, - 0xE7, - 0x19, - 0x00, - 0x19, - 0x19, - 0x00, - 0x19, - 0xE7, - 0x00, - 0xE7, - 0xE7, - 0x00, - 0xCE, - 0x19, - 0x00, - 0x00, - 0x19, - 0x00, - 0x00, - 0xE7, - 0x00, - 0xCE, - 0xE7, - 0x00, - 0x00, - 0x32, - 0x00, - 0x32, - 0x32, - 0x00, - 0x32, - 0x00, - 0x00, - 0x00, - 0x00, - 0x00, - 0xE7, - 0x32, - 0x00, - 0x19, - 0x32, - 0x00, - 0x19, - 0x00, - 0x00, - 0xE7, - 0x00, - 0x00, - 0xCE, - 0x32, - 0x00, - 0x00, - 0x32, - 0x00, - 0x00, - 0x00, - 0x00, - 0xCE, - 0x00, - 0x00, - 0x00, - 0x00, - 0x00, - 0x32, - 0x00, - 0x00, - 0x32, - 0x00, - 0x32, - 0x00, - 0x00, - 0x32, - 0xE7, - 0x00, - 0x00, - 0x19, - 0x00, - 0x00, - 0x19, - 0x00, - 0x32, - 0xE7, - 0x00, - 0x32, - 0xCE, - 0x00, - 0x00, - 0x00, - 0x00, - 0x00, - 0x00, - 0x00, - 0x32, - 0xCE, - 0x00, - 0x32, - 0x00, - 0x00, - 0xE7, - 0x32, - 0x00, - 0xE7, - 0x32, - 0x00, - 0x19, - 0x00, - 0x00, - 0x19, - 0xE7, - 0x00, - 0xE7, - 0x19, - 0x00, - 0xE7, - 0x19, - 0x00, - 0x19, - 0xE7, - 0x00, - 0x19, - 0xCE, - 0x00, - 0xE7, - 0x00, - 0x00, - 0xE7, - 0x00, - 0x00, - 0x19, - 0xCE, - 0x00, - 0x19, - 0x00, - 0x00, - 0xCE, - 0x32, - 0x00, - 0xCE, - 0x32, - 0x00, - 0x00, - 0x00, - 0x00, - 0x00, - 0xE7, - 0x00, - 0xCE, - 0x19, - 0x00, - 0xCE, - 0x19, - 0x00, - 0x00, - 0xE7, - 0x00, - 0x00, - 0xCE, - 0x00, - 0xCE, - 0x00, - 0x00, - 0xCE, - 0x00, - 0x00, - 0x00, - 0xCE, - 0x00, - 0x00, - 0x00, - 0x00, - 0x00, - 0x00, - 0x00, - 0x32, - 0x00, - 0xCE, - 0x32, - 0x00, - 0xCE, - 0x00, - 0x00, - 0x00, - 0xE7, - 0x00, - 0x00, - 0x19, - 0x00, - 0xCE, - 0x19, - 0x00, - 0xCE, - 0xE7, - 0x00, - 0x00, - 0xCE, - 0x00, - 0x00, - 0x00, - 0x00, - 0xCE, - 0x00, - 0x00, - 0xCE, - 0xCE, - 0x00, - 0x19, - 0x00, - 0x00, - 0x19, - 0x32, - 0x00, - 0xE7, - 0x32, - 0x00, - 0xE7, - 0x00, - 0x00, - 0x19, - 0xE7, - 0x00, - 0x19, - 0x19, - 0x00, - 0xE7, - 0x19, - 0x00, - 0xE7, - 0xE7, - 0x00, - 0x19, - 0xCE, - 0x00, - 0x19, - 0x00, - 0x00, - 0xE7, - 0x00, - 0x00, - 0xE7, - 0xCE, - 0x00, - 0x32, - 0x00, - 0x00, - 0x32, - 0x32, - 0x00, - 0x00, - 0x32, - 0x00, - 0x00, - 0x00, - 0x00, - 0x32, - 0xE7, - 0x00, - 0x32, - 0x19, - 0x00, - 0x00, - 0x19, - 0x00, - 0x00, - 0xE7, - 0x00, - 0x32, - 0xCE, - 0x00, - 0x32, - 0x00, - 0x00, - 0x00, - 0x00, - 0x00, - 0x00, - 0xCE, - /* padding */ - 0x00, - 0x00, - 0x00, - 0x00, - 0x00, - 0x00, - 0x00, - 0x00, - 0x00, - 0x00, - 0x00, - 0x00, - 0x00, - 0x00, - 0x00, - 0x00, - 0x00, - 0x00, - 0x00, - 0x00, - 0x00, - 0x00, - 0x00, - 0x00, - 0x00, - 0x00, - 0x00, - 0x00, +static u8 jpa_pos[324] ALIGN_DECL(32) = { + 0x00, 0x00, 0x00, 0x32, 0x00, 0x00, 0x32, 0xCE, 0x00, 0x00, 0xCE, 0x00, 0xE7, 0x00, 0x00, 0x19, + 0x00, 0x00, 0x19, 0xCE, 0x00, 0xE7, 0xCE, 0x00, 0xCE, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xCE, + 0x00, 0xCE, 0xCE, 0x00, 0x00, 0x19, 0x00, 0x32, 0x19, 0x00, 0x32, 0xE7, 0x00, 0x00, 0xE7, 0x00, + 0xE7, 0x19, 0x00, 0x19, 0x19, 0x00, 0x19, 0xE7, 0x00, 0xE7, 0xE7, 0x00, 0xCE, 0x19, 0x00, 0x00, + 0x19, 0x00, 0x00, 0xE7, 0x00, 0xCE, 0xE7, 0x00, 0x00, 0x32, 0x00, 0x32, 0x32, 0x00, 0x32, 0x00, + 0x00, 0x00, 0x00, 0x00, 0xE7, 0x32, 0x00, 0x19, 0x32, 0x00, 0x19, 0x00, 0x00, 0xE7, 0x00, 0x00, + 0xCE, 0x32, 0x00, 0x00, 0x32, 0x00, 0x00, 0x00, 0x00, 0xCE, 0x00, 0x00, 0x00, 0x00, 0x00, 0x32, + 0x00, 0x00, 0x32, 0x00, 0x32, 0x00, 0x00, 0x32, 0xE7, 0x00, 0x00, 0x19, 0x00, 0x00, 0x19, 0x00, + 0x32, 0xE7, 0x00, 0x32, 0xCE, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x32, 0xCE, 0x00, 0x32, + 0x00, 0x00, 0xE7, 0x32, 0x00, 0xE7, 0x32, 0x00, 0x19, 0x00, 0x00, 0x19, 0xE7, 0x00, 0xE7, 0x19, + 0x00, 0xE7, 0x19, 0x00, 0x19, 0xE7, 0x00, 0x19, 0xCE, 0x00, 0xE7, 0x00, 0x00, 0xE7, 0x00, 0x00, + 0x19, 0xCE, 0x00, 0x19, 0x00, 0x00, 0xCE, 0x32, 0x00, 0xCE, 0x32, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xE7, 0x00, 0xCE, 0x19, 0x00, 0xCE, 0x19, 0x00, 0x00, 0xE7, 0x00, 0x00, 0xCE, 0x00, 0xCE, 0x00, + 0x00, 0xCE, 0x00, 0x00, 0x00, 0xCE, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x32, 0x00, 0xCE, + 0x32, 0x00, 0xCE, 0x00, 0x00, 0x00, 0xE7, 0x00, 0x00, 0x19, 0x00, 0xCE, 0x19, 0x00, 0xCE, 0xE7, + 0x00, 0x00, 0xCE, 0x00, 0x00, 0x00, 0x00, 0xCE, 0x00, 0x00, 0xCE, 0xCE, 0x00, 0x19, 0x00, 0x00, + 0x19, 0x32, 0x00, 0xE7, 0x32, 0x00, 0xE7, 0x00, 0x00, 0x19, 0xE7, 0x00, 0x19, 0x19, 0x00, 0xE7, + 0x19, 0x00, 0xE7, 0xE7, 0x00, 0x19, 0xCE, 0x00, 0x19, 0x00, 0x00, 0xE7, 0x00, 0x00, 0xE7, 0xCE, + 0x00, 0x32, 0x00, 0x00, 0x32, 0x32, 0x00, 0x00, 0x32, 0x00, 0x00, 0x00, 0x00, 0x32, 0xE7, 0x00, + 0x32, 0x19, 0x00, 0x00, 0x19, 0x00, 0x00, 0xE7, 0x00, 0x32, 0xCE, 0x00, 0x32, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0xCE, }; /* 803C4220-803C4240 021340 0020+00 2/2 0/0 0/0 .data jpa_crd */ -SECTION_DATA static u8 jpa_crd[32] = { +static u8 jpa_crd[32] ALIGN_DECL(32) = { 0x00, 0x00, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x00, 0x00, 0x02, 0x00, 0x02, 0x01, 0x00, 0x01, 0x00, 0x00, 0x01, 0x00, 0x01, 0x02, 0x00, 0x02, 0x00, 0x00, 0x02, 0x00, 0x02, 0x02, 0x00, 0x02, }; -/* 803C4240-803C426C -00001 002C+00 1/1 0/0 0/0 .data @2829 */ -SECTION_DATA static void* lit_2829[11] = { - (void*)(((char*)init__11JPAResourceFP7JKRHeap) + 0x1488), - (void*)(((char*)init__11JPAResourceFP7JKRHeap) + 0x149C), - (void*)(((char*)init__11JPAResourceFP7JKRHeap) + 0x13D0), - (void*)(((char*)init__11JPAResourceFP7JKRHeap) + 0x1430), - (void*)(((char*)init__11JPAResourceFP7JKRHeap) + 0x1430), - (void*)(((char*)init__11JPAResourceFP7JKRHeap) + 0x14AC), - (void*)(((char*)init__11JPAResourceFP7JKRHeap) + 0x14AC), - (void*)(((char*)init__11JPAResourceFP7JKRHeap) + 0x1474), - (void*)(((char*)init__11JPAResourceFP7JKRHeap) + 0x1474), - (void*)(((char*)init__11JPAResourceFP7JKRHeap) + 0x1460), - (void*)(((char*)init__11JPAResourceFP7JKRHeap) + 0x1400), -}; - -/* 803C426C-803C4298 -00001 002C+00 1/1 0/0 0/0 .data @2828 */ -SECTION_DATA static void* lit_2828[11] = { - (void*)(((char*)init__11JPAResourceFP7JKRHeap) + 0x112C), - (void*)(((char*)init__11JPAResourceFP7JKRHeap) + 0x1140), - (void*)(((char*)init__11JPAResourceFP7JKRHeap) + 0x1074), - (void*)(((char*)init__11JPAResourceFP7JKRHeap) + 0x10D4), - (void*)(((char*)init__11JPAResourceFP7JKRHeap) + 0x10D4), - (void*)(((char*)init__11JPAResourceFP7JKRHeap) + 0x1150), - (void*)(((char*)init__11JPAResourceFP7JKRHeap) + 0x1150), - (void*)(((char*)init__11JPAResourceFP7JKRHeap) + 0x1118), - (void*)(((char*)init__11JPAResourceFP7JKRHeap) + 0x1118), - (void*)(((char*)init__11JPAResourceFP7JKRHeap) + 0x1104), - (void*)(((char*)init__11JPAResourceFP7JKRHeap) + 0x10A4), -}; - /* 80274080-802755E8 26E9C0 1568+00 2/0 1/1 0/0 .text init__11JPAResourceFP7JKRHeap */ -void JPAResource::init(JKRHeap* param_0) { - // NONMATCHING +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_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(); + + if (is_glbl_tex_anm && is_tex_anm) { + mpCalcEmitterFuncListNum++; + } + + if (is_glbl_clr_anm) { + if (is_prm_anm) { + mpCalcEmitterFuncListNum++; + } + if (is_env_anm) { + mpCalcEmitterFuncListNum++; + } + if (is_prm_anm || is_env_anm) { + mpCalcEmitterFuncListNum++; + } + } + + if (mpCalcEmitterFuncListNum != 0) { + mpCalcEmitterFuncList = + (EmitterFunc*)JKRAllocFromHeap(heap, mpCalcEmitterFuncListNum * 4, 4); + } + + int func_no = 0; + + if (is_glbl_tex_anm && is_tex_anm) { + switch (mpBaseShape->getTexAnmType()) { + case 0: + mpCalcEmitterFuncList[func_no] = &JPACalcTexIdxNormal; + break; + case 1: + mpCalcEmitterFuncList[func_no] = &JPACalcTexIdxRepeat; + break; + case 2: + mpCalcEmitterFuncList[func_no] = &JPACalcTexIdxReverse; + break; + case 3: + mpCalcEmitterFuncList[func_no] = &JPACalcTexIdxMerge; + break; + case 4: + mpCalcEmitterFuncList[func_no] = &JPACalcTexIdxRandom; + break; + } + func_no++; + } + + if (is_glbl_clr_anm) { + if (is_prm_anm) { + mpCalcEmitterFuncList[func_no] = &JPACalcPrm; + func_no++; + } + if (is_env_anm) { + mpCalcEmitterFuncList[func_no] = &JPACalcEnv; + func_no++; + } + if (is_prm_anm || is_env_anm) { + switch (mpBaseShape->getClrAnmType()) { + case 0: + mpCalcEmitterFuncList[func_no] = &JPACalcClrIdxNormal; + break; + case 1: + mpCalcEmitterFuncList[func_no] = &JPACalcClrIdxRepeat; + break; + case 2: + mpCalcEmitterFuncList[func_no] = &JPACalcClrIdxReverse; + break; + case 3: + mpCalcEmitterFuncList[func_no] = &JPACalcClrIdxMerge; + break; + case 4: + mpCalcEmitterFuncList[func_no] = &JPACalcClrIdxRandom; + break; + } + } + } + + if (!is_glbl_tex_anm && is_tex_anm) { + mpCalcParticleFuncListNum++; + } + + if (!base_type_5_6 && (is_enable_alpha_anm || is_enable_alpha_flick)) { + mpCalcParticleFuncListNum++; + } + + if (!is_glbl_clr_anm) { + if (is_prm_anm) { + mpCalcParticleFuncListNum++; + } + if (is_env_anm) { + mpCalcParticleFuncListNum++; + } + if (is_prm_anm || is_env_anm) { + mpCalcParticleFuncListNum++; + } + } else { + mpCalcParticleFuncListNum++; + } + + if (is_enable_scale_anm) { + if (mpBaseShape->getType() != 0) { + if (mpExtraShape->isScaleXYDiff()) { + if (mpExtraShape->getScaleAnmTypeX() == 0 && mpExtraShape->getScaleAnmTypeY() == 0) { + mpCalcParticleFuncListNum++; + } else { + mpCalcParticleFuncListNum++; + mpCalcParticleFuncListNum++; + } + } else { + mpCalcParticleFuncListNum++; + } + } + mpCalcParticleFuncListNum++; + mpCalcParticleFuncListNum++; + } + + if (mpCalcParticleFuncListNum != 0) { + mpCalcParticleFuncList = + (ParticleFunc*)JKRAllocFromHeap(heap, mpCalcParticleFuncListNum * 4, 4); + } + + func_no = 0; + + if (!is_glbl_tex_anm && is_tex_anm) { + switch (mpBaseShape->getTexAnmType()) { + case 0: + mpCalcParticleFuncList[func_no] = &JPACalcTexIdxNormal; + break; + case 1: + mpCalcParticleFuncList[func_no] = &JPACalcTexIdxRepeat; + break; + case 2: + mpCalcParticleFuncList[func_no] = &JPACalcTexIdxReverse; + break; + case 3: + mpCalcParticleFuncList[func_no] = &JPACalcTexIdxMerge; + break; + case 4: + mpCalcParticleFuncList[func_no] = &JPACalcTexIdxRandom; + break; + } + func_no++; + } + + if (!base_type_5_6 && (is_enable_alpha_anm || is_enable_alpha_flick)) { + if (is_enable_alpha_flick) { + mpCalcParticleFuncList[func_no] = &JPACalcAlphaFlickAnm; + func_no++; + } else { + mpCalcParticleFuncList[func_no] = &JPACalcAlphaAnm; + func_no++; + } + } + + if (!is_glbl_clr_anm) { + if (is_prm_anm) { + mpCalcParticleFuncList[func_no] = &JPACalcPrm; + func_no++; + } + if (is_env_anm) { + mpCalcParticleFuncList[func_no] = &JPACalcEnv; + func_no++; + } + if (is_prm_anm || is_env_anm) { + switch (mpBaseShape->getClrAnmType()) { + case 0: + mpCalcParticleFuncList[func_no] = &JPACalcClrIdxNormal; + break; + case 1: + mpCalcParticleFuncList[func_no] = &JPACalcClrIdxRepeat; + break; + case 2: + mpCalcParticleFuncList[func_no] = &JPACalcClrIdxReverse; + break; + case 3: + mpCalcParticleFuncList[func_no] = &JPACalcClrIdxMerge; + break; + case 4: + mpCalcParticleFuncList[func_no] = &JPACalcClrIdxRandom; + break; + } + func_no++; + } + } else { + mpCalcParticleFuncList[func_no] = &JPACalcColorCopy; + func_no++; + } + + if (is_enable_scale_anm) { + if (mpBaseShape->getType() != 0) { + if (mpExtraShape->isScaleXYDiff()) { + mpCalcParticleFuncList[func_no] = &JPACalcScaleY; + func_no++; + if (mpExtraShape->getScaleAnmTypeY() != 0 || mpExtraShape->getScaleAnmTypeX() != 0) { + switch (mpExtraShape->getScaleAnmTypeY()) { + case 0: + mpCalcParticleFuncList[func_no] = &JPACalcScaleAnmNormal; + break; + case 1: + mpCalcParticleFuncList[func_no] = &JPACalcScaleAnmRepeatY; + break; + case 2: + mpCalcParticleFuncList[func_no] = &JPACalcScaleAnmReverseY; + break; + } + func_no++; + } + } else { + mpCalcParticleFuncList[func_no] = &JPACalcScaleCopy; + func_no++; + } + } + mpCalcParticleFuncList[func_no] = &JPACalcScaleX; + func_no++; + switch (mpExtraShape->getScaleAnmTypeX()) { + case 0: + mpCalcParticleFuncList[func_no] = &JPACalcScaleAnmNormal; + break; + case 1: + mpCalcParticleFuncList[func_no] = &JPACalcScaleAnmRepeatX; + break; + case 2: + mpCalcParticleFuncList[func_no] = &JPACalcScaleAnmReverseX; + break; + } + } + + if (mpChildShape != NULL && mpChildShape->isScaleOutOn()) { + mpCalcParticleChildFuncListNum++; + } + + if (mpChildShape != NULL && mpChildShape->isAlphaOutOn()) { + mpCalcParticleChildFuncListNum++; + } + + if (mpCalcParticleChildFuncListNum != 0) { + mpCalcParticleChildFuncList = + (ParticleFunc*)JKRAllocFromHeap(heap, mpCalcParticleChildFuncListNum * 4, 4); + } + + func_no = 0; + + if (mpChildShape != NULL && mpChildShape->isScaleOutOn()) { + mpCalcParticleChildFuncList[func_no] = &JPACalcChildScaleOut; + func_no++; + } + + if (mpChildShape != NULL && mpChildShape->isAlphaOutOn()) { + mpCalcParticleChildFuncList[func_no] = &JPACalcChildAlphaOut; + } + + if (is_draw_parent && base_type_5_6) { + mpDrawEmitterFuncListNum++; + } + + mpDrawEmitterFuncListNum++; + + if (mpExTexShape != NULL) { + mpDrawEmitterFuncListNum++; + } + + if (is_glbl_tex_anm || !is_tex_anm) { + mpDrawEmitterFuncListNum++; + } + + mpDrawEmitterFuncListNum++; + + if (base_type_0_1) { + mpDrawEmitterFuncListNum++; + } + + if (base_type_0_1 && !is_enable_scale_anm) { + mpDrawEmitterFuncListNum++; + } + + if (is_glbl_clr_anm || (!is_prm_anm && !is_enable_alpha_anm) || !is_env_anm) { + mpDrawEmitterFuncListNum++; + } + + if (mpDrawEmitterFuncListNum != 0) { + mpDrawEmitterFuncList = + (EmitterFunc*)JKRAllocFromHeap(heap, mpDrawEmitterFuncListNum * 4, 4); + } + + func_no = 0; + + if (is_draw_parent && base_type_5_6) { + if (mpBaseShape->getType() == 5) { + mpDrawEmitterFuncList[func_no] = &JPADrawStripe; + func_no++; + } else { + mpDrawEmitterFuncList[func_no] = &JPADrawStripeX; + func_no++; + } + } + + mpDrawEmitterFuncList[func_no] = &JPADrawEmitterCallBackB; + func_no++; + + if (mpExTexShape != NULL) { + mpDrawEmitterFuncList[func_no] = &JPALoadExTex; + func_no++; + } + + if (!is_tex_anm) { + mpDrawEmitterFuncList[func_no] = &JPALoadTex; + func_no++; + } else if (is_glbl_tex_anm) { + mpDrawEmitterFuncList[func_no] = &JPALoadTexAnm; + func_no++; + } + + if (base_type_0_1) { + mpDrawEmitterFuncList[func_no] = &JPAGenTexCrdMtxIdt; + func_no++; + } else if (is_prj_tex) { + mpDrawEmitterFuncList[func_no] = &JPAGenTexCrdMtxPrj; + func_no++; + } else if (is_tex_crd_anm) { + if (base_type_5_6) { + mpDrawEmitterFuncList[func_no] = &JPAGenCalcTexCrdMtxAnm; + func_no++; + } else { + mpDrawEmitterFuncList[func_no] = &JPAGenTexCrdMtxAnm; + func_no++; + } + } else { + mpDrawEmitterFuncList[func_no] = &JPAGenTexCrdMtxIdt; + func_no++; + } + + if (base_type_0_1) { + mpDrawEmitterFuncList[func_no] = &JPALoadPosMtxCam; + func_no++; + } + + if (base_type_0_1 && !is_enable_scale_anm) { + if (base_type_0) { + mpDrawEmitterFuncList[func_no] = &JPASetPointSize; + func_no++; + } else { + mpDrawEmitterFuncList[func_no] = &JPASetLineWidth; + func_no++; + } + } + + if (is_glbl_clr_anm) { + if (base_type_5_6 || !is_enable_alpha_anm) { + mpDrawEmitterFuncList[func_no] = &JPARegistPrmEnv; + } else if (is_enable_alpha_anm) { + mpDrawEmitterFuncList[func_no] = &JPARegistEnv; + } + } else if (!is_prm_anm && !is_enable_alpha_anm) { + if (!is_env_anm) { + mpDrawEmitterFuncList[func_no] = &JPARegistPrmEnv; + } else { + mpDrawEmitterFuncList[func_no] = &JPARegistPrm; + } + } else if (!is_env_anm) { + mpDrawEmitterFuncList[func_no] = &JPARegistEnv; + } + + if (is_draw_child && child_type_5_6) { + mpDrawEmitterChildFuncListNum++; + } + + mpDrawEmitterChildFuncListNum++; + + if (child_type_0_1) { + mpDrawEmitterChildFuncListNum++; + } + + if (mpChildShape != NULL && !mpChildShape->isAlphaOutOn() && !mpChildShape->isAlphaInherited() + && !mpChildShape->isColorInherited()) { + mpDrawEmitterChildFuncListNum++; + } + + if (mpDrawEmitterChildFuncListNum != 0) { + mpDrawEmitterChildFuncList = + (EmitterFunc*)JKRAllocFromHeap(heap, mpDrawEmitterChildFuncListNum * 4, 4); + } + + func_no = 0; + + if (is_draw_child && child_type_5_6) { + if (mpChildShape->getType() == 5) { + mpDrawEmitterChildFuncList[func_no] = &JPADrawStripe; + func_no++; + } else { + mpDrawEmitterChildFuncList[func_no] = &JPADrawStripeX; + func_no++; + } + } + + mpDrawEmitterChildFuncList[func_no] = &JPADrawEmitterCallBackB; + func_no++; + + if (child_type_0_1) { + mpDrawEmitterChildFuncList[func_no] = &JPALoadPosMtxCam; + func_no++; + } + + if (mpChildShape != NULL && !mpChildShape->isAlphaOutOn() && !mpChildShape->isAlphaInherited() + && !mpChildShape->isColorInherited()) { + mpDrawEmitterChildFuncList[func_no] = &JPARegistChildPrmEnv; + } + + if (is_draw_parent && !base_type_5_6) { + mpDrawParticleFuncListNum++; + } + + mpDrawParticleFuncListNum++; + + if (!is_glbl_tex_anm && is_tex_anm) { + mpDrawParticleFuncListNum++; + } + + if ((base_type_0_1 && is_enable_scale_anm) || (is_tex_crd_anm && !is_prj_tex)) { + mpDrawParticleFuncListNum++; + } + + if ((!is_glbl_clr_anm && (is_prm_anm || is_env_anm || is_enable_alpha_anm)) + || (is_glbl_clr_anm && is_enable_alpha_anm && !base_type_5_6)) { + mpDrawParticleFuncListNum++; + } + + if (mpDrawParticleFuncListNum != 0) { + mpDrawParticleFuncList = + (ParticleFunc*)JKRAllocFromHeap(heap, mpDrawParticleFuncListNum * 4, 4); + } + + func_no = 0; + + if (is_draw_parent && !base_type_5_6) { + switch (mpBaseShape->getType()) { + case 2: + if (is_enable_rotate_anm) { + mpDrawParticleFuncList[func_no] = &JPADrawRotBillboard; + } else { + mpDrawParticleFuncList[func_no] = &JPADrawBillboard; + } + break; + case 10: + if (is_enable_rotate_anm) { + mpDrawParticleFuncList[func_no] = &JPADrawRotYBillboard; + } else { + mpDrawParticleFuncList[func_no] = &JPADrawYBillboard; + } + break; + case 3: + case 4: + if (is_enable_rotate_anm) { + mpDrawParticleFuncList[func_no] = &JPADrawRotDirection; + } else { + mpDrawParticleFuncList[func_no] = &JPADrawDirection; + } + break; + case 9: + mpDrawParticleFuncList[func_no] = &JPADrawDBillboard; + break; + case 7: + case 8: + mpDrawParticleFuncList[func_no] = &JPADrawRotation; + break; + case 0: + mpDrawParticleFuncList[func_no] = &JPADrawPoint; + break; + case 1: + mpDrawParticleFuncList[func_no] = &JPADrawLine; + break; + } + func_no++; + } + + mpDrawParticleFuncList[func_no] = &JPADrawParticleCallBack; + func_no++; + + if (!is_glbl_tex_anm && is_tex_anm) { + mpDrawParticleFuncList[func_no] = &JPALoadTexAnm; + func_no++; + } + + if (base_type_0_1 && is_enable_scale_anm) { + if (base_type_0) { + mpDrawParticleFuncList[func_no] = &JPASetPointSize; + func_no++; + } else { + mpDrawParticleFuncList[func_no] = &JPASetLineWidth; + func_no++; + } + } else if (is_tex_crd_anm && !is_prj_tex) { + mpDrawParticleFuncList[func_no] = &JPALoadCalcTexCrdMtxAnm; + func_no++; + } + + if (!is_glbl_clr_anm) { + if (is_prm_anm) { + if (is_env_anm) { + mpDrawParticleFuncList[func_no] = &JPARegistPrmAlphaEnv; + } else { + mpDrawParticleFuncList[func_no] = &JPARegistPrmAlpha; + } + } else if (is_enable_alpha_anm) { + if (is_env_anm) { + mpDrawParticleFuncList[func_no] = &JPARegistAlphaEnv; + } else { + mpDrawParticleFuncList[func_no] = &JPARegistAlpha; + } + } else if (is_env_anm) { + mpDrawParticleFuncList[func_no] = &JPARegistEnv; + } + } else if (is_enable_alpha_anm && !base_type_5_6) { + mpDrawParticleFuncList[func_no] = &JPARegistAlpha; + } + + if (is_draw_child && mpChildShape != NULL && !child_type_5_6) { + mpDrawParticleChildFuncListNum++; + } + + mpDrawParticleChildFuncListNum++; + + if (child_type_0_1) { + mpDrawParticleChildFuncListNum++; + } + + if (mpChildShape != NULL && (mpChildShape->isAlphaOutOn() || mpChildShape->isAlphaInherited() + || mpChildShape->isColorInherited())) { + mpDrawParticleChildFuncListNum++; + } + + if (mpDrawParticleChildFuncListNum != 0) { + mpDrawParticleChildFuncList = + (ParticleFunc*)JKRAllocFromHeap(heap, mpDrawParticleChildFuncListNum * 4, 4); + } + + func_no = 0; + + if (is_draw_child && mpChildShape != NULL && !child_type_5_6) { + switch (mpChildShape->getType()) { + case 2: + if (is_rotate_on) { + mpDrawParticleChildFuncList[func_no] = &JPADrawRotBillboard; + } else { + mpDrawParticleChildFuncList[func_no] = &JPADrawBillboard; + } + break; + case 10: + if (is_rotate_on) { + mpDrawParticleChildFuncList[func_no] = &JPADrawRotYBillboard; + } else { + mpDrawParticleChildFuncList[func_no] = &JPADrawYBillboard; + } + break; + case 3: + case 4: + if (is_rotate_on) { + mpDrawParticleChildFuncList[func_no] = &JPADrawRotDirection; + } else { + mpDrawParticleChildFuncList[func_no] = &JPADrawDirection; + } + break; + case 9: + mpDrawParticleChildFuncList[func_no] = &JPADrawDBillboard; + break; + case 7: + case 8: + mpDrawParticleChildFuncList[func_no] = &JPADrawRotation; + break; + case 0: + mpDrawParticleChildFuncList[func_no] = &JPADrawPoint; + break; + case 1: + mpDrawParticleChildFuncList[func_no] = &JPADrawLine; + break; + } + func_no++; + } + + mpDrawParticleChildFuncList[func_no] = &JPADrawParticleCallBack; + func_no++; + + if (child_type_0_1) { + if (child_type_0) { + mpDrawParticleChildFuncList[func_no] = &JPASetPointSize; + func_no++; + } else { + mpDrawParticleChildFuncList[func_no] = &JPASetLineWidth; + func_no++; + } + } + + if (mpChildShape != NULL && (mpChildShape->isAlphaOutOn() || mpChildShape->isAlphaInherited() + || mpChildShape->isColorInherited())) { + mpDrawParticleChildFuncList[func_no] = &JPARegistPrmAlphaEnv; + } } /* 802755E8-80275A94 26FF28 04AC+00 0/0 1/1 0/0 .text * calc__11JPAResourceFP18JPAEmitterWorkDataP14JPABaseEmitter */ -bool JPAResource::calc(JPAEmitterWorkData* param_0, JPABaseEmitter* param_1) { - // NONMATCHING +bool JPAResource::calc(JPAEmitterWorkData* work, JPABaseEmitter* emtr) { + work->mpEmtr = emtr; + work->mpRes = this; + work->mEmitCount = 0; + + if (!emtr->processTillStartFrame()) { + return false; + } + + if (emtr->processTermination()) { + return true; + } + + if (emtr->checkStatus(2)) { + if (emtr->mpEmtrCallBack != NULL) { + emtr->mpEmtrCallBack->execute(emtr); + if (emtr->checkStatus(0x100)) { + return true; + } + emtr->mpEmtrCallBack->executeAfter(emtr); + if (emtr->checkStatus(0x100)) { + return true; + } + } + + } else { + calcKey(work); + + for (int i = mFieldBlockNum - 1; i >= 0; i--) { + mpFieldBlocks[i]->initOpParam(); + } + + if (emtr->mpEmtrCallBack != NULL) { + emtr->mpEmtrCallBack->execute(emtr); + if (emtr->checkStatus(0x100)) { + return true; + } + } + + calcWorkData_c(work); + + for (int i = mpCalcEmitterFuncListNum - 1; i >= 0; i--) { + (*mpCalcEmitterFuncList[i])(work); + } + + for (int i = mFieldBlockNum - 1; i >= 0; i--) { + mpFieldBlocks[i]->prepare(work); + } + + if (!emtr->checkStatus(8)) { + mpDynamicsBlock->create(work); + } + + if (emtr->mpEmtrCallBack != NULL) { + emtr->mpEmtrCallBack->executeAfter(emtr); + if (emtr->checkStatus(0x100)) { + return true; + } + } + + JPANode* node = emtr->mAlivePtclBase.getFirst(); + JPANode* next; + while (node != emtr->mAlivePtclBase.getEnd()) { + 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()) { + next = node->getNext(); + if (node->getObject()->calc_c(work)) { + emtr->mpPtclPool->push_front(emtr->mAlivePtclChld.erase(node)); + } + node = next; + } + + emtr->mTick++; + } + + return false; } /* 80275A94-80275B74 2703D4 00E0+00 0/0 1/1 0/0 .text @@ -599,102 +803,309 @@ void JPAResource::draw(JPAEmitterWorkData* work, JPABaseEmitter* emtr) { } } -/* ############################################################################################## */ -/* 80455290-80455294 003890 0004+00 2/2 0/0 0/0 .sdata2 @3189 */ -SECTION_SDATA2 static f32 lit_3189 = 51.0f / 50.0f; - -/* 80455294-80455298 003894 0004+00 2/2 0/0 0/0 .sdata2 @3190 */ -SECTION_SDATA2 static f32 lit_3190 = 2.0f / 5.0f; - -/* 80455298-8045529C 003898 0004+00 1/1 0/0 0/0 .sdata2 @3191 */ -SECTION_SDATA2 static f32 lit_3191 = 1.0f; - -/* 8045529C-804552A0 00389C 0004+00 2/2 0/0 0/0 .sdata2 @3192 */ -SECTION_SDATA2 static u8 lit_3192[4] = { - 0x00, - 0x00, - 0x00, - 0x00, -}; - -/* 804552A0-804552A8 0038A0 0008+00 3/3 0/0 0/0 .sdata2 @3194 */ -SECTION_SDATA2 static f64 lit_3194 = 4503599627370496.0 /* cast u32 to float */; - /* 80275B74-80275EB0 2704B4 033C+00 1/1 0/0 0/0 .text drawP__11JPAResourceFP18JPAEmitterWorkData */ -void JPAResource::drawP(JPAEmitterWorkData* param_0) { - // NONMATCHING +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(); + + if (mpBaseShape->getType() == 0) { + work->mGlobalPtclScl.x *= 1.02f; + } else if (mpBaseShape->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; + } 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->mpAlivePtcl = &work->mpEmtr->mAlivePtclBase; + setPTev(); + + for (int i = mpDrawEmitterFuncListNum - 1; i >= 0; i--) { + (*mpDrawEmitterFuncList[i])(work); + } + + if (mpBaseShape->isDrawFwdAhead()) { + JPANode* node = work->mpEmtr->mAlivePtclBase.getLast(); + for (; node != work->mpEmtr->mAlivePtclBase.getEnd(); node = node->getPrev()) { + work->mpCurNode = node; + if (mpDrawParticleFuncList != NULL) { + for (int i = mpDrawParticleFuncListNum - 1; i >= 0; i--) { + (*mpDrawParticleFuncList[i])(work, node->getObject()); + } + } + } + } else { + JPANode* node = work->mpEmtr->mAlivePtclBase.getFirst(); + for (; node != work->mpEmtr->mAlivePtclBase.getEnd(); node = node->getNext()) { + work->mpCurNode = node; + if (mpDrawParticleFuncList != NULL) { + for (int i = mpDrawParticleFuncListNum - 1; i >= 0; i--) { + (*mpDrawParticleFuncList[i])(work, node->getObject()); + } + } + } + } + + GXSetMisc(GX_MT_XF_FLUSH, 0); + + if (work->mpEmtr->mpEmtrCallBack != NULL) { + work->mpEmtr->mpEmtrCallBack->drawAfter(work->mpEmtr); + } } /* 80275EB0-802761A8 2707F0 02F8+00 1/1 0/0 0/0 .text drawC__11JPAResourceFP18JPAEmitterWorkData */ -void JPAResource::drawC(JPAEmitterWorkData* param_0) { - // NONMATCHING +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(); + } else { + work->mGlobalPtclScl.x = work->mpEmtr->mGlobalPScl.x * mpChildShape->getScaleX(); + work->mGlobalPtclScl.y = work->mpEmtr->mGlobalPScl.y * mpChildShape->getScaleY(); + } + + if (mpChildShape->getType() == 0) { + work->mGlobalPtclScl.x *= 1.02f; + } else if (mpChildShape->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->mPrjType = 0; + + work->mpAlivePtcl = &work->mpEmtr->mAlivePtclChld; + setCTev(work); + + for (int i = mpDrawEmitterChildFuncListNum - 1; i >= 0; i--) { + (*mpDrawEmitterChildFuncList[i])(work); + } + + if (mpBaseShape->isDrawFwdAhead()) { + JPANode* node = work->mpEmtr->mAlivePtclChld.getLast(); + for (; node != work->mpEmtr->mAlivePtclChld.getEnd(); node = node->getPrev()) { + work->mpCurNode = node; + if (mpDrawParticleChildFuncList != NULL) { + for (int i = mpDrawParticleChildFuncListNum - 1; i >= 0; i--) { + (*mpDrawParticleChildFuncList[i])(work, node->getObject()); + } + } + } + } else { + JPANode* node = work->mpEmtr->mAlivePtclChld.getFirst(); + for (; node != work->mpEmtr->mAlivePtclChld.getEnd(); node = node->getNext()) { + work->mpCurNode = node; + if (mpDrawParticleChildFuncList != NULL) { + for (int i = mpDrawParticleChildFuncListNum - 1; i >= 0; i--) { + (*mpDrawParticleChildFuncList[i])(work, node->getObject()); + } + } + } + } + + GXSetMisc(GX_MT_XF_FLUSH, 0); + + if (work->mpEmtr->mpEmtrCallBack != NULL) { + work->mpEmtr->mpEmtrCallBack->drawAfter(work->mpEmtr); + } } /* 802761A8-8027642C 270AE8 0284+00 1/1 0/0 0/0 .text setPTev__11JPAResourceFv */ void JPAResource::setPTev() { - // NONMATCHING + GXTexCoordID tex_coord = GX_TEXCOORD1; + u8 tev_stages = 1; + 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 pos_offset = center_offset + base_plane_type * 0x6C; + int crd_offset = (mpBaseShape->getTilingS() + 2 * mpBaseShape->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); + GXSetIndTexCoordScale(GX_INDTEXSTAGE0, GX_ITS_1, GX_ITS_1); + GXSetIndTexMtx(GX_ITM_0, (f32*)mpExTexShape->getIndTexMtx(), + mpExTexShape->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()) { + 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); + GXSetTevColorOp(GX_TEVSTAGE1, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_TRUE, + GX_TEVPREV); + GXSetTevAlphaOp(GX_TEVSTAGE1, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_TRUE, + GX_TEVPREV); + tev_stages++; + tex_gens++; + } + } + + GXSetNumTevStages(tev_stages); + GXSetNumIndStages(ind_stages); + if (mpBaseShape->isClipOn()) { + GXSetMisc(GX_MT_XF_FLUSH, 8); + GXSetClipMode(GX_CLIP_ENABLE); + } else { + GXSetClipMode(GX_CLIP_DISABLE); + } + GXSetNumTexGens(tex_gens); } /* 8027642C-8027658C 270D6C 0160+00 1/1 0/0 0/0 .text setCTev__11JPAResourceFP18JPAEmitterWorkData */ -void JPAResource::setCTev(JPAEmitterWorkData* param_0) { - // NONMATCHING +void JPAResource::setCTev(JPAEmitterWorkData* work) { + int base_plane_type = (mpChildShape->getType() == 3 || mpChildShape->getType() == 7) ? + mpChildShape->getBasePlaneType() : 0; + int pos_offset = 0x30 + base_plane_type * 0x6C; + GXSetArray(GX_VA_POS, jpa_pos + pos_offset, 3); + GXSetArray(GX_VA_TEX0, jpa_crd, 2); + GXSetTevOrder(GX_TEVSTAGE0, GX_TEXCOORD0, GX_TEXMAP1, GX_COLOR_NULL); + GXSetTexCoordGen(GX_TEXCOORD0, GX_TG_MTX2x4, GX_TG_TEX0, 0x3C); + GXSetTevDirect(GX_TEVSTAGE0); + GXSetNumTevStages(1); + GXSetNumIndStages(0); + if (mpChildShape->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); } /* 8027658C-80276608 270ECC 007C+00 0/0 1/1 0/0 .text * calc_p__11JPAResourceFP18JPAEmitterWorkDataP15JPABaseParticle */ -void JPAResource::calc_p(JPAEmitterWorkData* param_0, JPABaseParticle* param_1) { - // NONMATCHING +void JPAResource::calc_p(JPAEmitterWorkData* work, JPABaseParticle* ptcl) { + if (mpCalcParticleFuncList != NULL) { + for (int i = mpCalcParticleFuncListNum - 1; i >= 0; i--) { + (*mpCalcParticleFuncList[i])(work, ptcl); + } + } } /* 80276608-80276684 270F48 007C+00 0/0 1/1 0/0 .text * calc_c__11JPAResourceFP18JPAEmitterWorkDataP15JPABaseParticle */ -void JPAResource::calc_c(JPAEmitterWorkData* param_0, JPABaseParticle* param_1) { - // NONMATCHING +void JPAResource::calc_c(JPAEmitterWorkData* work, JPABaseParticle* ptcl) { + if (mpCalcParticleChildFuncList != NULL) { + for (int i = mpCalcParticleChildFuncListNum - 1; i >= 0; i--) { + (*mpCalcParticleChildFuncList[i])(work, ptcl); + } + } } /* 80276684-80276700 270FC4 007C+00 0/0 2/2 0/0 .text * calcField__11JPAResourceFP18JPAEmitterWorkDataP15JPABaseParticle */ -void JPAResource::calcField(JPAEmitterWorkData* param_0, JPABaseParticle* param_1) { - // NONMATCHING +void JPAResource::calcField(JPAEmitterWorkData* work, JPABaseParticle* ptcl) { + for (int i = mFieldBlockNum - 1; i >= 0; i--) { + mpFieldBlocks[i]->calc(work, ptcl); + } } -/* ############################################################################################## */ -/* 803C4298-803C42E0 -00001 002C+1C 1/1 0/0 0/0 .data @3454 */ -SECTION_DATA static void* lit_3454[11 + 7 /* padding */] = { - (void*)(((char*)calcKey__11JPAResourceFP18JPAEmitterWorkData) + 0x90), - (void*)(((char*)calcKey__11JPAResourceFP18JPAEmitterWorkData) + 0x9C), - (void*)(((char*)calcKey__11JPAResourceFP18JPAEmitterWorkData) + 0x110), - (void*)(((char*)calcKey__11JPAResourceFP18JPAEmitterWorkData) + 0xB4), - (void*)(((char*)calcKey__11JPAResourceFP18JPAEmitterWorkData) + 0xC0), - (void*)(((char*)calcKey__11JPAResourceFP18JPAEmitterWorkData) + 0x110), - (void*)(((char*)calcKey__11JPAResourceFP18JPAEmitterWorkData) + 0xD8), - (void*)(((char*)calcKey__11JPAResourceFP18JPAEmitterWorkData) + 0xE4), - (void*)(((char*)calcKey__11JPAResourceFP18JPAEmitterWorkData) + 0xF0), - (void*)(((char*)calcKey__11JPAResourceFP18JPAEmitterWorkData) + 0xFC), - (void*)(((char*)calcKey__11JPAResourceFP18JPAEmitterWorkData) + 0x108), - /* padding */ - NULL, - NULL, - NULL, - NULL, - NULL, - NULL, - NULL, -}; - /* 80276700-80276840 271040 0140+00 2/1 0/0 0/0 .text calcKey__11JPAResourceFP18JPAEmitterWorkData */ -void JPAResource::calcKey(JPAEmitterWorkData* param_0) { - // NONMATCHING +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()) { + case 0: + work->mpEmtr->mRate = val; + break; + case 1: + work->mpEmtr->mVolumeSize = val; + break; + case 3: + work->mpEmtr->mVolumeMinRad = val; + break; + case 4: + work->mpEmtr->mLifeTime = val; + break; + case 6: + work->mpEmtr->mAwayFromCenterSpeed = val; + break; + case 7: + work->mpEmtr->mAwayFromAxisSpeed = val; + break; + case 8: + work->mpEmtr->mDirSpeed = val; + break; + case 9: + work->mpEmtr->mSpread = val; + break; + case 10: + work->mpEmtr->mScaleOut = val; + break; + } + } } /* 80276840-80276A0C 271180 01CC+00 1/1 0/0 0/0 .text * calcWorkData_c__11JPAResourceFP18JPAEmitterWorkData */ -void JPAResource::calcWorkData_c(JPAEmitterWorkData* param_0) { - // NONMATCHING +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->mVolumeAngleMax = 1; + work->mDivNumber = mpDynamicsBlock->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); + JPAGetXYZRotateMtx(work->mpEmtr->mLocalRot.x * 182, work->mpEmtr->mLocalRot.y * 182, + work->mpEmtr->mLocalRot.z * 182, local_rot_mtx); + MTXScale(global_mtx, work->mpEmtr->mGlobalScl.x, work->mpEmtr->mGlobalScl.y, + work->mpEmtr->mGlobalScl.z); + MTXConcat(work->mpEmtr->mGlobalRot, global_mtx, global_mtx); + global_mtx[0][3] = work->mpEmtr->mGlobalTrs.x; + global_mtx[1][3] = work->mpEmtr->mGlobalTrs.y; + global_mtx[2][3] = work->mpEmtr->mGlobalTrs.z; + MTXCopy(work->mpEmtr->mGlobalRot, work->mRotationMtx); + MTXConcat(work->mRotationMtx, local_rot_mtx, work->mGlobalRot); + MTXConcat(work->mGlobalRot, local_scl_mtx, work->mGlobalSR); + work->mEmitterPos.set(work->mpEmtr->mLocalTrs); + work->mGlobalScl.mul(work->mpEmtr->mGlobalScl, work->mpEmtr->mLocalScl); + JPAGetDirMtx(work->mpEmtr->mLocalDir, work->mDirectionMtx); + work->mPublicScale.set(work->mpEmtr->mGlobalScl); + MTXMultVec(global_mtx, &work->mpEmtr->mLocalTrs, &work->mGlobalPos); } /* 80276A0C-80276A8C 27134C 0080+00 1/1 0/0 0/0 .text @@ -704,11 +1115,5 @@ void JPAResource::calcWorkData_d(JPAEmitterWorkData* work) { JPAGetXYZRotateMtx(work->mpEmtr->mLocalRot.x * 0xB6, work->mpEmtr->mLocalRot.y * 0xB6, work->mpEmtr->mLocalRot.z * 0xB6, mtx); MTXConcat(work->mpEmtr->mGlobalRot, mtx, work->mGlobalRot); - MTXMultVecSR(work->mGlobalRot, (Vec*)&work->mpEmtr->mLocalDir, (Vec*)&work->mGlobalEmtrDir); + MTXMultVecSR(work->mGlobalRot, &work->mpEmtr->mLocalDir, &work->mGlobalEmtrDir); } - -/* 80276A8C-80276A90 2713CC 0004+00 0/0 3/0 0/0 .text - * prepare__12JPAFieldBaseFP18JPAEmitterWorkDataP13JPAFieldBlock */ -void JPAFieldBase::prepare(JPAEmitterWorkData* param_0, JPAFieldBlock* param_1) { - /* empty function */ -} \ No newline at end of file diff --git a/src/JSystem/JParticle/JPAResourceLoader.cpp b/src/JSystem/JParticle/JPAResourceLoader.cpp index 66f3cd6e58b..580e913afeb 100644 --- a/src/JSystem/JParticle/JPAResourceLoader.cpp +++ b/src/JSystem/JParticle/JPAResourceLoader.cpp @@ -4,93 +4,103 @@ // #include "JSystem/JParticle/JPAResourceLoader.h" -#include "dolphin/types.h" - -// -// Types: -// - -struct JPATexture { - /* 8027D7D4 */ JPATexture(u8 const*); -}; - -struct JKRHeap {}; - -struct JPAResource { - /* 80274010 */ JPAResource(); - /* 80274080 */ void init(JKRHeap*); -}; - -struct JPAResourceManager { - /* 80273F8C */ void registRes(JPAResource*); - /* 80273FAC */ void registTex(JPATexture*); -}; - -struct JPAResourceLoader { - /* 8027D8A0 */ JPAResourceLoader(u8 const*, JPAResourceManager*); - /* 8027D8E0 */ void load_jpc(u8 const*, JPAResourceManager*); -}; - -struct JPAKeyBlock { - /* 8027D730 */ JPAKeyBlock(u8 const*); -}; - -struct JPAFieldBlock { - /* 8027D088 */ JPAFieldBlock(u8 const*, JKRHeap*); -}; - -struct JPAExtraShape { - /* 8027AD88 */ JPAExtraShape(u8 const*); -}; - -struct JPADynamicsBlock { - /* 8027BB18 */ JPADynamicsBlock(u8 const*); -}; - -struct JPABaseShape { - /* 8027A6DC */ JPABaseShape(u8 const*, JKRHeap*); -}; - -// -// Forward References: -// - -extern "C" void __ct__17JPAResourceLoaderFPCUcP18JPAResourceManager(); -extern "C" void load_jpc__17JPAResourceLoaderFPCUcP18JPAResourceManager(); - -// -// External References: -// - -extern "C" void registRes__18JPAResourceManagerFP11JPAResource(); -extern "C" void registTex__18JPAResourceManagerFP10JPATexture(); -extern "C" void __ct__11JPAResourceFv(); -extern "C" void init__11JPAResourceFP7JKRHeap(); -extern "C" void __ct__12JPABaseShapeFPCUcP7JKRHeap(); -extern "C" void __ct__13JPAExtraShapeFPCUc(); -extern "C" void __ct__13JPAChildShapeFPCUc(); -extern "C" void __ct__13JPAExTexShapeFPCUc(); -extern "C" void __ct__16JPADynamicsBlockFPCUc(); -extern "C" void __ct__13JPAFieldBlockFPCUcP7JKRHeap(); -extern "C" void __ct__11JPAKeyBlockFPCUc(); -extern "C" void __ct__10JPATextureFPCUc(); -extern "C" void* __nw__FUlP7JKRHeapi(); -extern "C" void* __nwa__FUlP7JKRHeapi(); -extern "C" void _savegpr_18(); -extern "C" void _restgpr_18(); - -// -// Declarations: -// +#include "JSystem/JKernel/JKRHeap.h" +#include "JSystem/JParticle/JPABaseShape.h" +#include "JSystem/JParticle/JPAChildShape.h" +#include "JSystem/JParticle/JPADynamicsBlock.h" +#include "JSystem/JParticle/JPAExTexShape.h" +#include "JSystem/JParticle/JPAExtraShape.h" +#include "JSystem/JParticle/JPAFieldBlock.h" +#include "JSystem/JParticle/JPAKeyBlock.h" +#include "JSystem/JParticle/JPAResource.h" +#include "JSystem/JParticle/JPAResourceManager.h" /* 8027D8A0-8027D8E0 2781E0 0040+00 0/0 1/1 0/0 .text * __ct__17JPAResourceLoaderFPCUcP18JPAResourceManager */ -JPAResourceLoader::JPAResourceLoader(u8 const* param_0, JPAResourceManager* param_1) { - // NONMATCHING +JPAResourceLoader::JPAResourceLoader(u8 const* data, JPAResourceManager* mgr) { + if (*(u32*)(data + 4) == '2-10') { + load_jpc(data, mgr); + } } +struct JPAResourceHeader { + /* 0x0 */ u16 mUsrIdx; + /* 0x2 */ u16 mBlockNum; + /* 0x4 */ u8 mFieldBlockNum; + /* 0x5 */ u8 mKeyBlockNum; + /* 0x6 */ u8 mTDB1Num; +}; + /* 8027D8E0-8027DCA0 278220 03C0+00 1/1 0/0 0/0 .text * load_jpc__17JPAResourceLoaderFPCUcP18JPAResourceManager */ -void JPAResourceLoader::load_jpc(u8 const* param_0, JPAResourceManager* param_1) { - // NONMATCHING -} \ No newline at end of file +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]; + + 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; + + offset += 8; + u32 field_idx = 0; + u32 key_idx = 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++; + break; + case 'KFA1': + res->mpKeyBlocks[key_idx] = new (heap, 0) JPAKeyBlock(data + offset); + key_idx++; + break; + case 'BEM1': + res->mpDynamicsBlock = new (heap, 0) JPADynamicsBlock(data + offset); + break; + case 'BSP1': + res->mpBaseShape = new (heap, 0) JPABaseShape(data + offset, heap); + break; + case 'ESP1': + res->mpExtraShape = new (heap, 0) JPAExtraShape(data + offset); + break; + case 'SSP1': + res->mpChildShape = new (heap, 0) JPAChildShape(data + offset); + break; + case 'ETX1': + res->mpExTexShape = new (heap, 0) JPAExTexShape(data + offset); + break; + case 'TDB1': + res->mpTDB1 = (const u16*)(data + offset + 8); + break; + } + offset += size; + } + + res->init(heap); + mgr->registRes(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); + offset += size; + } +} diff --git a/src/d/actor/d_a_ep.cpp b/src/d/actor/d_a_ep.cpp index fbc9b3f6400..9e3e29d3bf4 100644 --- a/src/d/actor/d_a_ep.cpp +++ b/src/d/actor/d_a_ep.cpp @@ -148,10 +148,6 @@ struct _GXTexObj {}; struct LIGHT_INFLUENCE {}; -struct JMath { - static u8 sincosTable_[65536]; -}; - struct J3DUClipper { /* 8027378C */ void calcViewFrustum(); }; @@ -286,7 +282,6 @@ extern "C" void MtxPosition__FP4cXyzP4cXyz(); extern "C" void calcViewFrustum__11J3DUClipperFv(); extern "C" void seStart__7Z2SeMgrF10JAISoundIDPC3VecUlScffffUc(); extern "C" void __dl__FPv(); -extern "C" void PSMTXCopy(); extern "C" void __construct_array(); extern "C" void _savegpr_22(); extern "C" void _savegpr_25(); @@ -1170,4 +1165,4 @@ static void func_8046AFB4() { // NONMATCHING } -/* 8046B0D0-8046B0D0 00010C 0000+00 0/0 0/0 0/0 .rodata @stringBase0 */ \ No newline at end of file +/* 8046B0D0-8046B0D0 00010C 0000+00 0/0 0/0 0/0 .rodata @stringBase0 */