diff --git a/include/JSystem/JParticle/JPABaseShape.h b/include/JSystem/JParticle/JPABaseShape.h index 66ec3fa9..2b6e125e 100644 --- a/include/JSystem/JParticle/JPABaseShape.h +++ b/include/JSystem/JParticle/JPABaseShape.h @@ -28,18 +28,18 @@ struct JPABaseShapeData { /* 0x1C */ u8 mAlphaRef1; /* 0x1D */ u8 mZModeCfg; /* 0x1E */ u8 mTexFlg; - /* 0x1F */ u8 mTexAnmNum; + /* 0x1F */ u8 texAnmKeyNum; /* 0x20 */ u8 mTexIdx; /* 0x21 */ u8 mClrFlg; - /* 0x22 */ u8 mClrPrmKeyNum; - /* 0x23 */ u8 mClrEnvKeyNum; + /* 0x22 */ u8 prmAnmKeyNum; + /* 0x23 */ u8 envAnmKeyNum; /* 0x24 */ s16 mClrAnmFrmMax; /* 0x26 */ GXColor mClrPrm; /* 0x2A */ GXColor mClrEnv; /* 0x2E */ u8 mAnmRndm; /* 0x2F */ u8 mClrAnmRndmMask; /* 0x30 */ u8 mTexAnmRndmMask; -}; +}; // Size: 0x34 struct JPABaseShapeAlphaArg { GXTevAlphaArg mArg[4]; @@ -64,62 +64,62 @@ public: static GXTevColorArg st_ca[6][4]; static JPABaseShapeAlphaArg st_aa[5]; - GXBlendMode getBlendMode() const { return st_bm[mpData->mBlendModeCfg & 0x03]; } - GXBlendFactor getBlendSrc() const { return st_bf[(mpData->mBlendModeCfg >> 2) & 0x0F]; } - GXBlendFactor getBlendDst() const { return st_bf[(mpData->mBlendModeCfg >> 6) & 0x0F]; } - GXLogicOp getLogicOp() const { return st_lo[(mpData->mBlendModeCfg >> 10) & 0x0F]; } - GXBool getZCompLoc() const { return (GXBool)((mpData->mZModeCfg >> 5) & 0x01); } + GXBlendMode getBlendMode() const { return st_bm[pBsd->mBlendModeCfg & 0x03]; } + GXBlendFactor getBlendSrc() const { return st_bf[(pBsd->mBlendModeCfg >> 2) & 0x0F]; } + GXBlendFactor getBlendDst() const { return st_bf[(pBsd->mBlendModeCfg >> 6) & 0x0F]; } + GXLogicOp getLogicOp() const { return st_lo[(pBsd->mBlendModeCfg >> 10) & 0x0F]; } + GXBool getZCompLoc() const { return (GXBool)((pBsd->mZModeCfg >> 5) & 0x01); } - GXBool getZEnable() const { return (GXBool)(mpData->mZModeCfg & 0x01); } - GXCompare getZCmp() const { return st_c[(mpData->mZModeCfg >> 1) & 0x07]; } - GXBool getZUpd() const { return (GXBool)((mpData->mZModeCfg >> 4) & 0x01); } + GXBool getZEnable() const { return (GXBool)(pBsd->mZModeCfg & 0x01); } + GXCompare getZCmp() const { return st_c[(pBsd->mZModeCfg >> 1) & 0x07]; } + GXBool getZUpd() const { return (GXBool)((pBsd->mZModeCfg >> 4) & 0x01); } - GXCompare getAlphaCmp0() const { return st_c[mpData->mAlphaCompareCfg & 0x07]; } - u8 getAlphaRef0() const { return mpData->mAlphaRef0; } - GXAlphaOp getAlphaOp() const { return st_ao[(mpData->mAlphaCompareCfg >> 3) & 0x03]; } - GXCompare getAlphaCmp1() const { return st_c[(mpData->mAlphaCompareCfg >> 5) & 0x07]; } - u8 getAlphaRef1() const { return mpData->mAlphaRef1; } + GXCompare getAlphaCmp0() const { return st_c[pBsd->mAlphaCompareCfg & 0x07]; } + u8 getAlphaRef0() const { return pBsd->mAlphaRef0; } + GXAlphaOp getAlphaOp() const { return st_ao[(pBsd->mAlphaCompareCfg >> 3) & 0x03]; } + GXCompare getAlphaCmp1() const { return st_c[(pBsd->mAlphaCompareCfg >> 5) & 0x07]; } + u8 getAlphaRef1() const { return pBsd->mAlphaRef1; } - const GXTevColorArg* getTevColorArg() const { return st_ca[(mpData->mFlags >> 0x0F) & 0x07]; } - const JPABaseShapeAlphaArg* getTevAlphaArg() const { return &st_aa[(mpData->mFlags >> 0x12) & 0x07]; } + const GXTevColorArg* getTevColorArg() const { return st_ca[(pBsd->mFlags >> 0x0F) & 0x07]; } + const JPABaseShapeAlphaArg* getTevAlphaArg() const { return &st_aa[(pBsd->mFlags >> 0x12) & 0x07]; } - u32 getType() const { return (mpData->mFlags >> 0) & 0x0F; } - u32 getDirType() const { return (mpData->mFlags >> 4) & 0x07; } - u32 getRotType() const { return (mpData->mFlags >> 7) & 0x07; } - u32 getBasePlaneType() const { return (mpData->mFlags >> 10) & 0x01; } - u32 getTilingS() const { return (mpData->mFlags >> 27) & 0x01; } // was 25 - u32 getTilingT() const { return (mpData->mFlags >> 28) & 0x01; } // was 26 - BOOL isGlblClrAnm() const { return mpData->mFlags & 0x00001000; } - BOOL isGlblTexAnm() const { return mpData->mFlags & 0x00004000; } - BOOL isPrjTex() const { return mpData->mFlags & 0x00400000; } // was 0x00100000 - bool isDrawFwdAhead() const { return !!(mpData->mFlags & 0x00800000); } // was 0x00200000 - bool isDrawPrntAhead() const { return !!(mpData->mFlags & 0x01000000); } // was 0x00400000 - BOOL isClipOn() const { return (mpData->mFlags & 0x02000000); } // was 0x00800000 - BOOL isTexCrdAnm() const { return mpData->mFlags & 0x04000000; } // was 0x01000000 - bool isNoDrawParent() const { return !!((mpData->mFlags >> 29) & 1); } // was 0x08000000 - bool isNoDrawChild() const { return !!((mpData->mFlags >> 30) & 1); } // was 0x10000000 + u32 getType() const { return (pBsd->mFlags >> 0) & 0x0F; } + u32 getDirType() const { return (pBsd->mFlags >> 4) & 0x07; } + u32 getRotType() const { return (pBsd->mFlags >> 7) & 0x07; } + u32 getBasePlaneType() const { return (pBsd->mFlags >> 10) & 0x01; } + u32 getTilingS() const { return (pBsd->mFlags >> 27) & 0x01; } // was 25 + u32 getTilingT() const { return (pBsd->mFlags >> 28) & 0x01; } // was 26 + BOOL isGlblClrAnm() const { return pBsd->mFlags & 0x00001000; } + BOOL isGlblTexAnm() const { return pBsd->mFlags & 0x00004000; } + BOOL isPrjTex() const { return pBsd->mFlags & 0x00400000; } // was 0x00100000 + BOOL isDrawFwdAhead() const { return pBsd->mFlags & 0x00800000; } // was 0x00200000 + BOOL isDrawPrntAhead() const { return pBsd->mFlags & 0x01000000; } // was 0x00400000 + BOOL isClipOn() const { return pBsd->mFlags & 0x02000000; } // was 0x00800000 + BOOL isTexCrdAnm() const { return pBsd->mFlags & 0x04000000; } // was 0x01000000 + BOOL isNoDrawParent() const { return pBsd->mFlags >> 29 & 1; } // was 0x08000000 + BOOL isNoDrawChild() const { return pBsd->mFlags >> 30 & 1; } // was 0x10000000 - BOOL isPrmAnm() const { return mpData->mClrFlg & 0x02; } - BOOL isEnvAnm() const { return mpData->mClrFlg & 0x08; } - u8 getClrAnmType() const { return (mpData->mClrFlg >> 4) & 0x07; } - s16 getClrAnmMaxFrm() const { return mpData->mClrAnmFrmMax; } - void getPrmClr(GXColor* dst) { *dst = mpData->mClrPrm; } - void getPrmClr(s16 idx, GXColor* dst) { *dst = mpPrmClrAnmTbl[idx]; } - void getEnvClr(GXColor* dst) { *dst = mpData->mClrEnv; } - void getEnvClr(s16 idx, GXColor* dst) { *dst = mpEnvClrAnmTbl[idx]; } + BOOL isPrmAnm() const { return pBsd->mClrFlg & 0x02; } + BOOL isEnvAnm() const { return pBsd->mClrFlg & 0x08; } + u32 getClrAnmType() const { return (pBsd->mClrFlg >> 4) & 0x07; } + s16 getClrAnmMaxFrm() const { return pBsd->mClrAnmFrmMax; } + void getPrmClr(GXColor* dst) const { *dst = pBsd->mClrPrm; } + void getPrmClr(s16 idx, GXColor* dst) const { *dst = mpPrmClrAnmTbl[idx]; } + void getEnvClr(GXColor* dst) const { *dst = pBsd->mClrEnv; } + void getEnvClr(s16 idx, GXColor* dst) const { *dst = mpEnvClrAnmTbl[idx]; } - BOOL isTexAnm() const { return mpData->mTexFlg & 0x01; } - u8 getTexAnmType() const { return (mpData->mTexFlg >> 2) & 0x07; } - u32 getTexIdx() const { return mpData->mTexIdx; } + BOOL isTexAnm() const { return pBsd->mTexFlg & 0x01; } + u32 getTexAnmType() const { return (pBsd->mTexFlg >> 2) & 0x07; } + u8 getTexIdx() const { return pBsd->mTexIdx; } u8 getTexIdx(u8 idx) const { return mpTexIdxAnimTbl[idx]; } - f32 getBaseSizeX() const { return mpData->mBaseSizeX; } - f32 getBaseSizeY() const { return mpData->mBaseSizeY; } - u8 getClrLoopOfstMask() const { return mpData->mClrAnmRndmMask; } - u32 getClrLoopOfst(u32 param_1) const { return getClrLoopOfstMask() & param_1; } - u8 getTexLoopOfstMask() const { return mpData->mTexAnmRndmMask; } - u32 getTexLoopOfst(u8 param_1) const { return getTexLoopOfstMask() & param_1; } - u8 getLoopOfstValue() const { return mpData->mAnmRndm; } + f32 getBaseSizeX() const { return pBsd->mBaseSizeX; } + f32 getBaseSizeY() const { return pBsd->mBaseSizeY; } + u8 getClrLoopOfstMask() const { return pBsd->mClrAnmRndmMask; } + s32 getClrLoopOfst(u8 param_1) const { return getClrLoopOfstMask() & param_1; } + u8 getTexLoopOfstMask() const { return pBsd->mTexAnmRndmMask; } + s32 getTexLoopOfst(u8 param_1) const { return getTexLoopOfstMask() & param_1; } + u8 getLoopOfstValue() const { return pBsd->mAnmRndm; } f32 getIncTransX() const { return ((f32*)mpTexCrdMtxAnmTbl)[5]; } f32 getInitTransX() const { return ((f32*)mpTexCrdMtxAnmTbl)[0]; } @@ -131,10 +131,10 @@ public: f32 getInitScaleY() const { return ((f32*)mpTexCrdMtxAnmTbl)[3]; } f32 getIncRot() const { return ((f32*)mpTexCrdMtxAnmTbl)[9]; } f32 getInitRot() const { return ((f32*)mpTexCrdMtxAnmTbl)[4]; } - u8 getTexAnmKeyNum() const { return mpData->mTexAnmNum; } + u8 getTexAnmKeyNum() const { return pBsd->texAnmKeyNum; } public: - /* 0x00 */ const JPABaseShapeData* mpData; + /* 0x00 */ const JPABaseShapeData* pBsd; /* 0x04 */ const void* mpTexCrdMtxAnmTbl; /* 0x08 */ const u8* mpTexIdxAnimTbl; /* 0x0C */ GXColor* mpPrmClrAnmTbl; diff --git a/include/JSystem/JParticle/JPAChildShape.h b/include/JSystem/JParticle/JPAChildShape.h index f408274a..99302187 100644 --- a/include/JSystem/JParticle/JPAChildShape.h +++ b/include/JSystem/JParticle/JPAChildShape.h @@ -82,6 +82,7 @@ public: /* 0x00 */ const JPAChildShapeData* mpData; }; +// SS addition void fn_8031DBA0(JPAEmitterWorkData*); void JPARegistChildPrmEnv(JPAEmitterWorkData*); diff --git a/include/JSystem/JParticle/JPADrawInfo.h b/include/JSystem/JParticle/JPADrawInfo.h index ed269d7f..d964e932 100644 --- a/include/JSystem/JParticle/JPADrawInfo.h +++ b/include/JSystem/JParticle/JPADrawInfo.h @@ -11,12 +11,12 @@ class JPADrawInfo { public: JPADrawInfo() {} - JPADrawInfo(Mtx param_0, f32 fovY, f32 aspect) { + JPADrawInfo(const Mtx param_0, f32 fovY, f32 aspect) { MTXCopy(param_0, mCamMtx); C_MTXLightPerspective(mPrjMtx, fovY, aspect, 0.5f, -0.5f, 0.5f, 0.5f); } - JPADrawInfo(Mtx param_0, f32 top, f32 bottom, f32 left, f32 right) { + JPADrawInfo(const Mtx param_0, f32 top, f32 bottom, f32 left, f32 right) { MTXCopy(param_0, mCamMtx); C_MTXLightOrtho(mPrjMtx, top, bottom, left, right, 0.5f, 0.5f, 0.5f, 0.5f); } @@ -26,6 +26,8 @@ public: void getCamMtx(Mtx dst) const { MTXCopy(mCamMtx, dst); } void getPrjMtx(Mtx dst) const { MTXCopy(mPrjMtx, dst); } + + void setPrjMtx(const Mtx src) { MTXCopy(src, mPrjMtx); } }; #endif diff --git a/include/JSystem/JParticle/JPADynamicsBlock.h b/include/JSystem/JParticle/JPADynamicsBlock.h index 5dd4e880..9e147da3 100644 --- a/include/JSystem/JParticle/JPADynamicsBlock.h +++ b/include/JSystem/JParticle/JPADynamicsBlock.h @@ -6,8 +6,7 @@ #include "egg/math/eggVector.h" #include "m/m_angle.h" - -class JPAEmitterWorkData; +struct JPAEmitterWorkData; /** * @ingroup jsystem-jparticle @@ -43,8 +42,7 @@ struct JPADynamicsBlockData { /* 0x74 */ u16 mVolumeSize; /* 0x76 */ u16 mDivNumber; /* 0x78 */ u8 mRateStep; - /* 0x7C */ u32 field_0x7c; -}; +}; // Size: 0x7C typedef void (*JPADynamicsCalcVolumeFunc)(JPAEmitterWorkData*); @@ -66,7 +64,7 @@ public: void init(); void create(JPAEmitterWorkData*); - void calc(JPAEmitterWorkData* work) { mpCalcVolumeFunc(work); } + void calc(JPAEmitterWorkData* work) const { mpCalcVolumeFunc(work); } s16 getStartFrame() const { return mpData->mStartFrame; } u32 getResUserWork() const { return mpData->mResUserWork; } @@ -83,23 +81,23 @@ public: void getEmitterDir(EGG::Vector3f* vec) const { vec->set(mpData->mEmitterDir.x, mpData->mEmitterDir.y, mpData->mEmitterDir.z); } - void getEmitterRot(mAng3_c* vec) const { + void getEmitterRot(mAng3_c* vec) const { vec->set(mpData->mEmitterRot); - } - s16 getMaxFrame() { return mpData->mMaxFrame; } - s16 getLifetime() { return mpData->mLifeTime; } - u16 getVolumeSize() { return mpData->mVolumeSize; } - f32 getRate() { return mpData->mRate; } - u8 getRateStep() { return mpData->mRateStep; } - f32 getVolumeSweep() { return mpData->mVolumeSweep; } - f32 getVolumeMinRad() { return mpData->mVolumeMinRad; } - f32 getInitVelOmni() { return mpData->mInitialVelOmni; } - f32 getInitVelAxis() { return mpData->mInitialVelAxis; } - f32 getInitVelDir() { return mpData->mInitialVelDir; } - f32 getInitVelDirSp() { return mpData->mSpread; } - f32 getInitVelRndm() { return mpData->mInitialVelRndm; } + } + s16 getMaxFrame() const { return mpData->mMaxFrame; } + s16 getLifetime() const { return mpData->mLifeTime; } + u16 getVolumeSize() const { return mpData->mVolumeSize; } + f32 getRate() const { return mpData->mRate; } + u8 getRateStep() const { return mpData->mRateStep; } + f32 getVolumeSweep() const { return mpData->mVolumeSweep; } + f32 getVolumeMinRad() const { return mpData->mVolumeMinRad; } + f32 getInitVelOmni() const { return mpData->mInitialVelOmni; } + f32 getInitVelAxis() const { return mpData->mInitialVelAxis; } + f32 getInitVelDir() const { return mpData->mInitialVelDir; } + f32 getInitVelDirSp() const { return mpData->mSpread; } + f32 getInitVelRndm() const { return mpData->mInitialVelRndm; } f32 getInitVelRatio() const { return mpData->mInitialVelRatio; } - f32 getAirRes() { return mpData->mAirResist; } + f32 getAirRes() const { return mpData->mAirResist; } f32 getLifetimeRndm() const { return mpData->mLifeTimeRndm; } f32 getMomentRndm() const { return mpData->mMoment; } diff --git a/include/JSystem/JParticle/JPAEmitter.h b/include/JSystem/JParticle/JPAEmitter.h index 678e327b..807c2d96 100644 --- a/include/JSystem/JParticle/JPAEmitter.h +++ b/include/JSystem/JParticle/JPAEmitter.h @@ -81,8 +81,6 @@ public: virtual void executeAfter(JPABaseEmitter*) {} virtual void draw(JPABaseEmitter*) {} virtual void drawAfter(JPABaseEmitter*) {} - - //~JPAEmitterCallBack(); }; enum { @@ -119,11 +117,12 @@ public: void setStatus(u32 status) { mStatus |= status; } void clearStatus(u32 status) { mStatus &= ~status; } u32 checkStatus(u32 status) const { return (mStatus & status); } - bool checkFlag(u32 flag) const { return !!(mpRes->getDyn()->getFlag() & flag); } - u32 getDynResUserWork() const { return mpRes->getDyn()->getResUserWork(); } + u32 checkFlag(u32 flag) const { return pRes->getDyn()->getFlag() & flag; } + u32 getDynResUserWork() const { return pRes->getDyn()->getResUserWork(); } u8 getResourceManagerID() const { return mResMgrID; } u8 getGroupID() const { return mGroupID; } u8 getDrawTimes() const { return mDrawTimes; } + f32 getRate() const { return mRate; } void setRate(f32 rate) { mRate = rate; } void setDirectionalSpeed(f32 i_speed) { mDirSpeed = i_speed; } void setRandomDirectionSpeed(f32 i_speed) { mRndmDirSpeed = i_speed; } @@ -131,21 +130,22 @@ public: void setGlobalRTMatrix(const Mtx m) { JPASetRMtxTVecfromMtx(m, mGlobalRot, &mGlobalTrs); } void setGlobalSRTMatrix(const Mtx m) { JPASetRMtxSTVecfromMtx(m, mGlobalRot, &mGlobalScl, &mGlobalTrs); - - // "set is used in TP debug" mGlobalPScl.set(mGlobalScl.x, mGlobalScl.y); } void setGlobalTranslation(f32 x, f32 y, f32 z) { mGlobalTrs.set(x, y, z); } void setGlobalTranslation(const EGG::Vector3f& trs) { mGlobalTrs.set(trs); } void getLocalTranslation(EGG::Vector3f& vec) { vec.set(mLocalTrs); } + void getLocalTranslation(EGG::Vector3f* vec) const { vec->set(mLocalTrs); } void setGlobalRotation(const mAng3_c& rot) { JPAGetXYZRotateMtx(rot.x, rot.y, rot.z, mGlobalRot); } void getGlobalTranslation(EGG::Vector3f* out) const { out->set(mGlobalTrs); } void setGlobalDynamicsScale(const EGG::Vector3f& i_scale) { mGlobalScl.set(i_scale); } + void getGlobalDynamicsScale(EGG::Vector3f* i_scale) const { i_scale->set(mGlobalScl); } void setGlobalAlpha(u8 alpha) { mGlobalPrmClr.a = alpha; } - u8 getGlobalAlpha() { return mGlobalPrmClr.a; } + u8 getGlobalAlpha() const { return mGlobalPrmClr.a; } void getGlobalPrmColor(GXColor& color) { color = mGlobalPrmClr; } + void getGlobalPrmColor(GXColor* color) const { *color = mGlobalPrmClr; } void setGlobalPrmColor(u8 r, u8 g, u8 b) { mGlobalPrmClr.r = r; mGlobalPrmClr.g = g; mGlobalPrmClr.b = b; } void setGlobalEnvColor(u8 r, u8 g, u8 b) { mGlobalEnvClr.r = r; mGlobalEnvClr.g = g; mGlobalEnvClr.b = b; } void setVolumeSize(u16 size) { mVolumeSize = size; } @@ -154,21 +154,27 @@ public: void setAwayFromAxisSpeed(f32 i_speed) { mAwayFromAxisSpeed = i_speed; } void setSpread(f32 i_spread) { mSpread = i_spread; } void setLocalTranslation(const EGG::Vector3f& i_trans) { mLocalTrs.set(i_trans); } - void setLocalRotation(const mAng3_c& i_rot) { mLocalRot.set(i_rot.x * 0.005493248f, i_rot.y * 0.005493248f, i_rot.z * 0.005493248f); } + void setLocalRotation(const mAng3_c& i_rot) { + mLocalRot.set(i_rot.x * (360.0f / 0xffff), i_rot.y * (360.0f / 0xffff), + i_rot.z * (360.0f / 0xffff)); + } void setRateStep(u8 i_step) { mRateStep = i_step; } void setGlobalParticleHeightScale(f32 height) { mGlobalPScl.y = height; } void setGlobalParticleScale(const EGG::Vector3f& scale) { - mGlobalPScl.set(scale.x, scale.y); + mGlobalPScl.set((f32)scale.x, (f32)scale.y); } void setGlobalParticleScale(f32 scaleX, f32 scaleY) { mGlobalPScl.set(scaleX, scaleY); } - void getGlobalParticleScale(EGG::Vector3f& scale) { + void getGlobalParticleScale(EGG::Vector3f& scale) const { scale.set(mGlobalPScl.x, mGlobalPScl.y, 1.0f); } + void getGlobalParticleScale(EGG::Vector3f* scale) const { + scale->set(mGlobalPScl.x, mGlobalPScl.y, 1.0f); + } void setGlobalScale(const EGG::Vector3f& scale) { mGlobalScl.set(scale); mGlobalPScl.set(scale.x ,scale.y); @@ -214,20 +220,28 @@ public: void stopDrawParticle() { setStatus(JPAEmtrStts_StopDraw); } void playDrawParticle() { clearStatus(JPAEmtrStts_StopDraw); } - u32 getUserWork() { return mpUserWork; } - void setUserWork(u32 userWork) { mpUserWork = userWork; } - u32 getParticleNumber() { + uintptr_t getUserWork() const { return mpUserWork; } + void setUserWork(uintptr_t userWork) { mpUserWork = userWork; } + u32 getParticleNumber() const { return mAlivePtclBase.getNum() + mAlivePtclChld.getNum(); } - bool isEnableDeleteEmitter() { + bool isEnableDeleteEmitter() const { return checkStatus(JPAEmtrStts_EnableDeleteEmitter) && getParticleNumber() == 0; } void setDrawTimes(u8 drawTimes) { mDrawTimes = drawTimes; } void setParticleCallBackPtr(JPAParticleCallBack* cb) { mpPtclCallBack = cb; } - JPAParticleCallBack* getParticleCallBackPtr() { return mpPtclCallBack; } + JPAParticleCallBack* getParticleCallBackPtr() const { return mpPtclCallBack; } JPAEmitterCallBack* getEmitterCallBackPtr() const { return mpEmtrCallBack; } u32 getAge() const { return mTick; } + void setVolumeMiniRadius(f32 param_1) { + mVolumeMinRad = param_1; + } + + void setMaxFrame(s32 maxFrame) { + mMaxFrame = maxFrame; + } + public: /* 0x00 */ EGG::Vector3f mLocalScl; /* 0x0C */ EGG::Vector3f mLocalTrs; @@ -259,7 +273,7 @@ public: /* 0xD4 */ JPAList mAlivePtclChld; /* 0xE0 */ JPAList* mpPtclPool; /* 0xE4 */ JPAEmitterManager* mpEmtrMgr; - /* 0xE8 */ JPAResource* mpRes; + /* 0xE8 */ JPAResource* pRes; /* 0xEC */ JPAEmitterCallBack* mpEmtrCallBack; /* 0xF0 */ JPAParticleCallBack* mpPtclCallBack; /* 0xF4 */ u32 mStatus; diff --git a/include/JSystem/JParticle/JPAEmitterManager.h b/include/JSystem/JParticle/JPAEmitterManager.h index f2085e80..836ded4b 100644 --- a/include/JSystem/JParticle/JPAEmitterManager.h +++ b/include/JSystem/JParticle/JPAEmitterManager.h @@ -6,6 +6,7 @@ #include "JSystem/JParticle/JPAList.h" #include "JSystem/JParticle/JPADrawInfo.h" #include "JSystem/JSupport/JSUList.h" +#include "JSystem/JUtility/JUTAssert.h" #include "JSystem/JGeometry.h" class JPAEmitterCallBack; @@ -36,7 +37,13 @@ public: void entryResourceManager(JPAResourceManager*, u8); void clearResourceManager(u8); void calcYBBCam(); - JPAResourceManager* getResourceManager(u16 idx) { return pResMgrAry[idx]; } + JPAResourceManager* getResourceManager(u16 idx) const { return pResMgrAry[idx]; } + JPAResourceManager* getResourceManager(u8 res_mgr_id) const { + JUT_ASSERT(147, res_mgr_id < ridMax); + return pResMgrAry[res_mgr_id]; + } + int getEmitterNumber() const { return emtrNum - mFreeEmtrList.getNumLinks(); } + int getParticleNumber() const { return ptclNum - mPtclPool.getNum(); } public: /* 0x00 */ JSUList* pEmtrUseList; diff --git a/include/JSystem/JParticle/JPAExTexShape.h b/include/JSystem/JParticle/JPAExTexShape.h index 9fe22c72..ade243b3 100644 --- a/include/JSystem/JParticle/JPAExTexShape.h +++ b/include/JSystem/JParticle/JPAExTexShape.h @@ -4,7 +4,7 @@ #include "JSystem/JParticle/JPABaseShape.h" #include "common.h" -class JPAEmitterWorkData; +struct JPAEmitterWorkData; /** * @ingroup jsystem-jparticle @@ -31,7 +31,7 @@ struct JPAExTexShapeData { /* 0x4D */ s8 mExpScale; /* 0x4E */ s8 mIndTexIdx; /* 0x4F */ s8 mSecTexIdx; -}; +}; // Size: 0x50 /** * @ingroup jsystem-jparticle @@ -46,7 +46,7 @@ public: s8 getExpScale() const { return mpData->mExpScale; } u8 getIndTexIdx() const { return mpData->mIndTexIdx; } u8 getSecTexIdx() const { return mpData->mSecTexIdx; } - bool isUseIndirect() const { return !!(mpData->mFlags & 0x01); } + BOOL isUseIndirect() const { return !!(mpData->mFlags & 0x01); } BOOL isUseSecTex() const { return (mpData->mFlags & 0x0100); } f32 getField_0x24() const { return mpData->field_0x24; } @@ -62,6 +62,7 @@ public: public: const JPAExTexShapeData* mpData; + // SS addition void fn_8031DE80(const JPABaseShape *bsp, f32) const; }; diff --git a/include/JSystem/JParticle/JPAExtraShape.h b/include/JSystem/JParticle/JPAExtraShape.h index a567d768..376b91ca 100644 --- a/include/JSystem/JParticle/JPAExtraShape.h +++ b/include/JSystem/JParticle/JPAExtraShape.h @@ -3,7 +3,7 @@ #include "common.h" -class JPAEmitterWorkData; +struct JPAEmitterWorkData; class JPABaseParticle; /** @@ -38,7 +38,7 @@ struct JPAExtraShapeData { /* 0x54 */ f32 mRotateSpeed; /* 0x58 */ f32 mRotateSpeedRandom; /* 0x5C */ f32 mRotateDirection; -}; +}; // Size: 0x60 /** * @ingroup jsystem-jparticle diff --git a/include/JSystem/JParticle/JPAFieldBlock.h b/include/JSystem/JParticle/JPAFieldBlock.h index 108b8bf6..7ff67ae8 100644 --- a/include/JSystem/JParticle/JPAFieldBlock.h +++ b/include/JSystem/JParticle/JPAFieldBlock.h @@ -5,7 +5,7 @@ #include "egg/egg_types.h" #include "egg/math/eggVector.h" -class JPAEmitterWorkData; +struct JPAEmitterWorkData; class JPABaseParticle; class JPAFieldBlock; @@ -122,36 +122,36 @@ public: JPAFieldBlock(u8 const*, EGG::Heap*); void init(EGG::Heap*); - u32 getType() { return mpData->mFlags & 0xF; } - u32 getAddType() { return (mpData->mFlags >> 8) & 3; } - u32 getSttFlag() { return mpData->mFlags >> 16; } - bool checkStatus(u16 flag) { return flag & getSttFlag(); } + u32 getType() const { return mpData->mFlags & 0xF; } + u32 getAddType() const { return (mpData->mFlags >> 8) & 3; } + u32 getSttFlag() const { return mpData->mFlags >> 16; } + u32 checkStatus(u16 flag) { return flag & getSttFlag(); } f32 getMagRndm() const { return mpData->mMagRndm; } f32 getVal1() const { return mpData->mVal1; } - f32 getFadeInTime() { return mpData->mFadeInTime; } - f32 getFadeOutTime() { return mpData->mFadeOutTime; } - f32 getEnTime() { return mpData->mEnTime; } - f32 getDisTime() { return mpData->mDisTime; } - u8 getCycle() { return mpData->mCycle; } - f32 getFadeInRate() { return mFadeInRate; } - f32 getFadeOutRate() { return mFadeOutRate; } - EGG::Vector3f& getPos() { return mPos; } - EGG::Vector3f& getDir() { return mDir; } + f32 getFadeInTime() const { return mpData->mFadeInTime; } + f32 getFadeOutTime() const { return mpData->mFadeOutTime; } + f32 getEnTime() const { return mpData->mEnTime; } + f32 getDisTime() const { return mpData->mDisTime; } + u8 getCycle() const { return mpData->mCycle; } + f32 getFadeInRate() const { return mFadeInRate; } + f32 getFadeOutRate() const { return mFadeOutRate; } + const EGG::Vector3f& getPos() const { return mPos; } + const EGG::Vector3f& getDir() const { return mDir; } f32 getMag() const { return mMag; } - void getPosOrig(EGG::Vector3f* pos) { pos->set(mpData->mPos); } - void getDirOrig(EGG::Vector3f* dir) { dir->set(mpData->mDir); } - f32 getMagOrig() { return mpData->mMag; } + void getPosOrig(EGG::Vector3f* pos) const { pos->set(mpData->mPos); } + void getDirOrig(EGG::Vector3f* dir) const { dir->set(mpData->mDir); } + f32 getMagOrig() const { return mpData->mMag; } void initOpParam() { getPosOrig(&mPos); getDirOrig(&mDir); mMag = getMagOrig(); } - void prepare(JPAEmitterWorkData* work) { mpField->prepare(work, this); } - void calc(JPAEmitterWorkData* work, JPABaseParticle* ptcl) { mpField->calc(work, this, ptcl); } + void prepare(JPAEmitterWorkData* work) { pFld->prepare(work, this); } + void calc(JPAEmitterWorkData* work, JPABaseParticle* ptcl) { pFld->calc(work, this, ptcl); } private: /* 0x00 */ const JPAFieldBlockData* mpData; - /* 0x04 */ JPAFieldBase* mpField; + /* 0x04 */ JPAFieldBase* pFld; /* 0x08 */ f32 mFadeInRate; /* 0x0C */ f32 mFadeOutRate; /* 0x10 */ EGG::Vector3f mPos; diff --git a/include/JSystem/JParticle/JPAKeyBlock.h b/include/JSystem/JParticle/JPAKeyBlock.h index 005dc6c1..bee15e17 100644 --- a/include/JSystem/JParticle/JPAKeyBlock.h +++ b/include/JSystem/JParticle/JPAKeyBlock.h @@ -11,7 +11,10 @@ struct JPAKeyBlock { JPAKeyBlock(u8 const*); f32 calc(f32); - u8 getID() { return mDataStart[8]; } + u8 getID() const { return mDataStart[8]; } + u8 getKeyNum() const { return mDataStart[9]; } + BOOL isLoop() const { return mDataStart[11]; } + const f32* getKeyData() const { return field_0x4; } const u8* mDataStart; const f32* field_0x4; diff --git a/include/JSystem/JParticle/JPAList.h b/include/JSystem/JParticle/JPAList.h index 287fdb75..e4583b4c 100644 --- a/include/JSystem/JParticle/JPAList.h +++ b/include/JSystem/JParticle/JPAList.h @@ -12,8 +12,8 @@ struct JPANode { JPANode() : mpPrev(NULL), mpNext(NULL) { } ~JPANode() {} - JPANode* getPrev() { return mpPrev; } - JPANode* getNext() { return mpNext; } + JPANode* getPrev() const { return mpPrev; } + JPANode* getNext() const { return mpNext; } T* getObject() { return &mData; } /* 0x00 */ JPANode* mpPrev; @@ -48,8 +48,7 @@ struct JPAList { } else { mpLast = node; mpFirst = node; - node->mpPrev = NULL; - node->mpNext = NULL; + node->mpNext = node->mpPrev = NULL; } mNum++; @@ -75,8 +74,7 @@ struct JPAList { if (mNum == 1) { ret = mpFirst; - mpLast = NULL; - mpFirst = NULL; + mpFirst = mpLast = NULL; mNum--; } else if (mNum) { ret = mpFirst; @@ -93,8 +91,7 @@ struct JPAList { if (mNum == 1) { ret = mpLast; - mpLast = NULL; - mpFirst = NULL; + mpFirst = mpLast = NULL; mNum--; } else if (mNum) { ret = mpLast; @@ -120,8 +117,7 @@ struct JPAList { mpLast = node->mpPrev; mNum--; } else { - mpLast = NULL; - mpFirst = NULL; + mpFirst = mpLast = NULL; mNum--; } return node; diff --git a/include/JSystem/JParticle/JPAParticle.h b/include/JSystem/JParticle/JPAParticle.h index b0430430..9ba15797 100644 --- a/include/JSystem/JParticle/JPAParticle.h +++ b/include/JSystem/JParticle/JPAParticle.h @@ -27,22 +27,24 @@ public: bool canCreateChild(JPAEmitterWorkData*); f32 getWidth(JPABaseEmitter const*) const; f32 getHeight(JPABaseEmitter const*) const; - int getAge() { return mAge; } + int getAge() const { return mAge; } void setOffsetPosition(const EGG::Vector3f& pos) { mOffsetPosition.set(pos); } void setOffsetPosition(f32 x, f32 y, f32 z) { mOffsetPosition.set(x, y, z); } void getOffsetPosition(EGG::Vector3f& pos) { pos.set(mOffsetPosition); } - s16 getRotateAngle() const { return mRotateAngle; } - void getGlobalPosition(EGG::Vector3f& pos) const { pos.set(mPosition); } + void getOffsetPosition(EGG::Vector3f* pos) const { pos->set(mOffsetPosition); } + u16 getRotateAngle() const { return mRotateAngle; } + void getGlobalPosition(EGG::Vector3f* pos) const { pos->set(mPosition); } f32 getParticleScaleX() const { return mParticleScaleX; } f32 getParticleScaleY() const { return mParticleScaleY; } void setStatus(u32 flag) { mStatus |= flag; } - u32 checkStatus(u32 flag) { return mStatus & flag; } + u32 checkStatus(u32 flag) const { return mStatus & flag; } void initStatus(u32 status) { mStatus = status; } void setInvisibleParticleFlag() { setStatus(8); } void setDeleteParticleFlag() { setStatus(2); } - void getVelVec(EGG::Vector3f& vec) const { vec.set(mVelocity); } - void getLocalPosition(EGG::Vector3f& vec) const { vec.set(mLocalPosition); } + void getVelVec(EGG::Vector3f* vec) const { vec->set(mVelocity); } + void getLocalPosition(EGG::Vector3f* vec) const { vec->set(mLocalPosition); } void getBaseAxis(EGG::Vector3f& vec) const { vec.set(mBaseAxis); } + void getBaseAxis(EGG::Vector3f* vec) const { vec->set(mBaseAxis); } public: /* 0x00 */ EGG::Vector3f mPosition; diff --git a/include/JSystem/JParticle/JPAResource.h b/include/JSystem/JParticle/JPAResource.h index 2d41f9b7..a4cfc2bf 100644 --- a/include/JSystem/JParticle/JPAResource.h +++ b/include/JSystem/JParticle/JPAResource.h @@ -4,7 +4,7 @@ #include "common.h" #include "egg/egg_types.h" -class JPAEmitterWorkData; +struct JPAEmitterWorkData; class JPABaseEmitter; class JPABaseParticle; @@ -37,13 +37,13 @@ public: void calcWorkData_c(JPAEmitterWorkData*); void calcWorkData_d(JPAEmitterWorkData*); - JPABaseShape* getBsp() const { return mpBaseShape; } - JPAExtraShape* getEsp() const { return mpExtraShape; } - JPAChildShape* getCsp() const { return mpChildShape; } - JPAExTexShape* getEts() const { return mpExTexShape; } - JPADynamicsBlock* getDyn() const { return mpDynamicsBlock; } + JPABaseShape* getBsp() const { return pBsp; } + JPAExtraShape* getEsp() const { return pEsp; } + JPAChildShape* getCsp() const { return pCsp; } + JPAExTexShape* getEts() const { return pEts; } + JPADynamicsBlock* getDyn() const { return pDyn; } - u32 getTexIdx(u32 idx) const { return mpTDB1[idx]; } + const u16 getTexIdx(u8 idx) { return mpTDB1[idx]; } u16 getUsrIdx() const { return mUsrIdx; } public: @@ -57,18 +57,18 @@ public: /* 0x14 */ ParticleFunc* mpCalcParticleChildFuncList; /* 0x18 */ ParticleFunc* mpDrawParticleChildFuncList; - /* 0x1C */ JPABaseShape* mpBaseShape; - /* 0x20 */ JPAExtraShape* mpExtraShape; - /* 0x24 */ JPAChildShape* mpChildShape; - /* 0x28 */ JPAExTexShape* mpExTexShape; - /* 0x2C */ JPADynamicsBlock* mpDynamicsBlock; - /* 0x30 */ JPAFieldBlock** mpFieldBlocks; - /* 0x34 */ JPAKeyBlock** mpKeyBlocks; + /* 0x1C */ JPABaseShape* pBsp; + /* 0x20 */ JPAExtraShape* pEsp; + /* 0x24 */ JPAChildShape* pCsp; + /* 0x28 */ JPAExTexShape* pEts; + /* 0x2C */ JPADynamicsBlock* pDyn; + /* 0x30 */ JPAFieldBlock** ppFld; + /* 0x34 */ JPAKeyBlock** ppKey; /* 0x38 */ u16 const* mpTDB1; /* 0x3C */ u16 mUsrIdx; - /* 0x3E */ u8 mFieldBlockNum; - /* 0x3F */ u8 mKeyBlockNum; - /* 0x40 */ u8 mTDB1Num; + /* 0x3E */ u8 fldNum; + /* 0x3F */ u8 keyNum; + /* 0x40 */ u8 texNum; /* 0x41 */ u8 mpCalcEmitterFuncListNum; /* 0x42 */ u8 mpDrawEmitterFuncListNum; /* 0x43 */ u8 mpDrawEmitterChildFuncListNum; diff --git a/include/JSystem/JParticle/JPAResourceManager.h b/include/JSystem/JParticle/JPAResourceManager.h index 409bde87..3c3d58aa 100644 --- a/include/JSystem/JParticle/JPAResourceManager.h +++ b/include/JSystem/JParticle/JPAResourceManager.h @@ -22,16 +22,16 @@ public: void registTex(JPATexture*); u32 getResUserWork(u16) const; - void load(u16 idx, GXTexMapID texMapID) { mpTexArr[idx]->load(texMapID); } + void load(u16 idx, GXTexMapID texMapID) { pTexAry[idx]->load(texMapID); } public: /* 0x00 */ EGG::Heap* mpHeap; - /* 0x04 */ JPAResource** mpResArr; - /* 0x08 */ JPATexture** mpTexArr; - /* 0x0C */ u16 mResMax; - /* 0x0E */ u16 mResNum; - /* 0x10 */ u16 mTexMax; - /* 0x12 */ u16 mTexNum; + /* 0x04 */ JPAResource** pResAry; + /* 0x08 */ JPATexture** pTexAry; + /* 0x0C */ u16 resMaxNum; + /* 0x0E */ u16 resRegNum; + /* 0x10 */ u16 texMaxNum; + /* 0x12 */ u16 texRegNum; }; #endif /* JPARESOURCEMANAGER_H */ diff --git a/include/d/col/c/c_m3d_g_lin.h b/include/d/col/c/c_m3d_g_lin.h index 8b1d9d46..629347f0 100644 --- a/include/d/col/c/c_m3d_g_lin.h +++ b/include/d/col/c/c_m3d_g_lin.h @@ -26,7 +26,7 @@ public: void CalcPos(mVec3_c *, f32) const; void CalcVec(Vec *pOut) const { - PSVECSubtract(mEnd, mStart, pOut); + VECSubtract(mEnd, mStart, pOut); } void SetStart(const mVec3_c &); diff --git a/include/m/m_vec.h b/include/m/m_vec.h index 0294dcca..6f0047b9 100644 --- a/include/m/m_vec.h +++ b/include/m/m_vec.h @@ -222,7 +222,7 @@ public: } f32 distance(const mVec3_c &to) const { - return EGG::Math::sqrt(PSVECSquareDistance(*this, to)); + return EGG::Math::sqrt(VECSquareDistance(*this, to)); } f32 squareDistance(const mVec3_c &to) const { return VEC3DistSq(*this, to); @@ -277,11 +277,6 @@ public: return EGG::Vector3f::angle(other); } - void offsetWithAngle(s16 yRot, f32 scale) { - this->x += nw4r::math::SinIdx(yRot) * scale; - this->z += nw4r::math::CosIdx(yRot) * scale; - } - static mVec3_c Zero; static mVec3_c Ex; static mVec3_c Ey; diff --git a/include/nw4r/g3d/g3d_calcworld.h b/include/nw4r/g3d/g3d_calcworld.h index b31ed72a..ce2f2fda 100644 --- a/include/nw4r/g3d/g3d_calcworld.h +++ b/include/nw4r/g3d/g3d_calcworld.h @@ -64,21 +64,21 @@ public: void SetScale(f32 x, f32 y, f32 z); void GetMtx(nw4r::math::MTX34 *out) { if (out != NULL) { - PSMTXCopy(*mpM, *out); + MTXCopy(*mpM, *out); } } void SetMtx(const nw4r::math::MTX34 *arg) { if (arg != NULL) { - PSMTXCopy(*arg, *mpM); + MTXCopy(*arg, *mpM); } else { - PSMTXIdentity(*mpM); + MTXIdentity(*mpM); } } // Not sure void SetMtxUnchecked(const nw4r::math::MTX34 *arg) { - PSMTXCopy(*arg, *mpM); + MTXCopy(*arg, *mpM); } private: diff --git a/include/nw4r/math/math_types.h b/include/nw4r/math/math_types.h index 282ea18a..7fb8172c 100644 --- a/include/nw4r/math/math_types.h +++ b/include/nw4r/math/math_types.h @@ -448,30 +448,30 @@ inline VEC3 *VEC3Sub(register VEC3 *out, register const VEC3 *a, register const } inline VEC3 *VEC3Cross(VEC3 *out, const VEC3 *a, const VEC3 *b) { - PSVECCrossProduct(*a, *b, *out); + VECCrossProduct(*a, *b, *out); return out; } inline f32 VEC3DistSq(const VEC3 *a, const VEC3 *b) { - return PSVECSquareDistance(*a, *b); + return VECSquareDistance(*a, *b); } inline f32 VEC3Len(const VEC3 *vec) { - return PSVECMag(*vec); + return VECMag(*vec); } inline VEC3 *VEC3Normalize(VEC3 *out, const VEC3 *in) { - PSVECNormalize(*in, *out); + VECNormalize(*in, *out); return out; } inline VEC3 *VEC3Transform(VEC3 *out, const MTX34 *mtx, const VEC3 *vec) { - PSMTXMultVec(*mtx, *vec, *out); + MTXMultVec(*mtx, *vec, *out); return out; } inline VEC3 *VEC3TransformCoord(VEC3 *out, const MTX34 *mtx, const VEC3 *vec) { - PSMTXMultVec(*mtx, *vec, *out); + MTXMultVec(*mtx, *vec, *out); return out; } @@ -496,21 +496,21 @@ MTX34 *MTX34RotAxisFIdx(MTX34 *mtx, const VEC3 *axis, f32 fidx); MTX34 *MTX34RotXYZFIdx(MTX34 *mtx, f32 fx, f32 fy, f32 fz); inline MTX34 *MTX34Copy(MTX34 *out, const MTX34 *in) { - PSMTXCopy(*in, *out); + MTXCopy(*in, *out); return out; } inline MTX34 *MTX34Identity(MTX34 *mtx) { - PSMTXIdentity(*mtx); + MTXIdentity(*mtx); return mtx; } inline u32 MTX34Inv(MTX34 *out, const MTX34 *in) { - return PSMTXInverse(*in, *out); + return MTXInverse(*in, *out); } inline u32 MTX34InvTranspose(MTX34 *pOut, const MTX34 *pIn) { - return PSMTXInvXpose(*pIn, *pOut); + return MTXInvXpose(*pIn, *pOut); } inline MTX34 *MTX34LookAt(MTX34 *mtx, const VEC3 *pos, const VEC3 *up, const VEC3 *target) { @@ -519,12 +519,12 @@ inline MTX34 *MTX34LookAt(MTX34 *mtx, const VEC3 *pos, const VEC3 *up, const VEC } inline MTX34 *MTX34Mult(MTX34 *out, const MTX34 *a, const MTX34 *b) { - PSMTXConcat(*a, *b, *out); + MTXConcat(*a, *b, *out); return out; } inline MTX34 *MTX34MultArray(MTX34 *out, const MTX34 *p1, const MTX34 *src, u32 len) { - PSMTXConcatArray(*p1, *src, *out, len); + MTXConcatArray(*p1, *src, *out, len); return out; } @@ -541,7 +541,7 @@ inline MTX34 *MTX34RotXYZRad(MTX34 *mtx, f32 rx, f32 ry, f32 rz) { } inline MTX34 *MTX34Scale(MTX34 *out, const VEC3 *scale, const MTX34 *in) { - PSMTXScaleApply(*in, *out, scale->x, scale->y, scale->z); + MTXScaleApply(*in, *out, scale->x, scale->y, scale->z); return out; } @@ -551,7 +551,7 @@ inline QUAT *MTX34ToQUAT(QUAT *quat, const MTX34 *mtx) { } inline MTX34 *MTX34Trans(MTX34 *out, const VEC3 *trans, const MTX34 *in) { - PSMTXTransApply(*in, *out, trans->x, trans->y, trans->z); + MTXTransApply(*in, *out, trans->x, trans->y, trans->z); return out; } @@ -569,7 +569,7 @@ MTX44 *MTX44Copy(MTX44 *dst, const MTX44 *src); * ******************************************************************************/ inline MTX34 *QUATToMTX34(MTX34 *mtx, const QUAT *quat) { - PSMTXQuat(*mtx, *quat); + MTXQuat(*mtx, *quat); return mtx; } diff --git a/include/rvl/MTX/mtx.h b/include/rvl/MTX/mtx.h index de5a32f4..2283df0c 100644 --- a/include/rvl/MTX/mtx.h +++ b/include/rvl/MTX/mtx.h @@ -31,6 +31,7 @@ typedef struct Quaternion { #define MTXIdentity PSMTXIdentity #define MTXCopy PSMTXCopy #define MTXConcat PSMTXConcat +#define MTXConcatArray PSMTXConcatArray #define MTXInverse PSMTXInverse #define MTXTranspose PSMTXTranspose #define MTXInverse PSMTXInverse diff --git a/src/JSystem/JParticle/JPABaseShape.cpp b/src/JSystem/JParticle/JPABaseShape.cpp index 74abae5d..6e8682d4 100644 --- a/src/JSystem/JParticle/JPABaseShape.cpp +++ b/src/JSystem/JParticle/JPABaseShape.cpp @@ -1,41 +1,30 @@ -// -// Generated By: dol2asm -// Translation Unit: JPABaseShape -// - #include "JSystem/JParticle/JPAExTexShape.h" #include "egg/core/eggHeap.h" #include "JSystem/JParticle/JPABaseShape.h" #include "JSystem/JParticle/JPAParticle.h" #include "JSystem/JParticle/JPAEmitter.h" #include "JSystem/JParticle/JPAResourceManager.h" +#include "JSystem/JUtility/JUTAssert.h" #include "nw4r/math/math_triangular.h" #include "rvl/MTX.h" #include "rvl/GX.h" -/* 80276A90-80276ACC 2713D0 003C+00 0/0 1/1 0/0 .text JPASetPointSize__FP18JPAEmitterWorkData */ void JPASetPointSize(JPAEmitterWorkData* work) { GXSetPointSize((u8)(25.0f * work->mGlobalPtclScl.x), GX_TO_ONE); } -/* 80276ACC-80276B08 27140C 003C+00 0/0 1/1 0/0 .text JPASetLineWidth__FP18JPAEmitterWorkData */ void JPASetLineWidth(JPAEmitterWorkData* work) { GXSetLineWidth((u8)(25.0f * work->mGlobalPtclScl.x), GX_TO_ONE); } -/* 80276B08-80276B4C 271448 0044+00 0/0 1/1 0/0 .text - * JPASetPointSize__FP18JPAEmitterWorkDataP15JPABaseParticle */ void JPASetPointSize(JPAEmitterWorkData* work, JPABaseParticle* ptcl) { GXSetPointSize((u8)(ptcl->mParticleScaleX * (25.0f * work->mGlobalPtclScl.x)), GX_TO_ONE); } -/* 80276B4C-80276B90 27148C 0044+00 0/0 1/1 0/0 .text - * JPASetLineWidth__FP18JPAEmitterWorkDataP15JPABaseParticle */ void JPASetLineWidth(JPAEmitterWorkData* work, JPABaseParticle* ptcl) { GXSetLineWidth((u8)(ptcl->mParticleScaleX * (25.0f * work->mGlobalPtclScl.x)), GX_TO_ONE); } -/* 80276B90-80276C2C 2714D0 009C+00 0/0 1/1 0/0 .text JPARegistPrm__FP18JPAEmitterWorkData */ void JPARegistPrm(JPAEmitterWorkData* work) { JPABaseEmitter* emtr = work->mpEmtr; GXColor prm = emtr->mPrmClr; @@ -46,7 +35,6 @@ void JPARegistPrm(JPAEmitterWorkData* work) { GXSetTevColor(GX_TEVREG0, prm); } -/* 80276C2C-80276CB0 27156C 0084+00 0/0 1/1 0/0 .text JPARegistEnv__FP18JPAEmitterWorkData */ void JPARegistEnv(JPAEmitterWorkData* work) { JPABaseEmitter* emtr = work->mpEmtr; GXColor env = emtr->mEnvClr; @@ -56,7 +44,6 @@ void JPARegistEnv(JPAEmitterWorkData* work) { GXSetTevColor(GX_TEVREG1, env); } -/* 80276CB0-80276DB0 2715F0 0100+00 0/0 1/1 0/0 .text JPARegistPrmEnv__FP18JPAEmitterWorkData */ void JPARegistPrmEnv(JPAEmitterWorkData* work) { JPABaseEmitter* emtr = work->mpEmtr; GXColor prm = emtr->mPrmClr; @@ -72,8 +59,6 @@ void JPARegistPrmEnv(JPAEmitterWorkData* work) { GXSetTevColor(GX_TEVREG1, env); } -/* 80276DB0-80276E60 2716F0 00B0+00 0/0 1/1 0/0 .text - * JPARegistAlpha__FP18JPAEmitterWorkDataP15JPABaseParticle */ void JPARegistAlpha(JPAEmitterWorkData* work, JPABaseParticle* ptcl) { JPABaseEmitter* emtr = work->mpEmtr; GXColor prm = emtr->mPrmClr; @@ -85,8 +70,6 @@ void JPARegistAlpha(JPAEmitterWorkData* work, JPABaseParticle* ptcl) { GXSetTevColor(GX_TEVREG0, prm); } -/* 80276E60-80276F10 2717A0 00B0+00 0/0 1/1 0/0 .text - * JPARegistPrmAlpha__FP18JPAEmitterWorkDataP15JPABaseParticle */ void JPARegistPrmAlpha(JPAEmitterWorkData* work, JPABaseParticle* ptcl) { JPABaseEmitter* emtr = work->mpEmtr; GXColor prm = ptcl->mPrmClr; @@ -98,8 +81,6 @@ void JPARegistPrmAlpha(JPAEmitterWorkData* work, JPABaseParticle* ptcl) { GXSetTevColor(GX_TEVREG0, prm); } -/* 80276F10-80277024 271850 0114+00 0/0 1/1 0/0 .text - * JPARegistPrmAlphaEnv__FP18JPAEmitterWorkDataP15JPABaseParticle */ void JPARegistPrmAlphaEnv(JPAEmitterWorkData* work, JPABaseParticle* ptcl) { JPABaseEmitter* emtr = work->mpEmtr; GXColor prm = ptcl->mPrmClr; @@ -116,8 +97,6 @@ void JPARegistPrmAlphaEnv(JPAEmitterWorkData* work, JPABaseParticle* ptcl) { GXSetTevColor(GX_TEVREG1, env); } -/* 80277024-80277138 271964 0114+00 0/0 1/1 0/0 .text - * JPARegistAlphaEnv__FP18JPAEmitterWorkDataP15JPABaseParticle */ void JPARegistAlphaEnv(JPAEmitterWorkData* work, JPABaseParticle* ptcl) { JPABaseEmitter* emtr = work->mpEmtr; GXColor prm = emtr->mPrmClr; @@ -134,8 +113,6 @@ void JPARegistAlphaEnv(JPAEmitterWorkData* work, JPABaseParticle* ptcl) { GXSetTevColor(GX_TEVREG1, env); } -/* 80277138-802771BC 271A78 0084+00 0/0 1/1 0/0 .text - * JPARegistEnv__FP18JPAEmitterWorkDataP15JPABaseParticle */ void JPARegistEnv(JPAEmitterWorkData* work, JPABaseParticle* ptcl) { JPABaseEmitter* emtr = work->mpEmtr; GXColor env = ptcl->mEnvClr; @@ -145,8 +122,6 @@ void JPARegistEnv(JPAEmitterWorkData* work, JPABaseParticle* ptcl) { GXSetTevColor(GX_TEVREG1, env); } -/* 802771BC-802771E8 271AFC 002C+00 0/0 1/1 0/0 .text JPACalcClrIdxNormal__FP18JPAEmitterWorkData - */ void JPACalcClrIdxNormal(JPAEmitterWorkData* work) { JPABaseShape* bsp = work->mpRes->getBsp(); s16 keyFrame; @@ -158,138 +133,92 @@ void JPACalcClrIdxNormal(JPAEmitterWorkData* work) { work->mClrKeyFrame = keyFrame; } -/* 802771E8-80277210 271B28 0028+00 0/0 1/1 0/0 .text - * JPACalcClrIdxNormal__FP18JPAEmitterWorkDataP15JPABaseParticle */ void JPACalcClrIdxNormal(JPAEmitterWorkData* work, JPABaseParticle* param_1) { JPABaseShape* shape = work->mpRes->getBsp(); - s16 keyFrame; - if (param_1->mAge < shape->getClrAnmMaxFrm()) { - keyFrame = param_1->mAge; - } else { - keyFrame = shape->getClrAnmMaxFrm(); - } - work->mClrKeyFrame = keyFrame; + work->mClrKeyFrame = param_1->mAge < shape->getClrAnmMaxFrm() ? param_1->mAge : shape->getClrAnmMaxFrm(); } -/* 80277210-80277240 271B50 0030+00 0/0 1/1 0/0 .text JPACalcClrIdxRepeat__FP18JPAEmitterWorkData - */ void JPACalcClrIdxRepeat(JPAEmitterWorkData* work) { JPABaseShape* shape = work->mpRes->getBsp(); work->mClrKeyFrame = work->mpEmtr->mTick % (shape->getClrAnmMaxFrm() + 1); } -/* 80277240-8027727C 271B80 003C+00 0/0 1/1 0/0 .text - * JPACalcClrIdxRepeat__FP18JPAEmitterWorkDataP15JPABaseParticle */ void JPACalcClrIdxRepeat(JPAEmitterWorkData* work, JPABaseParticle* param_1) { JPABaseShape* shape = work->mpRes->getBsp(); - s32 tick = param_1->mAge + shape->getClrLoopOfst(param_1->mAnmRandom); - work->mClrKeyFrame = tick % (shape->getClrAnmMaxFrm() + 1); + s32 r28 = shape->getClrAnmMaxFrm() + 1; + work->mClrKeyFrame = (param_1->mAge + shape->getClrLoopOfst(param_1->mAnmRandom)) % r28; } -/* 8027727C-802772BC 271BBC 0040+00 0/0 1/1 0/0 .text JPACalcClrIdxReverse__FP18JPAEmitterWorkData - */ void JPACalcClrIdxReverse(JPAEmitterWorkData* work) { JPABaseShape* shape = work->mpRes->getBsp(); int maxFrm = shape->getClrAnmMaxFrm(); - u32 tick = work->mpEmtr->mTick; - u32 uVar1 = tick / maxFrm; - tick = tick % maxFrm; - uVar1 &= 1; - work->mClrKeyFrame = tick + (uVar1) * (maxFrm - tick * 2); + u32 div = (work->mpEmtr->mTick / maxFrm) & 1; + u32 rem = work->mpEmtr->mTick % maxFrm; + work->mClrKeyFrame = rem + (div) * (maxFrm - rem * 2); } -/* 802772BC-80277308 271BFC 004C+00 0/0 1/1 0/0 .text - * JPACalcClrIdxReverse__FP18JPAEmitterWorkDataP15JPABaseParticle */ void JPACalcClrIdxReverse(JPAEmitterWorkData* work, JPABaseParticle* param_1) { JPABaseShape* shape = work->mpRes->getBsp(); - s32 tick = param_1->mAge + shape->getClrLoopOfst(param_1->mAnmRandom); + s32 r29 = param_1->mAge + shape->getClrLoopOfst(param_1->mAnmRandom); s32 maxFrm = shape->getClrAnmMaxFrm(); - s32 rem = tick % maxFrm; - work->mClrKeyFrame = rem + ((tick / maxFrm) & 1) * (maxFrm - rem * 2); + s32 div = (r29 / maxFrm) & 1; + s32 rem = r29 % maxFrm; + work->mClrKeyFrame = rem + (div) * (maxFrm - rem * 2); } -/* 80277308-80277314 271C48 000C+00 0/0 1/1 0/0 .text JPACalcClrIdxMerge__FP18JPAEmitterWorkData - */ void JPACalcClrIdxMerge(JPAEmitterWorkData* work) { work->mClrKeyFrame = 0; } -/* 80277314-80277384 271C54 0070+00 0/0 1/1 0/0 .text - * JPACalcClrIdxMerge__FP18JPAEmitterWorkDataP15JPABaseParticle */ void JPACalcClrIdxMerge(JPAEmitterWorkData* work, JPABaseParticle* param_1) { JPABaseShape* shape = work->mpRes->getBsp(); s32 maxFrm = shape->getClrAnmMaxFrm() + 1; - s32 tick = (s32)(param_1->mTime * maxFrm) + shape->getClrLoopOfst(param_1->mAnmRandom); - work->mClrKeyFrame = tick % maxFrm; + work->mClrKeyFrame = (s32(param_1->mTime * maxFrm) + shape->getClrLoopOfst(param_1->mAnmRandom)) % maxFrm; } -/* 80277384-80277390 271CC4 000C+00 0/0 1/1 0/0 .text JPACalcClrIdxRandom__FP18JPAEmitterWorkData - */ void JPACalcClrIdxRandom(JPAEmitterWorkData* work) { work->mClrKeyFrame = 0; } -/* 80277390-802773C4 271CD0 0034+00 0/0 1/1 0/0 .text - * JPACalcClrIdxRandom__FP18JPAEmitterWorkDataP15JPABaseParticle */ void JPACalcClrIdxRandom(JPAEmitterWorkData* work, JPABaseParticle* param_1) { JPABaseShape* shape = work->mpRes->getBsp(); - s32 tick = shape->getClrLoopOfst(param_1->mAnmRandom); - s32 maxFrm = shape->getClrAnmMaxFrm() + 1; - work->mClrKeyFrame = tick % maxFrm; + work->mClrKeyFrame = shape->getClrLoopOfst(param_1->mAnmRandom) % (shape->getClrAnmMaxFrm() + 1); } -/* 802773C4-80277404 271D04 0040+00 0/0 1/1 0/0 .text JPACalcPrm__FP18JPAEmitterWorkData - */ void JPACalcPrm(JPAEmitterWorkData* work) { work->mpRes->getBsp()->getPrmClr(work->mClrKeyFrame, &work->mpEmtr->mPrmClr); } -/* 80277404-80277440 271D44 003C+00 0/0 1/1 0/0 .text - * JPACalcPrm__FP18JPAEmitterWorkDataP15JPABaseParticle */ void JPACalcPrm(JPAEmitterWorkData* work, JPABaseParticle* ptcl) { work->mpRes->getBsp()->getPrmClr(work->mClrKeyFrame, &ptcl->mPrmClr); } -/* 80277440-80277480 271D80 0040+00 0/0 1/1 0/0 .text JPACalcEnv__FP18JPAEmitterWorkData - */ void JPACalcEnv(JPAEmitterWorkData* work) { work->mpRes->getBsp()->getEnvClr(work->mClrKeyFrame, &work->mpEmtr->mEnvClr); } -/* 80277480-802774BC 271DC0 003C+00 0/0 1/1 0/0 .text - * JPACalcEnv__FP18JPAEmitterWorkDataP15JPABaseParticle */ void JPACalcEnv(JPAEmitterWorkData* work, JPABaseParticle* ptcl) { work->mpRes->getBsp()->getEnvClr(work->mClrKeyFrame, &ptcl->mEnvClr); } -/* 802774BC-80277504 271DFC 0048+00 0/0 1/1 0/0 .text - * JPACalcColorCopy__FP18JPAEmitterWorkDataP15JPABaseParticle */ void JPACalcColorCopy(JPAEmitterWorkData* work, JPABaseParticle* ptcl) { JPABaseEmitter* emtr = work->mpEmtr; ptcl->mPrmClr = emtr->mPrmClr; ptcl->mEnvClr = emtr->mEnvClr; } -/* 80277504-8027753C 271E44 0038+00 0/0 1/1 0/0 .text JPAGenTexCrdMtxIdt__FP18JPAEmitterWorkData - */ void JPAGenTexCrdMtxIdt(JPAEmitterWorkData* param_0) { GXSetTexCoordGen2(GX_TEXCOORD0, GX_TG_MTX2x4, GX_TG_TEX0, GX_IDENTITY, GX_FALSE, GX_PTIDENTITY); } -/* 8027753C-80277574 271E7C 0038+00 0/0 1/1 0/0 .text JPAGenTexCrdMtxAnm__FP18JPAEmitterWorkData - */ void JPAGenTexCrdMtxAnm(JPAEmitterWorkData* param_0) { GXSetTexCoordGen2(GX_TEXCOORD0, GX_TG_MTX2x4, GX_TG_TEX0, GX_TEXMTX0, GX_FALSE, GX_PTIDENTITY); } -/* 80277574-802775AC 271EB4 0038+00 0/0 1/1 0/0 .text JPAGenTexCrdMtxPrj__FP18JPAEmitterWorkData - */ void JPAGenTexCrdMtxPrj(JPAEmitterWorkData* param_0) { GXSetTexCoordGen2(GX_TEXCOORD0, GX_TG_MTX3x4, GX_TG_POS, GX_TEXMTX0, GX_FALSE, GX_PTIDENTITY); } -/* 802775AC-80277758 271EEC 01AC+00 0/0 1/1 0/0 .text - * JPAGenCalcTexCrdMtxAnm__FP18JPAEmitterWorkData */ void JPAGenCalcTexCrdMtxAnm(JPAEmitterWorkData* work) { JPABaseShape* shape = work->mpRes->getBsp(); f32 dVar16 = work->mpEmtr->mTick; @@ -321,8 +250,6 @@ void JPAGenCalcTexCrdMtxAnm(JPAEmitterWorkData* work) { GXSetTexCoordGen2(GX_TEXCOORD0, GX_TG_MTX2x4, GX_TG_TEX0, 0x1e, false, 0x7d); } -/* 80277758-802778EC 272098 0194+00 0/0 1/1 0/0 .text - * JPALoadCalcTexCrdMtxAnm__FP18JPAEmitterWorkDataP15JPABaseParticle */ void JPALoadCalcTexCrdMtxAnm(JPAEmitterWorkData* work, JPABaseParticle* param_1) { JPABaseShape* shape = work->mpRes->getBsp(); f32 dVar16 = param_1->mAge; @@ -357,50 +284,33 @@ void fn_8031A8C0(JPAEmitterWorkData* work, JPABaseParticle* ptcl) { work->mpRes->getEts()->fn_8031DE80(work->mpRes->getBsp(), ptcl->getAge()); } -/* 802778EC-80277940 27222C 0054+00 0/0 1/1 0/0 .text JPALoadTex__FP18JPAEmitterWorkData - */ void JPALoadTex(JPAEmitterWorkData* work) { work->mpResMgr->load(work->mpRes->getTexIdx(work->mpRes->getBsp()->getTexIdx()), GX_TEXMAP0); } -/* 80277940-80277990 272280 0050+00 0/0 1/1 0/0 .text JPALoadTexAnm__FP18JPAEmitterWorkData */ void JPALoadTexAnm(JPAEmitterWorkData* work) { work->mpResMgr->load(work->mpRes->getTexIdx(work->mpEmtr->mTexAnmIdx), GX_TEXMAP0); } -/* 80277990-802779DC 2722D0 004C+00 0/0 1/1 0/0 .text - * JPALoadTexAnm__FP18JPAEmitterWorkDataP15JPABaseParticle */ void JPALoadTexAnm(JPAEmitterWorkData* work, JPABaseParticle* ptcl) { work->mpResMgr->load(work->mpRes->getTexIdx(ptcl->mTexAnmIdx), GX_TEXMAP0); } -/* 802779DC-80277A18 27231C 003C+00 0/0 1/1 0/0 .text JPACalcTexIdxNormal__FP18JPAEmitterWorkData - */ void JPACalcTexIdxNormal(JPAEmitterWorkData* work) { JPABaseShape* shape = work->mpRes->getBsp(); - u8 tick = shape->getTexAnmKeyNum() - 1 < work->mpEmtr->mTick - ? shape->getTexAnmKeyNum() - 1 : work->mpEmtr->mTick; - work->mpEmtr->mTexAnmIdx = shape->getTexIdx(tick); + work->mpEmtr->mTexAnmIdx = shape->getTexIdx(shape->getTexAnmKeyNum() - 1 < work->mpEmtr->mTick ? shape->getTexAnmKeyNum() - 1 : work->mpEmtr->mTick); } -/* 80277A18-80277A50 272358 0038+00 0/0 1/1 0/0 .text - * JPACalcTexIdxNormal__FP18JPAEmitterWorkDataP15JPABaseParticle */ void JPACalcTexIdxNormal(JPAEmitterWorkData* work, JPABaseParticle* param_1) { JPABaseShape* shape = work->mpRes->getBsp(); - u8 tick = shape->getTexAnmKeyNum() - 1 < param_1->mAge - ? shape->getTexAnmKeyNum() - 1 : param_1->mAge; - param_1->mTexAnmIdx = shape->getTexIdx(tick); + param_1->mTexAnmIdx = shape->getTexIdx(shape->getTexAnmKeyNum() - 1 < param_1->mAge ? shape->getTexAnmKeyNum() - 1 : param_1->mAge); } -/* 80277A50-80277A88 272390 0038+00 0/0 1/1 0/0 .text JPACalcTexIdxRepeat__FP18JPAEmitterWorkData - */ void JPACalcTexIdxRepeat(JPAEmitterWorkData* work) { JPABaseShape* shape = work->mpRes->getBsp(); work->mpEmtr->mTexAnmIdx = shape->getTexIdx(work->mpEmtr->mTick % shape->getTexAnmKeyNum()); } -/* 80277A88-80277ACC 2723C8 0044+00 0/0 1/1 0/0 .text - * JPACalcTexIdxRepeat__FP18JPAEmitterWorkDataP15JPABaseParticle */ void JPACalcTexIdxRepeat(JPAEmitterWorkData* work, JPABaseParticle* param_1) { JPABaseShape* shape = work->mpRes->getBsp(); param_1->mTexAnmIdx = shape->getTexIdx( @@ -408,75 +318,58 @@ void JPACalcTexIdxRepeat(JPAEmitterWorkData* work, JPABaseParticle* param_1) { % shape->getTexAnmKeyNum()); } -/* 80277ACC-80277B1C 27240C 0050+00 0/0 1/1 0/0 .text JPACalcTexIdxReverse__FP18JPAEmitterWorkData - */ void JPACalcTexIdxReverse(JPAEmitterWorkData* work) { JPABaseShape* shape = work->mpRes->getBsp(); int tick = work->mpEmtr->mTick; int keyNum = (int)shape->getTexAnmKeyNum() - 1; - int div = tick / keyNum; + int div = tick / keyNum & 1; int rem = tick % keyNum; - work->mpEmtr->mTexAnmIdx = shape->getTexIdx(rem + (div & 1) * (keyNum - rem * 2)); + work->mpEmtr->mTexAnmIdx = shape->getTexIdx(rem + div * (keyNum - rem * 2)); } -/* 80277B1C-80277B78 27245C 005C+00 0/0 1/1 0/0 .text - * JPACalcTexIdxReverse__FP18JPAEmitterWorkDataP15JPABaseParticle */ void JPACalcTexIdxReverse(JPAEmitterWorkData* work, JPABaseParticle* param_1) { JPABaseShape* shape = work->mpRes->getBsp(); s32 tick = shape->getTexLoopOfst(param_1->mAnmRandom) + param_1->mAge; int keyNum = (int)shape->getTexAnmKeyNum() - 1; - int div = tick / keyNum; + int div = tick / keyNum & 1; int rem = tick % keyNum; - param_1->mTexAnmIdx = shape->getTexIdx(rem + (div & 1) * (keyNum - rem * 2)); + param_1->mTexAnmIdx = shape->getTexIdx(rem + div * (keyNum - rem * 2)); } -/* 80277B78-80277B94 2724B8 001C+00 0/0 1/1 0/0 .text JPACalcTexIdxMerge__FP18JPAEmitterWorkData - */ void JPACalcTexIdxMerge(JPAEmitterWorkData* work) { work->mpEmtr->mTexAnmIdx = work->mpRes->getBsp()->getTexIdx(); } -/* 80277B94-80277C0C 2724D4 0078+00 0/0 1/1 0/0 .text - * JPACalcTexIdxMerge__FP18JPAEmitterWorkDataP15JPABaseParticle */ void JPACalcTexIdxMerge(JPAEmitterWorkData* work, JPABaseParticle* param_1) { JPABaseShape* shape = work->mpRes->getBsp(); s32 maxFrm = shape->getTexAnmKeyNum(); - s32 tick = (s32)(maxFrm * param_1->mTime) + shape->getTexLoopOfst(param_1->mAnmRandom); - param_1->mTexAnmIdx = shape->getTexIdx(tick % maxFrm); + param_1->mTexAnmIdx = shape->getTexIdx((s32(maxFrm * param_1->mTime) + shape->getTexLoopOfst(param_1->mAnmRandom)) % maxFrm); } -/* 80277C0C-80277C28 27254C 001C+00 0/0 1/1 0/0 .text JPACalcTexIdxRandom__FP18JPAEmitterWorkData - */ void JPACalcTexIdxRandom(JPAEmitterWorkData* work) { work->mpEmtr->mTexAnmIdx = work->mpRes->getBsp()->getTexIdx(); } -/* 80277C28-80277C64 272568 003C+00 0/0 1/1 0/0 .text - * JPACalcTexIdxRandom__FP18JPAEmitterWorkDataP15JPABaseParticle */ void JPACalcTexIdxRandom(JPAEmitterWorkData* work, JPABaseParticle* param_1) { JPABaseShape* shape = work->mpRes->getBsp(); param_1->mTexAnmIdx = shape->getTexIdx(((int)shape->getTexLoopOfst(param_1->mAnmRandom)) % shape->getTexAnmKeyNum()); } -/* 80277C64-80277C8C 2725A4 0028+00 0/0 1/1 0/0 .text JPALoadPosMtxCam__FP18JPAEmitterWorkData */ void JPALoadPosMtxCam(JPAEmitterWorkData* work) { GXLoadPosMtxImm(work->mPosCamMtx, GX_PNMTX0); } -/* 80277C8C-80277C90 2725CC 0004+00 1/0 0/0 0/0 .text noLoadPrj__FPC18JPAEmitterWorkDataPA4_Cf */ static void noLoadPrj(JPAEmitterWorkData const* work, const Mtx srt) { /* empty function */ } -/* 80277C90-80277CC8 2725D0 0038+00 1/0 0/0 0/0 .text loadPrj__FPC18JPAEmitterWorkDataPA4_Cf */ void loadPrj(JPAEmitterWorkData const* work, const Mtx srt) { Mtx mtx; MTXConcat(work->mPrjMtx, srt, mtx); GXLoadTexMtxImm(mtx, GX_TEXMTX0, GX_MTX3x4); } -/* 80277CC8-80277E88 272608 01C0+00 1/0 0/0 0/0 .text loadPrjAnm__FPC18JPAEmitterWorkDataPA4_Cf */ static void loadPrjAnm(JPAEmitterWorkData const* work, const Mtx srt) { JPABaseShape* shape = work->mpRes->getBsp(); f32 dVar16 = work->mpEmtr->getAge(); @@ -509,13 +402,11 @@ static void loadPrjAnm(JPAEmitterWorkData const* work, const Mtx srt) { GXLoadTexMtxImm(local_108, 0x1e, GX_MTX3x4); } -/* 803C42E0-803C4300 021400 0020+00 10/9 0/0 0/0 .data jpa_dl */ static u8 ALIGN_DECL(32) jpa_dl[32] = { 0x80, 0x00, 0x04, 0x00, 0x00, 0x01, 0x01, 0x02, 0x02, 0x03, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, }; -/* 803C4300-803C4320 021420 0020+00 1/0 0/0 0/0 .data jpa_dl_x */ static u8 ALIGN_DECL(32) jpa_dl_x[32] = { 0x80, 0x00, 0x08, 0x00, 0x00, 0x01, 0x01, 0x02, 0x02, 0x03, 0x03, 0x48, 0x00, 0x49, 0x01, 0x4A, 0x02, 0x4B, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, @@ -523,176 +414,150 @@ static u8 ALIGN_DECL(32) jpa_dl_x[32] = { typedef void (*projectionFunc)(JPAEmitterWorkData const*, const Mtx); -/* 803C4320-803C432C -00001 000C+00 6/10 0/0 0/0 .data p_prj */ static projectionFunc p_prj[3] = { noLoadPrj, loadPrj, loadPrjAnm, }; -/* 80277E88-80277F70 2727C8 00E8+00 0/0 1/1 0/0 .text - * JPADrawBillboard__FP18JPAEmitterWorkDataP15JPABaseParticle */ void JPADrawBillboard(JPAEmitterWorkData* work, JPABaseParticle* param_1) { - if (param_1->checkStatus(8) == 0) { - EGG::Vector3f local_48; - MTXMultVec(work->mPosCamMtx, param_1->mPosition, local_48); - Mtx local_38; - local_38[0][0] = work->mGlobalPtclScl.x * param_1->mParticleScaleX; - local_38[0][3] = local_48.x; - local_38[1][1] = work->mGlobalPtclScl.y * param_1->mParticleScaleY; - local_38[1][3] = local_48.y; - local_38[2][2] = 1.0f; - local_38[2][3] = local_48.z; - local_38[2][1] = 0.0f; - local_38[2][0] = 0.0f; - local_38[1][2] = 0.0f; - local_38[1][0] = 0.0f; - local_38[0][2] = 0.0f; - local_38[0][1] = 0.0f; - GXLoadPosMtxImm(local_38, 0); - p_prj[work->mPrjType](work, local_38); - GXCallDisplayList(jpa_dl, sizeof(jpa_dl)); + if (param_1->checkStatus(JPAPtclStts_Invisible)) { + return; } + + EGG::Vector3f local_48; + MTXMultVec(work->mPosCamMtx, param_1->mPosition, local_48); + Mtx local_38; + local_38[0][0] = work->mGlobalPtclScl.x * param_1->mParticleScaleX; + local_38[0][3] = local_48.x; + local_38[1][1] = work->mGlobalPtclScl.y * param_1->mParticleScaleY; + local_38[1][3] = local_48.y; + local_38[2][2] = 1.0f; + local_38[2][3] = local_48.z; + local_38[0][1] = local_38[0][2] = local_38[1][0] = local_38[1][2] = local_38[2][0] = local_38[2][1] = 0.0f; + GXLoadPosMtxImm(local_38, 0); + p_prj[work->mPrjType](work, local_38); + GXCallDisplayList(jpa_dl, sizeof(jpa_dl)); } -/* 80277F70-80278088 2728B0 0118+00 0/0 1/1 0/0 .text - * JPADrawRotBillboard__FP18JPAEmitterWorkDataP15JPABaseParticle */ void JPADrawRotBillboard(JPAEmitterWorkData* work, JPABaseParticle* param_1) { - if (param_1->checkStatus(8) == 0) { - EGG::Vector3f local_48; - MTXMultVec(work->mPosCamMtx, param_1->mPosition, local_48); - f32 sinRot = nw4r::math::SinIdx((s16)param_1->mRotateAngle); - f32 cosRot = nw4r::math::CosIdx((s16)param_1->mRotateAngle); - f32 particleX = work->mGlobalPtclScl.x * param_1->mParticleScaleX; - f32 particleY = work->mGlobalPtclScl.y * param_1->mParticleScaleY; - - Mtx local_38; - local_38[0][0] = cosRot * particleX; - local_38[0][1] = -sinRot * particleY; - local_38[0][3] = local_48.x; - local_38[1][0] = sinRot * particleX; - local_38[1][1] = cosRot * particleY; - local_38[1][3] = local_48.y; - local_38[2][2] = 1.0f; - local_38[2][3] = local_48.z; - local_38[2][1] = 0.0f; - local_38[2][0] = 0.0f; - local_38[1][2] = 0.0f; - local_38[0][2] = 0.0f; - GXLoadPosMtxImm(local_38, 0); - p_prj[work->mPrjType](work, local_38); - GXCallDisplayList(jpa_dl, sizeof(jpa_dl)); + if (param_1->checkStatus(JPAPtclStts_Invisible)) { + return; } + + EGG::Vector3f local_48; + MTXMultVec(work->mPosCamMtx, param_1->mPosition, local_48); + f32 sinRot = nw4r::math::SinIdx((s16)param_1->mRotateAngle); + f32 cosRot = nw4r::math::CosIdx((s16)param_1->mRotateAngle); + f32 particleX = work->mGlobalPtclScl.x * param_1->mParticleScaleX; + f32 particleY = work->mGlobalPtclScl.y * param_1->mParticleScaleY; + + Mtx local_38; + local_38[0][0] = cosRot * particleX; + local_38[0][1] = -sinRot * particleY; + local_38[0][3] = local_48.x; + local_38[1][0] = sinRot * particleX; + local_38[1][1] = cosRot * particleY; + local_38[1][3] = local_48.y; + local_38[2][2] = 1.0f; + local_38[2][3] = local_48.z; + local_38[0][2] = local_38[1][2] = local_38[2][0] = local_38[2][1] = 0.0f; + GXLoadPosMtxImm(local_38, 0); + p_prj[work->mPrjType](work, local_38); + GXCallDisplayList(jpa_dl, sizeof(jpa_dl)); } -/* 80278088-80278184 2729C8 00FC+00 0/0 1/1 0/0 .text - * JPADrawYBillboard__FP18JPAEmitterWorkDataP15JPABaseParticle */ void JPADrawYBillboard(JPAEmitterWorkData* work, JPABaseParticle* param_1) { - if (param_1->checkStatus(8) == 0) { - EGG::Vector3f local_48; - MTXMultVec(work->mPosCamMtx, param_1->mPosition, local_48); - Mtx local_38; - f32 particleX = work->mGlobalPtclScl.x * param_1->mParticleScaleX; - f32 particleY = work->mGlobalPtclScl.y * param_1->mParticleScaleY; - local_38[0][0] = particleX; - local_38[0][3] = local_48.x; - local_38[1][1] = work->mYBBCamMtx[1][1] * particleY; - local_38[1][2] = work->mYBBCamMtx[1][2]; - local_38[1][3] = local_48.y; - local_38[2][1] = work->mYBBCamMtx[2][1] * particleY; - local_38[2][2] = work->mYBBCamMtx[2][2]; - local_38[2][3] = local_48.z; - local_38[2][0] = 0.0f; - local_38[1][0] = 0.0f; - local_38[0][2] = 0.0f; - local_38[0][1] = 0.0f; - GXLoadPosMtxImm(local_38, 0); - p_prj[work->mPrjType](work, local_38); - GXCallDisplayList(jpa_dl, sizeof(jpa_dl)); + if (param_1->checkStatus(JPAPtclStts_Invisible)) { + return; } + + EGG::Vector3f local_48; + MTXMultVec(work->mPosCamMtx, param_1->mPosition, local_48); + Mtx local_38; + f32 particleX = work->mGlobalPtclScl.x * param_1->mParticleScaleX; + f32 particleY = work->mGlobalPtclScl.y * param_1->mParticleScaleY; + local_38[0][0] = particleX; + local_38[0][3] = local_48.x; + local_38[1][1] = work->mYBBCamMtx[1][1] * particleY; + local_38[1][2] = work->mYBBCamMtx[1][2]; + local_38[1][3] = local_48.y; + local_38[2][1] = work->mYBBCamMtx[2][1] * particleY; + local_38[2][2] = work->mYBBCamMtx[2][2]; + local_38[2][3] = local_48.z; + local_38[0][1] = local_38[0][2] = local_38[1][0] = local_38[2][0] = 0.0f; + GXLoadPosMtxImm(local_38, 0); + p_prj[work->mPrjType](work, local_38); + GXCallDisplayList(jpa_dl, sizeof(jpa_dl)); } -/* 80278184-802782B4 272AC4 0130+00 0/0 1/1 0/0 .text - * JPADrawRotYBillboard__FP18JPAEmitterWorkDataP15JPABaseParticle */ void JPADrawRotYBillboard(JPAEmitterWorkData* work, JPABaseParticle* param_1) { - if (param_1->checkStatus(8) == 0) { - EGG::Vector3f local_48; - MTXMultVec(work->mPosCamMtx, param_1->mPosition, local_48); - f32 sinRot = nw4r::math::SinIdx((s16)param_1->mRotateAngle); - f32 cosRot = nw4r::math::CosIdx((s16)param_1->mRotateAngle); - Mtx local_38; - f32 particleX = work->mGlobalPtclScl.x * param_1->mParticleScaleX; - f32 particleY = work->mGlobalPtclScl.y * param_1->mParticleScaleY; - f32 local_98 = (float)(sinRot * particleX); - f32 local_94 = (float)(cosRot * particleY); - f32 local_90 = work->mYBBCamMtx[1][1]; - f32 fVar1 = work->mYBBCamMtx[2][1]; - local_38[0][0] = (float)(cosRot * particleX); - local_38[0][1] = (float)(-sinRot * particleY); - local_38[0][2] = 0.0f; - local_38[0][3] = local_48.x; - local_38[1][0] = local_98 * local_90; - local_38[1][1] = local_94 * local_90; - local_38[1][2] = -fVar1; - local_38[1][3] = local_48.y; - local_38[2][0] = local_98 * fVar1; - local_38[2][1] = local_94 * fVar1; - local_38[2][2] = local_90; - local_38[2][3] = local_48.z; - GXLoadPosMtxImm(local_38, 0); - p_prj[work->mPrjType](work, local_38); - GXCallDisplayList(jpa_dl, sizeof(jpa_dl)); + if (param_1->checkStatus(JPAPtclStts_Invisible)) { + return; } + + EGG::Vector3f local_48; + MTXMultVec(work->mPosCamMtx, param_1->mPosition, local_48); + f32 sinRot = nw4r::math::SinIdx((s16)param_1->mRotateAngle); + f32 cosRot = nw4r::math::CosIdx((s16)param_1->mRotateAngle); + Mtx local_38; + f32 particleX = work->mGlobalPtclScl.x * param_1->mParticleScaleX; + f32 particleY = work->mGlobalPtclScl.y * param_1->mParticleScaleY; + f32 local_98 = (float)(sinRot * particleX); + f32 local_94 = (float)(cosRot * particleY); + f32 local_90 = work->mYBBCamMtx[1][1]; + f32 fVar1 = work->mYBBCamMtx[2][1]; + local_38[0][0] = (float)(cosRot * particleX); + local_38[0][1] = (float)(-sinRot * particleY); + local_38[0][2] = 0.0f; + local_38[0][3] = local_48.x; + local_38[1][0] = local_98 * local_90; + local_38[1][1] = local_94 * local_90; + local_38[1][2] = -fVar1; + local_38[1][3] = local_48.y; + local_38[2][0] = local_98 * fVar1; + local_38[2][1] = local_94 * fVar1; + local_38[2][2] = local_90; + local_38[2][3] = local_48.z; + GXLoadPosMtxImm(local_38, 0); + p_prj[work->mPrjType](work, local_38); + GXCallDisplayList(jpa_dl, sizeof(jpa_dl)); } -/* 802782B4-802782D0 272BF4 001C+00 1/0 0/0 0/0 .text - * dirTypeVel__FPC18JPAEmitterWorkDataPC15JPABaseParticlePQ29JGeometry8TVec3 */ void dirTypeVel(JPAEmitterWorkData const* work, JPABaseParticle const* param_1, EGG::Vector3f* param_2) { - param_1->getVelVec(*param_2); + param_1->getVelVec(param_2); } -/* 802782D0-802782EC 272C10 001C+00 1/0 0/0 0/0 .text - * dirTypePos__FPC18JPAEmitterWorkDataPC15JPABaseParticlePQ29JGeometry8TVec3 */ void dirTypePos(JPAEmitterWorkData const* work, JPABaseParticle const* param_1, EGG::Vector3f* param_2) { - param_1->getLocalPosition(*param_2); + param_1->getLocalPosition(param_2); } -/* 802782EC-80278320 272C2C 0034+00 1/0 0/0 0/0 .text - * dirTypePosInv__FPC18JPAEmitterWorkDataPC15JPABaseParticlePQ29JGeometry8TVec3 */ void dirTypePosInv(JPAEmitterWorkData const* work, JPABaseParticle const* param_1, EGG::Vector3f* param_2) { - param_1->getLocalPosition(*param_2); + param_1->getLocalPosition(param_2); *param_2 = param_2->negated(); } -/* 80278320-8027833C 272C60 001C+00 1/0 0/0 0/0 .text - * dirTypeEmtrDir__FPC18JPAEmitterWorkDataPC15JPABaseParticlePQ29JGeometry8TVec3 */ void dirTypeEmtrDir(JPAEmitterWorkData const* work, JPABaseParticle const* param_1, EGG::Vector3f* param_2) { param_2->set(work->mGlobalEmtrDir); } -/* 8027833C-802783D4 272C7C 0098+00 1/0 0/0 0/0 .text - * dirTypePrevPtcl__FPC18JPAEmitterWorkDataPC15JPABaseParticlePQ29JGeometry8TVec3 */ void dirTypePrevPtcl(JPAEmitterWorkData const* work, JPABaseParticle const* param_1, EGG::Vector3f* param_2) { EGG::Vector3f aTStack_24; - param_1->getGlobalPosition(aTStack_24); - JPANode* end = work->mpAlivePtcl->getEnd(); - JPANode* prev = work->mpCurNode->getPrev(); - - if (end != prev) { - JPABaseParticle* particle = work->mpCurNode->getPrev()->getObject(); - particle->getGlobalPosition(*param_2); + param_1->getGlobalPosition(&aTStack_24); + + if (work->mpCurNode->getPrev() != work->mpAlivePtcl->getEnd()) { + work->mpCurNode->getPrev()->getObject()->getGlobalPosition(param_2); } else { work->mpEmtr->calcEmitterGlobalPosition(param_2); } *param_2 -= aTStack_24; } -/* 802783D4-80278414 272D14 0040+00 1/0 0/0 0/0 .text rotTypeY__FffRA3_A4_f */ static void rotTypeY(f32 param_0, f32 param_1, Mtx& param_2) { param_2[0][0] = param_1; param_2[0][1] = 0.0f; @@ -708,7 +573,6 @@ static void rotTypeY(f32 param_0, f32 param_1, Mtx& param_2) { param_2[2][3] = 0.0f; } -/* 80278414-80278454 272D54 0040+00 1/0 0/0 0/0 .text rotTypeX__FffRA3_A4_f */ static void rotTypeX(f32 param_0, f32 param_1, Mtx& param_2) { param_2[0][0] = 1.0f; param_2[0][1] = 0.0f; @@ -724,7 +588,6 @@ static void rotTypeX(f32 param_0, f32 param_1, Mtx& param_2) { param_2[2][3] = 0.0f; } -/* 80278454-80278494 272D94 0040+00 1/0 0/0 0/0 .text rotTypeZ__FffRA3_A4_f */ static void rotTypeZ(f32 param_0, f32 param_1, Mtx& param_2) { param_2[0][0] = param_1; param_2[0][1] = -param_0; @@ -740,7 +603,6 @@ static void rotTypeZ(f32 param_0, f32 param_1, Mtx& param_2) { param_2[2][3] = 0.0f; } -/* 80278494-802784F0 272DD4 005C+00 1/0 0/0 0/0 .text rotTypeXYZ__FffRA3_A4_f */ static void rotTypeXYZ(f32 param_0, f32 param_1, Mtx& param_2) { f32 f3; f32 fVar1; @@ -768,7 +630,6 @@ static void rotTypeXYZ(f32 param_0, f32 param_1, Mtx& param_2) { param_2[2][3] = 0.0f; } -/* 802784F0-8027853C 272E30 004C+00 1/0 0/0 0/0 .text basePlaneTypeXY__FPA4_fff */ static void basePlaneTypeXY(MtxP param_0, f32 param_1, f32 param_2) { param_0[0][0] *= param_1; param_0[1][0] *= param_1; @@ -778,7 +639,6 @@ static void basePlaneTypeXY(MtxP param_0, f32 param_1, f32 param_2) { param_0[2][1] *= param_2; } -/* 8027853C-80278588 272E7C 004C+00 1/0 0/0 0/0 .text basePlaneTypeXZ__FPA4_fff */ static void basePlaneTypeXZ(MtxP param_0, f32 param_1, f32 param_2) { param_0[0][0] *= param_1; param_0[1][0] *= param_1; @@ -788,7 +648,6 @@ static void basePlaneTypeXZ(MtxP param_0, f32 param_1, f32 param_2) { param_0[2][2] *= param_2; } -/* 80278588-802785F8 272EC8 0070+00 1/0 0/0 0/0 .text basePlaneTypeX__FPA4_fff */ static void basePlaneTypeX(MtxP param_0, f32 param_1, f32 param_2) { param_0[0][0] *= param_1; param_0[1][0] *= param_1; @@ -801,7 +660,6 @@ static void basePlaneTypeX(MtxP param_0, f32 param_1, f32 param_2) { param_0[2][2] *= param_1; } -/* 803C432C-803C4340 -00001 0014+00 2/5 0/0 0/0 .data p_direction */ typedef void (*dirTypeFunc)(JPAEmitterWorkData const*, JPABaseParticle const*, EGG::Vector3f*); static dirTypeFunc p_direction[5] = { @@ -809,7 +667,6 @@ static dirTypeFunc p_direction[5] = { dirTypeEmtrDir, dirTypePrevPtcl, }; -/* 803C4340-803C4354 -00001 0014+00 0/2 0/0 0/0 .data p_rot */ typedef void (*rotTypeFunc)(f32, f32, Mtx&); #pragma push #pragma force_active on @@ -819,7 +676,6 @@ static rotTypeFunc p_rot[5] = { }; #pragma pop -/* 803C4354-803C4360 -00001 000C+00 0/3 0/0 0/0 .data p_plane */ typedef void (*planeFunc)(MtxP, f32, f32); @@ -829,158 +685,166 @@ static planeFunc p_plane[3] = { basePlaneTypeX, }; -/* 804507A0-804507A8 -00001 0008+00 3/3 0/0 0/0 .sdata p_dl */ static u8* p_dl[2] = { jpa_dl, jpa_dl_x, }; -/* 802785F8-80278994 272F38 039C+00 0/0 1/1 0/0 .text - * JPADrawDirection__FP18JPAEmitterWorkDataP15JPABaseParticle */ void JPADrawDirection(JPAEmitterWorkData* param_0, JPABaseParticle* param_1) { - if (param_1->checkStatus(8) == 0) { - EGG::Vector3f local_6c; - EGG::Vector3f local_78; - p_direction[param_0->mDirType](param_0, param_1, &local_6c); - if (!local_6c.isZero()) { - local_6c.normalise(); - local_78 = param_1->mBaseAxis.cross(local_6c); - if (!local_78.isZero()) { - local_78.normalise(); - param_1->mBaseAxis = local_6c.cross(local_78); - param_1->mBaseAxis.normalise(); - Mtx local_60; - f32 fVar1 = param_0->mGlobalPtclScl.x * param_1->mParticleScaleX; - f32 fVar2 = param_0->mGlobalPtclScl.y * param_1->mParticleScaleY; - local_60[0][0] = param_1->mBaseAxis.x; - local_60[0][1] = local_6c.x; - local_60[0][2] = local_78.x; - local_60[0][3] = param_1->mPosition.x; - local_60[1][0] = param_1->mBaseAxis.y; - local_60[1][1] = local_6c.y; - local_60[1][2] = local_78.y; - local_60[1][3] = param_1->mPosition.y; - local_60[2][0] = param_1->mBaseAxis.z; - local_60[2][1] = local_6c.z; - local_60[2][2] = local_78.z; - local_60[2][3] = param_1->mPosition.z; - p_plane[param_0->mPlaneType](local_60, fVar1, fVar2); - MTXConcat(param_0->mPosCamMtx, local_60, local_60); - GXLoadPosMtxImm(local_60, 0); - p_prj[param_0->mPrjType](param_0, local_60); - GXCallDisplayList(p_dl[param_0->mDLType], sizeof(jpa_dl)); - } - } - } -} - -/* 80278994-80278DA8 2732D4 0414+00 0/0 1/1 0/0 .text - * JPADrawRotDirection__FP18JPAEmitterWorkDataP15JPABaseParticle */ -void JPADrawRotDirection(JPAEmitterWorkData* param_0, JPABaseParticle* param_1) { - if (param_1->checkStatus(8) == 0) { - f32 sinRot = nw4r::math::SinIdx((s16)param_1->mRotateAngle); - f32 cosRot = nw4r::math::CosIdx((s16)param_1->mRotateAngle); - EGG::Vector3f local_6c; - EGG::Vector3f local_78; - p_direction[param_0->mDirType](param_0, param_1, &local_6c); - if (!local_6c.isZero()) { - local_6c.normalise(); - local_78 = param_1->mBaseAxis.cross(local_6c); - if (!local_78.isZero()) { - local_78.normalise(); - param_1->mBaseAxis = local_6c.cross(local_78); - param_1->mBaseAxis.normalise(); - f32 particleX = param_0->mGlobalPtclScl.x * param_1->mParticleScaleX; - f32 particleY = param_0->mGlobalPtclScl.y * param_1->mParticleScaleY; - Mtx auStack_80; - Mtx local_60; - p_rot[param_0->mRotType](sinRot, cosRot, auStack_80); - p_plane[param_0->mPlaneType](auStack_80, particleX, particleY); - local_60[0][0] = param_1->mBaseAxis.x; - local_60[0][1] = local_6c.x; - local_60[0][2] = local_78.x; - local_60[0][3] = param_1->mPosition.x; - local_60[1][0] = param_1->mBaseAxis.y; - local_60[1][1] = local_6c.y; - local_60[1][2] = local_78.y; - local_60[1][3] = param_1->mPosition.y; - local_60[2][0] = param_1->mBaseAxis.z; - local_60[2][1] = local_6c.z; - local_60[2][2] = local_78.z; - local_60[2][3] = param_1->mPosition.z; - MTXConcat(local_60, auStack_80, auStack_80); - MTXConcat(param_0->mPosCamMtx, auStack_80, local_60); - GXLoadPosMtxImm(local_60, 0); - p_prj[param_0->mPrjType](param_0, local_60); - GXCallDisplayList(p_dl[param_0->mDLType], sizeof(jpa_dl)); - } - } - } -} - -/* 80278DA8-80278FC8 2736E8 0220+00 0/0 1/1 0/0 .text - * JPADrawDBillboard__FP18JPAEmitterWorkDataP15JPABaseParticle */ -void JPADrawDBillboard(JPAEmitterWorkData* param_0, JPABaseParticle* param_1) { - if (param_1->checkStatus(8) == 0) { - EGG::Vector3f local_70; - p_direction[param_0->mDirType](param_0, param_1, &local_70); - EGG::Vector3f aTStack_7c; - aTStack_7c.set(param_0->mPosCamMtx[2][0], param_0->mPosCamMtx[2][1], - param_0->mPosCamMtx[2][2]); - local_70 = local_70.cross(aTStack_7c); - if (!local_70.isZero()) { - local_70.normalise(); - MTXMultVecSR(param_0->mPosCamMtx, local_70, local_70); - EGG::Vector3f local_88; - MTXMultVec(param_0->mPosCamMtx, param_1->mPosition, local_88); - f32 particleX = param_0->mGlobalPtclScl.x * param_1->mParticleScaleX; - f32 particleY = param_0->mGlobalPtclScl.y * param_1->mParticleScaleY; - Mtx local_60; - local_60[0][0] = local_70.x * particleX; - local_60[0][1] = -local_70.y * particleY; - local_60[0][3] = local_88.x; - local_60[1][0] = local_70.y * particleX; - local_60[1][1] = local_70.x * particleY; - local_60[1][3] = local_88.y; - local_60[2][2] = 1.0f; - local_60[2][3] = local_88.z; - local_60[2][1] = 0.0f; - local_60[2][0] = 0.0f; - local_60[1][2] = 0.0f; - local_60[0][2] = 0.0f; - GXLoadPosMtxImm(local_60, 0); - p_prj[param_0->mPrjType](param_0, local_60); - GXCallDisplayList(jpa_dl, sizeof(jpa_dl)); - } - } -} - -/* 80278FC8-80279110 273908 0148+00 0/0 1/1 0/0 .text - * JPADrawRotation__FP18JPAEmitterWorkDataP15JPABaseParticle */ -void JPADrawRotation(JPAEmitterWorkData* param_0, JPABaseParticle* param_1) { - if (param_1->checkStatus(8) == 0) { - f32 sinRot = nw4r::math::SinIdx((s16)param_1->mRotateAngle); - f32 cosRot = nw4r::math::CosIdx((s16)param_1->mRotateAngle); - f32 particleX = param_0->mGlobalPtclScl.x * param_1->mParticleScaleX; - f32 particleY = param_0->mGlobalPtclScl.y * param_1->mParticleScaleY; - Mtx auStack_88; - p_rot[param_0->mRotType](sinRot, cosRot, auStack_88); - p_plane[param_0->mPlaneType](auStack_88, particleX, particleY); - auStack_88[0][3] = param_1->mPosition.x; - auStack_88[1][3] = param_1->mPosition.y; - auStack_88[2][3] = param_1->mPosition.z; - MTXConcat(param_0->mPosCamMtx, auStack_88, auStack_88); - GXLoadPosMtxImm(auStack_88, 0); - p_prj[param_0->mPrjType](param_0, auStack_88); - GXCallDisplayList(p_dl[param_0->mDLType], sizeof(jpa_dl)); - } -} - -/* 80279110-802791B0 273A50 00A0+00 0/0 1/1 0/0 .text - * JPADrawPoint__FP18JPAEmitterWorkDataP15JPABaseParticle */ -void JPADrawPoint(JPAEmitterWorkData* work, JPABaseParticle* ptcl) { - if (!!(ptcl->mStatus & JPAPtclStts_Invisible)) + if (param_1->checkStatus(JPAPtclStts_Invisible)) { return; + } + + EGG::Vector3f local_6c; + EGG::Vector3f local_78; + p_direction[param_0->mDirType](param_0, param_1, &local_6c); + + if (local_6c.isZero()) { + return; + } + + local_6c.normalise(); + local_78 = param_1->mBaseAxis.cross(local_6c); + + if (local_78.isZero()) { + return; + } + + local_78.normalise(); + param_1->mBaseAxis = local_6c.cross(local_78); + param_1->mBaseAxis.normalise(); + Mtx local_60; + f32 fVar1 = param_0->mGlobalPtclScl.x * param_1->mParticleScaleX; + f32 fVar2 = param_0->mGlobalPtclScl.y * param_1->mParticleScaleY; + local_60[0][0] = param_1->mBaseAxis.x; + local_60[0][1] = local_6c.x; + local_60[0][2] = local_78.x; + local_60[0][3] = param_1->mPosition.x; + local_60[1][0] = param_1->mBaseAxis.y; + local_60[1][1] = local_6c.y; + local_60[1][2] = local_78.y; + local_60[1][3] = param_1->mPosition.y; + local_60[2][0] = param_1->mBaseAxis.z; + local_60[2][1] = local_6c.z; + local_60[2][2] = local_78.z; + local_60[2][3] = param_1->mPosition.z; + p_plane[param_0->mPlaneType](local_60, fVar1, fVar2); + MTXConcat(param_0->mPosCamMtx, local_60, local_60); + GXLoadPosMtxImm(local_60, 0); + p_prj[param_0->mPrjType](param_0, local_60); + GXCallDisplayList(p_dl[param_0->mDLType], sizeof(jpa_dl)); +} + +void JPADrawRotDirection(JPAEmitterWorkData* param_0, JPABaseParticle* param_1) { + if (param_1->checkStatus(JPAPtclStts_Invisible)) { + return; + } + + f32 sinRot = nw4r::math::SinIdx((s16)param_1->mRotateAngle); + f32 cosRot = nw4r::math::CosIdx((s16)param_1->mRotateAngle); + EGG::Vector3f local_6c; + EGG::Vector3f local_78; + p_direction[param_0->mDirType](param_0, param_1, &local_6c); + + if (local_6c.isZero()) { + return; + } + + local_6c.normalise(); + local_78 = param_1->mBaseAxis.cross(local_6c); + + if (local_78.isZero()) { + return; + } + + local_78.normalise(); + param_1->mBaseAxis = local_6c.cross(local_78); + param_1->mBaseAxis.normalise(); + f32 particleX = param_0->mGlobalPtclScl.x * param_1->mParticleScaleX; + f32 particleY = param_0->mGlobalPtclScl.y * param_1->mParticleScaleY; + Mtx auStack_80; + Mtx local_60; + p_rot[param_0->mRotType](sinRot, cosRot, auStack_80); + p_plane[param_0->mPlaneType](auStack_80, particleX, particleY); + local_60[0][0] = param_1->mBaseAxis.x; + local_60[0][1] = local_6c.x; + local_60[0][2] = local_78.x; + local_60[0][3] = param_1->mPosition.x; + local_60[1][0] = param_1->mBaseAxis.y; + local_60[1][1] = local_6c.y; + local_60[1][2] = local_78.y; + local_60[1][3] = param_1->mPosition.y; + local_60[2][0] = param_1->mBaseAxis.z; + local_60[2][1] = local_6c.z; + local_60[2][2] = local_78.z; + local_60[2][3] = param_1->mPosition.z; + MTXConcat(local_60, auStack_80, auStack_80); + MTXConcat(param_0->mPosCamMtx, auStack_80, local_60); + GXLoadPosMtxImm(local_60, 0); + p_prj[param_0->mPrjType](param_0, local_60); + GXCallDisplayList(p_dl[param_0->mDLType], sizeof(jpa_dl)); +} + +void JPADrawDBillboard(JPAEmitterWorkData* param_0, JPABaseParticle* param_1) { + if (param_1->checkStatus(JPAPtclStts_Invisible)) { + return; + } + + EGG::Vector3f local_70; + p_direction[param_0->mDirType](param_0, param_1, &local_70); + EGG::Vector3f aTStack_7c(param_0->mPosCamMtx[2][0], param_0->mPosCamMtx[2][1], param_0->mPosCamMtx[2][2]); + local_70 = local_70.cross(aTStack_7c); + + if (local_70.isZero()) { + return; + } + + local_70.normalise(); + MTXMultVecSR(param_0->mPosCamMtx, local_70, local_70); + EGG::Vector3f local_88; + MTXMultVec(param_0->mPosCamMtx, param_1->mPosition, local_88); + f32 particleX = param_0->mGlobalPtclScl.x * param_1->mParticleScaleX; + f32 particleY = param_0->mGlobalPtclScl.y * param_1->mParticleScaleY; + Mtx local_60; + local_60[0][0] = local_70.x * particleX; + local_60[0][1] = -local_70.y * particleY; + local_60[0][3] = local_88.x; + local_60[1][0] = local_70.y * particleX; + local_60[1][1] = local_70.x * particleY; + local_60[1][3] = local_88.y; + local_60[2][2] = 1.0f; + local_60[2][3] = local_88.z; + local_60[0][2] = local_60[1][2] = local_60[2][0] = local_60[2][1] = 0.0f; + GXLoadPosMtxImm(local_60, 0); + p_prj[param_0->mPrjType](param_0, local_60); + GXCallDisplayList(jpa_dl, sizeof(jpa_dl)); +} + +void JPADrawRotation(JPAEmitterWorkData* param_0, JPABaseParticle* param_1) { + if (param_1->checkStatus(JPAPtclStts_Invisible)) { + return; + } + + f32 sinRot = nw4r::math::SinIdx((s16)param_1->mRotateAngle); + f32 cosRot = nw4r::math::CosIdx((s16)param_1->mRotateAngle); + f32 particleX = param_0->mGlobalPtclScl.x * param_1->mParticleScaleX; + f32 particleY = param_0->mGlobalPtclScl.y * param_1->mParticleScaleY; + Mtx auStack_88; + p_rot[param_0->mRotType](sinRot, cosRot, auStack_88); + p_plane[param_0->mPlaneType](auStack_88, particleX, particleY); + auStack_88[0][3] = param_1->mPosition.x; + auStack_88[1][3] = param_1->mPosition.y; + auStack_88[2][3] = param_1->mPosition.z; + MTXConcat(param_0->mPosCamMtx, auStack_88, auStack_88); + GXLoadPosMtxImm(auStack_88, 0); + p_prj[param_0->mPrjType](param_0, auStack_88); + GXCallDisplayList(p_dl[param_0->mDLType], sizeof(jpa_dl)); +} + +void JPADrawPoint(JPAEmitterWorkData* work, JPABaseParticle* ptcl) { + if (ptcl->checkStatus(JPAPtclStts_Invisible)) { + return; + } GXSetVtxDesc(GX_VA_POS, GX_DIRECT); GXSetVtxDesc(GX_VA_TEX0, GX_DIRECT); @@ -992,36 +856,37 @@ void JPADrawPoint(JPAEmitterWorkData* work, JPABaseParticle* ptcl) { GXSetVtxDesc(GX_VA_TEX0, GX_INDEX8); } -/* 802791B0-80279364 273AF0 01B4+00 0/0 1/1 0/0 .text - * JPADrawLine__FP18JPAEmitterWorkDataP15JPABaseParticle */ void JPADrawLine(JPAEmitterWorkData* param_0, JPABaseParticle* param_1) { - if (param_1->checkStatus(8) == 0) { - EGG::Vector3f local_1c = param_1->mPosition; - EGG::Vector3f local_28; - param_1->getVelVec(local_28); - if (!local_28.isZero()) { - local_28.setLength(param_0->mGlobalPtclScl.y * (25.0f * param_1->mParticleScaleY)); - local_28 = local_1c - local_28; - GXSetVtxDesc(GX_VA_POS, GX_DIRECT); - GXSetVtxDesc(GX_VA_TEX0, GX_DIRECT); - GXBegin(GX_LINES, GX_VTXFMT1, 2); - GXPosition3f32(local_1c.x, local_1c.y, local_1c.z); - GXTexCoord2f32(0.0f, 0.0f); - GXPosition3f32(local_28.x, local_28.y, local_28.z); - GXTexCoord2f32(0.0f, 1.0f); - GXEnd(); - GXSetVtxDesc(GX_VA_POS, GX_INDEX8); - GXSetVtxDesc(GX_VA_TEX0, GX_INDEX8); - } + if (param_1->checkStatus(JPAPtclStts_Invisible)) { + return; } + + EGG::Vector3f local_1c(param_1->mPosition); + EGG::Vector3f local_28; + param_1->getVelVec(&local_28); + + if (local_28.isZero()) { + return; + } + + local_28.setLength(param_0->mGlobalPtclScl.y * (25.0f * param_1->mParticleScaleY)); + local_28 = local_1c - local_28; + GXSetVtxDesc(GX_VA_POS, GX_DIRECT); + GXSetVtxDesc(GX_VA_TEX0, GX_DIRECT); + GXBegin(GX_LINES, GX_VTXFMT1, 2); + GXPosition3f32(local_1c.x, local_1c.y, local_1c.z); + GXTexCoord2f32(0.0f, 0.0f); + GXPosition3f32(local_28.x, local_28.y, local_28.z); + GXTexCoord2f32(0.0f, 1.0f); + GXEnd(); + GXSetVtxDesc(GX_VA_POS, GX_INDEX8); + GXSetVtxDesc(GX_VA_TEX0, GX_INDEX8); } -/* 80279364-8027936C 273CA4 0008+00 2/2 0/0 0/0 .text getNext__FP26JPANode<15JPABaseParticle> */ JPANode* getNext(JPANode* param_0) { return param_0->getNext(); } -/* 8027936C-80279374 273CAC 0008+00 2/2 0/0 0/0 .text getPrev__FP26JPANode<15JPABaseParticle> */ JPANode* getPrev(JPANode* param_0) { return param_0->getPrev(); } @@ -1032,7 +897,6 @@ void fn_8031C2C0(JPAEmitterWorkData* work) { work->mpRes->getEts()->fn_8031DE80(work->mpRes->getBsp(), work->mpEmtr->getAge()); } -/* 80279374-8027996C 273CB4 05F8+00 0/0 1/1 0/0 .text JPADrawStripe__FP18JPAEmitterWorkData */ void JPADrawStripe(JPAEmitterWorkData* param_0) { JPABaseShape* shape = param_0->mpRes->getBsp(); u32 ptcl_num = param_0->mpAlivePtcl->getNum(); @@ -1051,8 +915,8 @@ void JPADrawStripe(JPAEmitterWorkData* param_0) { EGG::Vector3f local_e0[2]; EGG::Vector3f local_f8; EGG::Vector3f local_104; - getNodeFunc node_func; - JPANode* startNode; + JPANode* startNode = NULL; + getNodeFunc node_func = NULL; if (shape->isDrawFwdAhead()) { startNode = param_0->mpAlivePtcl->getLast(); node_func = getPrev; @@ -1119,7 +983,6 @@ void JPADrawStripe(JPAEmitterWorkData* param_0) { GXSetVtxDesc(GX_VA_TEX0, GX_INDEX8); } -/* 8027996C-8027A3D8 2742AC 0A6C+00 0/0 1/1 0/0 .text JPADrawStripeX__FP18JPAEmitterWorkData */ void JPADrawStripeX(JPAEmitterWorkData* param_0) { JPABaseShape* shape = param_0->mpRes->getBsp(); u32 ptcl_num = param_0->mpAlivePtcl->getNum(); @@ -1141,8 +1004,8 @@ void JPADrawStripeX(JPAEmitterWorkData* param_0) { EGG::Vector3f local_a8[2]; EGG::Vector3f local_c0; EGG::Vector3f local_cc; - JPANode* startNode; - getNodeFunc node_func; + JPANode* startNode = NULL; + getNodeFunc node_func = NULL; if (shape->isDrawFwdAhead()) { startNode = param_0->mpAlivePtcl->getLast(); node_func = getPrev; @@ -1259,26 +1122,24 @@ void JPADrawStripeX(JPAEmitterWorkData* param_0) { GXSetVtxDesc(GX_VA_TEX0, GX_INDEX8); } -/* 8027A3D8-8027A414 274D18 003C+00 0/0 1/1 0/0 .text - * JPADrawEmitterCallBackB__FP18JPAEmitterWorkData */ void JPADrawEmitterCallBackB(JPAEmitterWorkData* work) { - if (work->mpEmtr->mpEmtrCallBack == NULL) + JPABaseEmitter* emtr = work->mpEmtr; + if (emtr->mpEmtrCallBack == NULL) { return; + } - work->mpEmtr->mpEmtrCallBack->draw(work->mpEmtr); + emtr->mpEmtrCallBack->draw(emtr); } -/* 8027A414-8027A454 274D54 0040+00 0/0 1/1 0/0 .text - * JPADrawParticleCallBack__FP18JPAEmitterWorkDataP15JPABaseParticle */ void JPADrawParticleCallBack(JPAEmitterWorkData* work, JPABaseParticle* ptcl) { - if (work->mpEmtr->mpPtclCallBack == NULL) + JPABaseEmitter* emtr = work->mpEmtr; + if (emtr->mpPtclCallBack == NULL) { return; + } - work->mpEmtr->mpPtclCallBack->draw(work->mpEmtr, ptcl); + emtr->mpPtclCallBack->draw(emtr, ptcl); } -/* 8027A454-8027A6DC 274D94 0288+00 1/1 0/0 0/0 .text - * makeColorTable__FPP8_GXColorPC16JPAClrAnmKeyDataUcsP7JKRHeap */ static void makeColorTable(GXColor** o_color_table, JPAClrAnmKeyData const* i_data, u8 param_2, s16 i_size, EGG::Heap* i_heap) { // The TP code didn't match, the MKDD version helps here @@ -1331,42 +1192,6 @@ static void makeColorTable(GXColor** o_color_table, JPAClrAnmKeyData const* i_da *o_color_table = color_table; } -/* 8027A6DC-8027A7E8 27501C 010C+00 0/0 1/1 0/0 .text __ct__12JPABaseShapeFPCUcP7JKRHeap - */ -JPABaseShape::JPABaseShape(u8 const* pData, EGG::Heap* pHeap) { - mpData = (const JPABaseShapeData*)pData; - - if (isTexCrdAnm()) { - mpTexCrdMtxAnmTbl = (const void*)(pData + sizeof(JPABaseShapeData)); - } else { - mpTexCrdMtxAnmTbl = NULL; - } - - if (isTexAnm()) { - u32 offs = sizeof(JPABaseShapeData); - if (isTexCrdAnm()) - offs = sizeof(JPABaseShapeData) + 0x28; - mpTexIdxAnimTbl = (const u8*)(pData + offs); - } else { - mpTexIdxAnimTbl = NULL; - } - - if (isPrmAnm()) { - makeColorTable(&mpPrmClrAnmTbl, (JPAClrAnmKeyData*)(pData + mpData->mClrPrmAnmOffset), - mpData->mClrPrmKeyNum, mpData->mClrAnmFrmMax, pHeap); - } else { - mpPrmClrAnmTbl = NULL; - } - - if (isEnvAnm()) { - makeColorTable(&mpEnvClrAnmTbl, (JPAClrAnmKeyData*)(pData + mpData->mClrEnvAnmOffset), - mpData->mClrEnvKeyNum, mpData->mClrAnmFrmMax, pHeap); - } else { - mpEnvClrAnmTbl = NULL; - } -} - -/* 803C4360-803C436C 021480 000C+00 0/1 0/0 0/0 .data st_bm__12JPABaseShape */ GXBlendMode JPABaseShape::st_bm[4] = { GX_BM_NONE, GX_BM_BLEND, @@ -1374,26 +1199,22 @@ GXBlendMode JPABaseShape::st_bm[4] = { GX_BM_SUBTRACT, }; -/* 803C436C-803C4394 02148C 0028+00 0/1 0/0 0/0 .data st_bf__12JPABaseShape */ GXBlendFactor JPABaseShape::st_bf[10] = { GX_BL_ZERO, GX_BL_ONE, GX_BL_SRCCLR, GX_BL_INVSRCCLR, - GX_BL_SRCCLR, GX_BL_INVSRCCLR, GX_BL_SRCALPHA, GX_BL_INVSRCALPHA, + GX_BL_DSTCLR, GX_BL_INVDSTCLR, GX_BL_SRCALPHA, GX_BL_INVSRCALPHA, GX_BL_DSTALPHA, GX_BL_INVDSTALPHA, }; -/* 803C4394-803C43D4 0214B4 0040+00 0/1 0/0 0/0 .data st_lo__12JPABaseShape */ GXLogicOp JPABaseShape::st_lo[16] = { GX_LO_CLEAR, GX_LO_SET, GX_LO_COPY, GX_LO_INVCOPY, GX_LO_NOOP, GX_LO_INV, GX_LO_AND, GX_LO_NAND, GX_LO_OR, GX_LO_NOR, GX_LO_XOR, GX_LO_EQUIV, GX_LO_REVAND, GX_LO_INVAND, GX_LO_REVOR, GX_LO_INVOR, }; -/* 803C43D4-803C43F4 0214F4 0020+00 0/1 0/0 0/0 .data st_c__12JPABaseShape */ GXCompare JPABaseShape::st_c[8] = { GX_NEVER, GX_LESS, GX_LEQUAL, GX_EQUAL, GX_NEQUAL, GX_GEQUAL, GX_GREATER, GX_ALWAYS, }; -/* 803C43F4-803C4404 021514 0010+00 0/1 0/0 0/0 .data st_ao__12JPABaseShape */ GXAlphaOp JPABaseShape::st_ao[4] = { GX_AOP_AND, GX_AOP_OR, @@ -1401,7 +1222,6 @@ GXAlphaOp JPABaseShape::st_ao[4] = { GX_AOP_XNOR, }; -/* 803C4404-803C4464 021524 0060+00 0/1 0/0 0/0 .data st_ca__12JPABaseShape */ GXTevColorArg JPABaseShape::st_ca[6][4] = { { GX_CC_ZERO, @@ -1441,7 +1261,6 @@ GXTevColorArg JPABaseShape::st_ca[6][4] = { }, }; -/* 803C4464-803C4488 021584 0020+04 0/1 0/0 0/0 .data st_aa__12JPABaseShape */ JPABaseShapeAlphaArg JPABaseShape::st_aa[5] = { { GX_CA_ZERO, @@ -1484,9 +1303,45 @@ JPABaseShapeAlphaArg JPABaseShape::st_aa[5] = { GX_CS_SCALE_2, }, }; +JPABaseShape::JPABaseShape(u8 const* pData, EGG::Heap* pHeap) { + pBsd = (const JPABaseShapeData*)pData; + + if (isTexCrdAnm()) { + mpTexCrdMtxAnmTbl = (const void*)(pData + sizeof(JPABaseShapeData)); + } else { + mpTexCrdMtxAnmTbl = NULL; + } + + if (isTexAnm()) { + JUT_ASSERT(1698, pBsd->texAnmKeyNum != 0); + u32 offs = sizeof(JPABaseShapeData); + if (isTexCrdAnm()) { + offs += 0x28; + } + mpTexIdxAnimTbl = (const u8*)(pData + offs); + } else { + mpTexIdxAnimTbl = NULL; + } + + if (isPrmAnm()) { + JUT_ASSERT(1707, pBsd->prmAnmKeyNum != 0); + JPAClrAnmKeyData* anmKeyData = (JPAClrAnmKeyData*)(pData + pBsd->mClrPrmAnmOffset); + makeColorTable(&mpPrmClrAnmTbl, anmKeyData, + pBsd->prmAnmKeyNum, pBsd->mClrAnmFrmMax, pHeap); + } else { + mpPrmClrAnmTbl = NULL; + } + + if (isEnvAnm()) { + JUT_ASSERT(1716, pBsd->envAnmKeyNum != 0); + JPAClrAnmKeyData* anmKeyData = (JPAClrAnmKeyData*)(pData + pBsd->mClrEnvAnmOffset); + makeColorTable(&mpEnvClrAnmTbl, anmKeyData, + pBsd->envAnmKeyNum, pBsd->mClrAnmFrmMax, pHeap); + } else { + mpEnvClrAnmTbl = NULL; + } +} -/* 8027A7E8-8027A918 275128 0130+00 0/0 1/1 0/0 .text setGX__12JPABaseShapeCFP18JPAEmitterWorkData - */ void JPABaseShape::setGX(JPAEmitterWorkData* work) const { const GXTevColorArg* colorArg = getTevColorArg(); const JPABaseShapeAlphaArg* alphaArg = getTevAlphaArg(); diff --git a/src/JSystem/JParticle/JPAChildShape.cpp b/src/JSystem/JParticle/JPAChildShape.cpp index 979b5df2..c970dc51 100644 --- a/src/JSystem/JParticle/JPAChildShape.cpp +++ b/src/JSystem/JParticle/JPAChildShape.cpp @@ -1,8 +1,3 @@ -// -// Generated By: dol2asm -// Translation Unit: JPAChildShape -// - #include "JSystem/JParticle/JPAChildShape.h" #include "JSystem/JParticle/JPAParticle.h" #include "JSystem/JParticle/JPAEmitter.h" @@ -15,8 +10,6 @@ void fn_8031DBA0(JPAEmitterWorkData* work) { } } -/* 8027AEBC-8027AFDC 2757FC 0120+00 0/0 1/1 0/0 .text JPARegistChildPrmEnv__FP18JPAEmitterWorkData - */ void JPARegistChildPrmEnv(JPAEmitterWorkData* work) { JPAChildShape* csp = work->mpRes->getCsp(); JPABaseEmitter* emtr = work->mpEmtr; @@ -34,21 +27,16 @@ void JPARegistChildPrmEnv(JPAEmitterWorkData* work) { GXSetTevColor(GX_TEVREG1, env); } -/* 8027AFDC-8027B008 27591C 002C+00 0/0 1/1 0/0 .text - * JPACalcChildAlphaOut__FP18JPAEmitterWorkDataP15JPABaseParticle */ void JPACalcChildAlphaOut(JPAEmitterWorkData* work, JPABaseParticle* ptcl) { f32 anm = (1.0f - ptcl->mTime) * 255.0f; OSf32tou8(&anm, &ptcl->mPrmColorAlphaAnm); } -/* 8027B008-8027B038 275948 0030+00 0/0 1/1 0/0 .text - * JPACalcChildScaleOut__FP18JPAEmitterWorkDataP15JPABaseParticle */ void JPACalcChildScaleOut(JPAEmitterWorkData* work, JPABaseParticle* ptcl) { ptcl->mParticleScaleX = ptcl->mScaleOut * (1.0f - ptcl->mTime); ptcl->mParticleScaleY = ptcl->mAlphaWaveRandom * (1.0f - ptcl->mTime); } -/* 8027B038-8027B040 -00001 0008+00 0/0 0/0 0/0 .text __ct__13JPAChildShapeFPCUc */ JPAChildShape::JPAChildShape(u8 const* pData) { mpData = (JPAChildShapeData*)pData; } diff --git a/src/JSystem/JParticle/JPADynamicsBlock.cpp b/src/JSystem/JParticle/JPADynamicsBlock.cpp index a037be31..4804cd6d 100644 --- a/src/JSystem/JParticle/JPADynamicsBlock.cpp +++ b/src/JSystem/JParticle/JPADynamicsBlock.cpp @@ -1,14 +1,8 @@ -// -// Generated By: dol2asm -// Translation Unit: JPADynamicsBlock -// - #include "JSystem/JParticle/JPADynamicsBlock.h" #include "JSystem/JParticle/JPAEmitter.h" #include "nw4r/math/math_triangular.h" -/* 8027B144-8027B220 275A84 00DC+00 1/1 0/0 0/0 .text JPAVolumePoint__FP18JPAEmitterWorkData */ void JPAVolumePoint(JPAEmitterWorkData* work) { work->mVolumeCalcData.mVolumePos.setZero(); work->mVolumeCalcData.mVelOmni.set(work->mpEmtr->get_r_zh(), work->mpEmtr->get_r_zh(), @@ -17,7 +11,6 @@ void JPAVolumePoint(JPAEmitterWorkData* work) { work->mVolumeCalcData.mVelOmni.z); } -/* 8027B220-8027B33C 275B60 011C+00 1/1 0/0 0/0 .text JPAVolumeLine */ void JPAVolumeLine(JPAEmitterWorkData* work) { if (work->mpEmtr->checkFlag(JPADynFlag_FixedInterval)) { work->mVolumeCalcData.mVolumePos.set( @@ -34,7 +27,6 @@ void JPAVolumeLine(JPAEmitterWorkData* work) { work->mVolumeCalcData.mVelAxis.set(0.0f, 0.0f, work->mVolumeCalcData.mVolumePos.z); } -/* 8027B33C-8027B4E8 275C7C 01AC+00 1/1 0/0 0/0 .text JPAVolumeCircle */ // NONMATCHING regalloc. Could be issue with mul asm implementations void JPAVolumeCircle(JPAEmitterWorkData* work) { s16 theta; @@ -56,29 +48,25 @@ void JPAVolumeCircle(JPAEmitterWorkData* work) { distance = work->mVolumeSize * (work->mVolumeMinRad + distance * (1.0f - work->mVolumeMinRad)); work->mVolumeCalcData.mVolumePos.set(distance * nw4r::math::SinIdx(theta), 0.0f, distance * nw4r::math::CosIdx(theta)); - work->mVolumeCalcData.mVelOmni = work->mVolumeCalcData.mVolumePos; - work->mVolumeCalcData.mVelOmni *= work->mGlobalScl; + work->mVolumeCalcData.mVelOmni.mul(work->mVolumeCalcData.mVolumePos, work->mGlobalScl); work->mVolumeCalcData.mVelAxis.set(work->mVolumeCalcData.mVolumePos.x, 0.0f, work->mVolumeCalcData.mVolumePos.z); } -/* 8027B4E8-8027B5F0 275E28 0108+00 1/1 0/0 0/0 .text JPAVolumeCube */ void JPAVolumeCube(JPAEmitterWorkData* work) { work->mVolumeCalcData.mVolumePos.set(work->mpEmtr->get_r_zh() * work->mVolumeSize, work->mpEmtr->get_r_zh() * work->mVolumeSize, work->mpEmtr->get_r_zh() * work->mVolumeSize); - work->mVolumeCalcData.mVelOmni = work->mVolumeCalcData.mVolumePos; - work->mVolumeCalcData.mVelOmni *= work->mGlobalScl; + work->mVolumeCalcData.mVelOmni.mul(work->mVolumeCalcData.mVolumePos, work->mGlobalScl); work->mVolumeCalcData.mVelAxis.set(work->mVolumeCalcData.mVolumePos.x, 0.0f, work->mVolumeCalcData.mVolumePos.z); } -/* 8027B5F0-8027B87C 275F30 028C+00 1/1 0/0 0/0 .text JPAVolumeSphere__FP18JPAEmitterWorkData */ static void JPAVolumeSphere(JPAEmitterWorkData* work) { - s16 phi, theta; + s16 phi, r28; if (work->mpEmtr->checkFlag(JPADynFlag_FixedInterval)) { - phi = (u16)(work->mVolumeX * 0x8000 / (work->mDivNumber - 1) + 0x4000); - f32 tmp = (u16)(work->mVolumeAngleNum * 0x10000 / (work->mVolumeAngleMax - 1)); - theta = tmp * work->mVolumeSweep + 0x8000; + phi = u16(work->mVolumeX * 0x8000 / (work->mDivNumber - 1) + 0x4000); + u16 r26 = u16(work->mVolumeAngleNum * 0x10000 / (work->mVolumeAngleMax - 1)); + r28 = f32(r26) * work->mVolumeSweep + 0x8000; work->mVolumeAngleNum++; if (work->mVolumeAngleNum == work->mVolumeAngleMax) { work->mVolumeAngleNum = 0; @@ -92,16 +80,16 @@ static void JPAVolumeSphere(JPAEmitterWorkData* work) { } } else { phi = work->mpEmtr->get_r_ss() >> 1; - theta = work->mVolumeSweep * work->mpEmtr->get_r_ss(); + r28 = work->mVolumeSweep * work->mpEmtr->get_r_ss(); } - f32 rnd = work->mpEmtr->get_r_f(); + f32 f31 = work->mpEmtr->get_r_f(); if (work->mpEmtr->checkFlag(JPADynFlag_FixedDensity)) { - rnd = 1.0f - rnd * rnd * rnd; + f31 = 1.0f - f31 * f31 * f31; } - f32 rad = work->mVolumeSize * (work->mVolumeMinRad + rnd * (1.0f - work->mVolumeMinRad)); - work->mVolumeCalcData.mVolumePos.set(rad * nw4r::math::CosIdx(phi) * nw4r::math::SinIdx(theta), -rad * nw4r::math::SinIdx(phi), - rad * nw4r::math::CosIdx(phi) * nw4r::math::CosIdx(theta)); + f31 = work->mVolumeSize * (work->mVolumeMinRad + f31 * (1.0f - work->mVolumeMinRad)); + work->mVolumeCalcData.mVolumePos.set(f31 * nw4r::math::CosIdx(phi) * nw4r::math::SinIdx(r28), -f31 * nw4r::math::SinIdx(phi), + f31 * nw4r::math::CosIdx(phi) * nw4r::math::CosIdx(r28)); work->mVolumeCalcData.mVelOmni.set( work->mVolumeCalcData.mVolumePos.x * work->mGlobalScl.x, work->mVolumeCalcData.mVolumePos.y * work->mGlobalScl.y, work->mVolumeCalcData.mVolumePos.z * work->mGlobalScl.z @@ -110,16 +98,15 @@ static void JPAVolumeSphere(JPAEmitterWorkData* work) { work->mVolumeCalcData.mVolumePos.z); } -/* 8027B87C-8027B9F8 2761BC 017C+00 1/1 0/0 0/0 .text JPAVolumeCylinder__FP18JPAEmitterWorkData */ static void JPAVolumeCylinder(JPAEmitterWorkData* work) { - s16 theta = work->mVolumeSweep * work->mpEmtr->get_r_ss(); - f32 rnd = work->mpEmtr->get_r_f(); + s16 r30 = work->mVolumeSweep * work->mpEmtr->get_r_ss(); + f32 f31 = work->mpEmtr->get_r_f(); if (work->mpEmtr->checkFlag(JPADynFlag_FixedDensity)) { - rnd = 1.0f - rnd * rnd; + f31 = 1.0f - f31 * f31; } - f32 rad = work->mVolumeSize * (work->mVolumeMinRad + rnd * (1.0f - work->mVolumeMinRad)); + f31 = work->mVolumeSize * (work->mVolumeMinRad + f31 * (1.0f - work->mVolumeMinRad)); work->mVolumeCalcData.mVolumePos.set( - rad * nw4r::math::SinIdx(theta), work->mVolumeSize * work->mpEmtr->get_r_zp(), rad * nw4r::math::CosIdx(theta)); + f31 * nw4r::math::SinIdx(r30), work->mVolumeSize * work->mpEmtr->get_r_zp(), f31 * nw4r::math::CosIdx(r30)); work->mVolumeCalcData.mVelOmni.set( work->mVolumeCalcData.mVolumePos.x * work->mGlobalScl.x, work->mVolumeCalcData.mVolumePos.y * work->mGlobalScl.y, work->mVolumeCalcData.mVolumePos.z * work->mGlobalScl.z @@ -128,7 +115,6 @@ static void JPAVolumeCylinder(JPAEmitterWorkData* work) { work->mVolumeCalcData.mVolumePos.z); } -/* 8027B9F8-8027BB18 276338 0120+00 1/1 0/0 0/0 .text JPAVolumeTorus__FP18JPAEmitterWorkData */ static void JPAVolumeTorus(JPAEmitterWorkData* work) { s16 theta = work->mVolumeSweep * work->mpEmtr->get_r_ss(); s16 phi = work->mpEmtr->get_r_ss(); @@ -145,7 +131,6 @@ static void JPAVolumeTorus(JPAEmitterWorkData* work) { ); } -/* 8027BB18-8027BB4C 276458 0034+00 0/0 1/1 0/0 .text __ct__16JPADynamicsBlockFPCUc */ JPADynamicsBlock::JPADynamicsBlock(u8 const* data) { mpData = (const JPADynamicsBlockData*)data; init(); @@ -161,7 +146,6 @@ enum { VOL_Line = 0x06, }; -/* 8027BB4C-8027BBE8 27648C 009C+00 2/1 0/0 0/0 .text init__16JPADynamicsBlockFv */ void JPADynamicsBlock::init() { switch (getVolumeType()) { case VOL_Cube: @@ -188,30 +172,18 @@ void JPADynamicsBlock::init() { } } -/* 8027BBE8-8027BDEC 276528 0204+00 0/0 1/1 0/0 .text - * create__16JPADynamicsBlockFP18JPAEmitterWorkData */ void JPADynamicsBlock::create(JPAEmitterWorkData* work) { if (work->mpEmtr->checkStatus(JPAEmtrStts_RateStepEmit)) { - s32 emitCount; - s32 createCount; + s32 emitCount = 0; - // Probably an inlined function. if (work->mpEmtr->checkFlag(JPADynFlag_FixedInterval)) { - s32 count; - if (getVolumeType() == VOL_Sphere) { - count = 4 * getDivNumber() * getDivNumber() + 2; - } else { - count = getDivNumber(); - } - emitCount = count; + emitCount = getVolumeType() == VOL_Sphere ? 4 * getDivNumber() * getDivNumber() + 2 : getDivNumber(); work->mVolumeEmitIdx = 0; } else { f32 newPtclCount = work->mpEmtr->mRate * (getRateRndm() * work->mpEmtr->get_r_zp() + 1.0f); - f32 newEmitCount = work->mpEmtr->mEmitCount + newPtclCount; - work->mpEmtr->mEmitCount = newEmitCount; - emitCount = (s32)newEmitCount; + emitCount = work->mpEmtr->mEmitCount += newPtclCount; work->mpEmtr->mEmitCount -= emitCount; if (work->mpEmtr->checkStatus(JPAEmtrStts_FirstEmit) && 0.0f < newPtclCount && @@ -224,10 +196,10 @@ void JPADynamicsBlock::create(JPAEmitterWorkData* work) { emitCount = 0; } - // Probably an inlined function. - createCount = emitCount; + JPABaseParticle* ptcl = NULL; + s32 createCount = emitCount; while (createCount > 0) { - JPABaseParticle* ptcl = work->mpEmtr->createParticle(); + ptcl = work->mpEmtr->createParticle(); if (ptcl == NULL) break; createCount--; @@ -235,7 +207,7 @@ void JPADynamicsBlock::create(JPAEmitterWorkData* work) { } if (++work->mpEmtr->mRateStepTimer >= (work->mpEmtr->mRateStep + 1)) { - work->mpEmtr->mRateStepTimer -= (work->mpEmtr->mRateStep + 1); + work->mpEmtr->mRateStepTimer -= work->mpEmtr->mRateStep + 1; work->mpEmtr->setStatus(JPAEmtrStts_RateStepEmit); } else { work->mpEmtr->clearStatus(JPAEmtrStts_RateStepEmit); diff --git a/src/JSystem/JParticle/JPAEmitter.cpp b/src/JSystem/JParticle/JPAEmitter.cpp index b61e413d..abfbde46 100644 --- a/src/JSystem/JParticle/JPAEmitter.cpp +++ b/src/JSystem/JParticle/JPAEmitter.cpp @@ -1,8 +1,3 @@ -// -// Generated By: dol2asm -// Translation Unit: JPAEmitter -// - #include "JSystem/JParticle/JPAEmitter.h" #include "JSystem/JParticle/JPAEmitterManager.h" #include "JSystem/JParticle/JPAParticle.h" @@ -10,65 +5,39 @@ #include "JSystem/JParticle/JPABaseShape.h" #include "egg/math/eggVector.h" -// -// Types: -// - -// -// Forward References: -// - -// -// External References: -// - -// -// Declarations: -// - -/* 8027E6A4-8027E6EC 278FE4 0048+00 0/0 14/14 16/16 .text __dt__18JPAEmitterCallBackFv */ JPAEmitterCallBack::~JPAEmitterCallBack() { } -/* 8027E6EC-8027EA40 27902C 0354+00 0/0 1/1 0/0 .text - * init__14JPABaseEmitterFP17JPAEmitterManagerP11JPAResource */ void JPABaseEmitter::init(JPAEmitterManager* param_0, JPAResource* param_1) { mpEmtrMgr = param_0; - mpRes = param_1; - mpRes->getDyn()->getEmitterScl(&mLocalScl); - mpRes->getDyn()->getEmitterTrs(&mLocalTrs); - mpRes->getDyn()->getEmitterDir(&mLocalDir); + pRes = param_1; + pRes->getDyn()->getEmitterScl(&mLocalScl); + pRes->getDyn()->getEmitterTrs(&mLocalTrs); + pRes->getDyn()->getEmitterDir(&mLocalDir); mLocalDir.normalise(); - mpRes->getDyn()->getEmitterRot(&mLocalRot); - mMaxFrame = mpRes->getDyn()->getMaxFrame(); - mLifeTime = mpRes->getDyn()->getLifetime(); - mVolumeSize = mpRes->getDyn()->getVolumeSize(); - mRate = mpRes->getDyn()->getRate(); - mRateStep = mpRes->getDyn()->getRateStep(); - mVolumeSweep = mpRes->getDyn()->getVolumeSweep(); - mVolumeMinRad = mpRes->getDyn()->getVolumeMinRad(); - mAwayFromCenterSpeed = mpRes->getDyn()->getInitVelOmni(); - mAwayFromAxisSpeed = mpRes->getDyn()->getInitVelAxis(); - mDirSpeed = mpRes->getDyn()->getInitVelDir(); - mSpread = mpRes->getDyn()->getInitVelDirSp(); - mRndmDirSpeed = mpRes->getDyn()->getInitVelRndm(); - mAirResist = mpRes->getDyn()->getAirRes(); + pRes->getDyn()->getEmitterRot(&mLocalRot); + mMaxFrame = pRes->getDyn()->getMaxFrame(); + mLifeTime = pRes->getDyn()->getLifetime(); + mVolumeSize = pRes->getDyn()->getVolumeSize(); + mRate = pRes->getDyn()->getRate(); + mRateStep = pRes->getDyn()->getRateStep(); + mVolumeSweep = pRes->getDyn()->getVolumeSweep(); + mVolumeMinRad = pRes->getDyn()->getVolumeMinRad(); + mAwayFromCenterSpeed = pRes->getDyn()->getInitVelOmni(); + mAwayFromAxisSpeed = pRes->getDyn()->getInitVelAxis(); + mDirSpeed = pRes->getDyn()->getInitVelDir(); + mSpread = pRes->getDyn()->getInitVelDirSp(); + mRndmDirSpeed = pRes->getDyn()->getInitVelRndm(); + mAirResist = pRes->getDyn()->getAirRes(); mRndm.set_seed(mpEmtrMgr->pWd->mRndm.get_rndm_u()); MTXIdentity(mGlobalRot); mGlobalScl.set(1.0f, 1.0f, 1.0f); mGlobalTrs.setZero(); mGlobalPScl.set(1.0f, 1.0f); - mGlobalEnvClr.a = 0xff; - mGlobalEnvClr.b = 0xff; - mGlobalEnvClr.g = 0xff; - mGlobalEnvClr.r = 0xff; - mGlobalPrmClr.a = 0xff; - mGlobalPrmClr.b = 0xff; - mGlobalPrmClr.g = 0xff; - mGlobalPrmClr.r = 0xff; + mGlobalPrmClr.r = mGlobalPrmClr.g = mGlobalPrmClr.b = mGlobalPrmClr.a = mGlobalEnvClr.r = mGlobalEnvClr.g = mGlobalEnvClr.b = mGlobalEnvClr.a = 0xff; param_1->getBsp()->getPrmClr(&mPrmClr); param_1->getBsp()->getEnvClr(&mEnvClr); - mpUserWork = NULL; + mpUserWork = 0; mScaleOut = 1.0f; mEmitCount = 0.0f; initStatus(0x30); @@ -79,34 +48,33 @@ void JPABaseEmitter::init(JPAEmitterManager* param_0, JPAResource* param_1) { mTexAnmIdx = 0; } -/* 8027EA40-8027EB60 279380 0120+00 0/0 3/3 0/0 .text createParticle__14JPABaseEmitterFv - */ JPABaseParticle* JPABaseEmitter::createParticle() { if (mpPtclPool->getNum() != 0) { JPANode* node = mpPtclPool->pop_front(); mAlivePtclBase.push_front(node); - mpRes->getDyn()->calc(mpEmtrMgr->pWd); - node->mData.init_p(mpEmtrMgr->pWd); - return &node->mData; + pRes->getDyn()->calc(mpEmtrMgr->pWd); + node->getObject()->init_p(mpEmtrMgr->pWd); + return node->getObject(); + } else { + JUT_WARN(128, "%s", "JPA : Can NOT create particle more\n"); } return NULL; } -/* 8027EB60-8027EC60 2794A0 0100+00 0/0 1/1 0/0 .text - * createChild__14JPABaseEmitterFP15JPABaseParticle */ JPABaseParticle* JPABaseEmitter::createChild(JPABaseParticle* parent) { if (mpPtclPool->getNum() != 0) { JPANode* node = mpPtclPool->pop_front(); mAlivePtclChld.push_front(node); - node->mData.init_c(mpEmtrMgr->pWd, parent); - return &node->mData; + node->getObject()->init_c(mpEmtrMgr->pWd, parent); + return node->getObject(); + } else { + JUT_WARN(151, "%s", "JPA : Can NOT create child particle more\n") } return NULL; } -/* 8027EC60-8027EDD4 2795A0 0174+00 0/0 2/2 21/21 .text deleteAllParticle__14JPABaseEmitterFv */ void JPABaseEmitter::deleteAllParticle() { while (mAlivePtclBase.getNum()) mpPtclPool->push_front(mAlivePtclBase.pop_back()); @@ -114,21 +82,17 @@ void JPABaseEmitter::deleteAllParticle() { mpPtclPool->push_front(mAlivePtclChld.pop_back()); } -/* 8027EDD4-8027EE14 279714 0040+00 0/0 1/1 0/0 .text processTillStartFrame__14JPABaseEmitterFv */ bool JPABaseEmitter::processTillStartFrame() { - JPADynamicsBlock* dyn = mpRes->getDyn(); - s16 startFrame = dyn->getStartFrame(); - - if (mWaitTime >= startFrame) + if (mWaitTime >= pRes->getDyn()->getStartFrame()) return true; - if (!(mStatus & 2)) + if (!checkStatus(2)) { mWaitTime++; + } return false; } -/* 8027EE14-8027EEB0 279754 009C+00 0/0 1/1 0/0 .text processTermination__14JPABaseEmitterFv */ bool JPABaseEmitter::processTermination() { if (checkStatus(0x100)) { return true; @@ -140,19 +104,17 @@ bool JPABaseEmitter::processTermination() { if (mMaxFrame < 0) { setStatus(8); return getParticleNumber() == 0; - } + } if (mTick >= mMaxFrame) { setStatus(8); if (checkStatus(0x40)) { - return false; + return 0; } return getParticleNumber() == 0; } return false; } -/* 8027EEB0-8027EF30 2797F0 0080+00 0/0 1/1 0/0 .text - * calcEmitterGlobalPosition__14JPABaseEmitterCFPQ29JGeometry8TVec3 */ void JPABaseEmitter::calcEmitterGlobalPosition(EGG::Vector3f* dst) const { Mtx mtx; MTXScale(mtx, mGlobalScl.x, mGlobalScl.y, mGlobalScl.z); @@ -163,21 +125,16 @@ void JPABaseEmitter::calcEmitterGlobalPosition(EGG::Vector3f* dst) const { MTXMultVec(mtx, mLocalTrs, *dst); } -/* 8027EF30-8027EF40 279870 0010+00 0/0 1/1 0/0 .text getCurrentCreateNumber__14JPABaseEmitterCFv - */ u32 JPABaseEmitter::getCurrentCreateNumber() const { return mpEmtrMgr->pWd->mEmitCount; } -/* 8027EF40-8027EF50 279880 0010+00 0/0 3/3 0/0 .text getDrawCount__14JPABaseEmitterCFv - */ u8 JPABaseEmitter::getDrawCount() const { return mpEmtrMgr->pWd->mDrawCount; } -/* 8027EF50-8027EFA4 279890 0054+00 0/0 1/1 0/0 .text - * loadTexture__14JPABaseEmitterFUc11_GXTexMapID */ -bool JPABaseEmitter::loadTexture(u8 idx, GXTexMapID texMapID) { - mpEmtrMgr->pWd->mpResMgr->load(mpRes->getTexIdx(idx), texMapID); +bool JPABaseEmitter::loadTexture(u8 no, GXTexMapID texMapID) { + JUT_ASSERT(286, pRes->texNum > no); + mpEmtrMgr->pWd->mpResMgr->load(pRes->getTexIdx(no), texMapID); return true; } diff --git a/src/JSystem/JParticle/JPAEmitterManager.cpp b/src/JSystem/JParticle/JPAEmitterManager.cpp index 54f4a874..75b7f86a 100644 --- a/src/JSystem/JParticle/JPAEmitterManager.cpp +++ b/src/JSystem/JParticle/JPAEmitterManager.cpp @@ -1,8 +1,3 @@ -// -// Generated By: dol2asm -// Translation Unit: JPAEmitterManager -// - #include "JSystem/JParticle/JPAList.h" #include "JSystem/JSupport/JSUList.h" #include "egg/core/eggHeap.h" @@ -16,8 +11,6 @@ #include "rvl/GX/GXTypes.h" #include "rvl/GX.h" -/* 8027DCA0-8027DEBC 2785E0 021C+00 0/0 1/1 0/0 .text __ct__17JPAEmitterManagerFUlUlP7EGG::HeapUcUc - */ JPAEmitterManager::JPAEmitterManager(u32 i_ptclNum, u32 i_emtrNum, EGG::Heap* pHeap, u8 i_gidMax, u8 i_ridMax) { emtrNum = i_emtrNum; @@ -49,16 +42,13 @@ JPAEmitterManager::JPAEmitterManager(u32 i_ptclNum, u32 i_emtrNum, EGG::Heap* pH JUT_ASSERT(67, pWd); } -/* 8027DEBC-8027DFA0 2787FC 00E4+00 0/0 3/3 0/0 .text - * createSimpleEmitterID__17JPAEmitterManagerFRCQ29JGeometry8TVec3UsUcUcP18JPAEmitterCallBackP19JPAParticleCallBack - */ JPABaseEmitter* JPAEmitterManager::createSimpleEmitterID(EGG::Vector3f const& pos, u16 resID, u8 group_id, u8 res_mgr_id, JPAEmitterCallBack* emtrCB, JPAParticleCallBack* ptclCB) { JUT_ASSERT(88, group_id < gidMax); JUT_ASSERT(89, res_mgr_id < ridMax); - JUT_ASSERT(90, pResMgrAry[res_mgr_id] != 0); + JUT_ASSERT(90, pResMgrAry[res_mgr_id] != NULL); JPAResource* pRes = pResMgrAry[res_mgr_id]->getResource(resID); if (pRes == NULL) { @@ -118,7 +108,6 @@ void JPAEmitterManager::fn_80320E20(u8 group_id, f32 of_x, f32 of_z) { } } -/* 8027DFA0-8027E028 2788E0 0088+00 0/0 3/3 0/0 .text calc__17JPAEmitterManagerFUc */ void JPAEmitterManager::calc(u8 group_id) { JUT_ASSERT(154, group_id < gidMax); JSULink* pNext = NULL; @@ -128,13 +117,11 @@ void JPAEmitterManager::calc(u8 group_id) { JPABaseEmitter* emtr = pLink->getObject(); - if (emtr->mpRes->calc(pWd, emtr) && !emtr->checkStatus(0x200)) + if (emtr->pRes->calc(pWd, emtr) && !emtr->checkStatus(0x200)) forceDeleteEmitter(emtr); } } -/* 8027E028-8027E220 278968 01F8+00 0/0 1/1 0/0 .text draw__17JPAEmitterManagerFPC11JPADrawInfoUc - */ void JPAEmitterManager::draw(JPADrawInfo const* drawInfo, u8 group_id) { JUT_ASSERT(192, group_id < gidMax); drawInfo->getCamMtx(pWd->mPosCamMtx); @@ -166,30 +153,24 @@ void JPAEmitterManager::draw(JPADrawInfo const* drawInfo, u8 group_id) { JPABaseEmitter* emtr = pLink->getObject(); if (!emtr->checkStatus(0x04)) { pWd->mpResMgr = pResMgrAry[emtr->mResMgrID]; - emtr->mpRes->draw(pWd, emtr); + emtr->pRes->draw(pWd, emtr); } } GXSetClipMode(GX_CLIP_ENABLE); } -/* 8027E220-8027E278 278B60 0058+00 0/0 1/1 0/0 .text forceDeleteAllEmitter__17JPAEmitterManagerFv - */ void JPAEmitterManager::forceDeleteAllEmitter() { for (u8 i = 0; i < gidMax; i++) forceDeleteGroupEmitter(i); } -/* 8027E278-8027E2D8 278BB8 0060+00 1/1 0/0 0/0 .text - * forceDeleteGroupEmitter__17JPAEmitterManagerFUc */ void JPAEmitterManager::forceDeleteGroupEmitter(u8 group_id) { JUT_ASSERT(288, group_id < gidMax); while (pEmtrUseList[group_id].getNumLinks()) forceDeleteEmitter(pEmtrUseList[group_id].getLast()->getObject()); } -/* 8027E2D8-8027E344 278C18 006C+00 3/3 1/1 0/0 .text - * forceDeleteEmitter__17JPAEmitterManagerFP14JPABaseEmitter */ void JPAEmitterManager::forceDeleteEmitter(JPABaseEmitter* emtr) { emtr->deleteAllParticle(); emtr->setStatus(0x300); @@ -197,17 +178,13 @@ void JPAEmitterManager::forceDeleteEmitter(JPABaseEmitter* emtr) { mFreeEmtrList.prepend(&emtr->mLink); } -/* 8027E344-8027E354 278C84 0010+00 0/0 2/2 0/0 .text - * entryResourceManager__17JPAEmitterManagerFP18JPAResourceManagerUc */ void JPAEmitterManager::entryResourceManager(JPAResourceManager* resMgr, u8 resMgrID) { - JUT_ASSERT_MSG_F(325, resMgrID < ridMax && (pResMgrAry[resMgrID]) == 0, + JUT_ASSERT_MSG_F(325, resMgrID < ridMax && (pResMgrAry[resMgrID]) == NULL, "res_id %d res_id_max %d array[%d] = %x", resMgrID, ridMax, resMgrID, pResMgrAry[resMgrID]); pResMgrAry[resMgrID] = resMgr; } -/* 8027E354-8027E3F4 278C94 00A0+00 0/0 1/1 0/0 .text clearResourceManager__17JPAEmitterManagerFUc - */ void JPAEmitterManager::clearResourceManager(u8 res_mgr_id) { JUT_ASSERT(339, res_mgr_id < ridMax); for (u8 i = 0; i < gidMax; i++) { @@ -224,8 +201,6 @@ void JPAEmitterManager::clearResourceManager(u8 res_mgr_id) { pResMgrAry[res_mgr_id] = NULL; } -/* 8027E3F4-8027E51C 278D34 0128+00 1/1 0/0 0/0 .text calcYBBCam__17JPAEmitterManagerFv - */ void JPAEmitterManager::calcYBBCam() { EGG::Vector3f v(0.0f, pWd->mPosCamMtx[1][1], pWd->mPosCamMtx[2][1]); JUT_ASSERT(367, !v.isZero()); diff --git a/src/JSystem/JParticle/JPAExTexShape.cpp b/src/JSystem/JParticle/JPAExTexShape.cpp index 7d8d08f2..34e72f51 100644 --- a/src/JSystem/JParticle/JPAExTexShape.cpp +++ b/src/JSystem/JParticle/JPAExTexShape.cpp @@ -1,8 +1,3 @@ -// -// Generated By: dol2asm -// Translation Unit: JPAExTexShape -// - #include "JSystem/JParticle/JPAExTexShape.h" #include "JSystem/JParticle/JPAResourceManager.h" #include "JSystem/JParticle/JPAEmitter.h" @@ -10,31 +5,27 @@ #include "rvl/MTX.h" #include "rvl/GX.h" -/* 8027B040-8027B13C 275980 00FC+00 0/0 1/1 0/0 .text JPALoadExTex__FP18JPAEmitterWorkData */ void JPALoadExTex(JPAEmitterWorkData* work) { - Mtx m; JPAExTexShape* ets = work->mpRes->getEts(); - + GXTexCoordID secTexCoordID = GX_TEXCOORD1; if (ets->isUseIndirect()) { + Mtx m; MTXIdentity(m); GXLoadTexMtxImm(m, GX_TEXMTX2, GX_MTX2x4); GXSetTexCoordGen2(GX_TEXCOORD1, GX_TG_MTX2x4, GX_TG_TEX0, GX_TEXMTX2, GX_FALSE, GX_PTIDENTITY); - u8 texIdx = ets->getIndTexIdx(); - work->mpResMgr->load(work->mpRes->getTexIdx(texIdx), GX_TEXMAP2); + work->mpResMgr->load(work->mpRes->getTexIdx(ets->getIndTexIdx()), GX_TEXMAP2); secTexCoordID = GX_TEXCOORD2; } if (ets->isUseSecTex()) { GXSetTexCoordGen2(secTexCoordID, GX_TG_MTX2x4, GX_TG_TEX0, GX_IDENTITY, GX_FALSE, GX_PTIDENTITY); - u8 texIdx = ets->getSecTexIdx(); - work->mpResMgr->load(work->mpRes->getTexIdx(texIdx), GX_TEXMAP3); + work->mpResMgr->load(work->mpRes->getTexIdx(ets->getSecTexIdx()), GX_TEXMAP3); } } -/* 8027B13C-8027B144 -00001 0008+00 0/0 0/0 0/0 .text __ct__13JPAExTexShapeFPCUc */ JPAExTexShape::JPAExTexShape(u8 const* data) { mpData = (const JPAExTexShapeData*)data; } diff --git a/src/JSystem/JParticle/JPAExtraShape.cpp b/src/JSystem/JParticle/JPAExtraShape.cpp index ca825d31..3e565e57 100644 --- a/src/JSystem/JParticle/JPAExtraShape.cpp +++ b/src/JSystem/JParticle/JPAExtraShape.cpp @@ -1,15 +1,8 @@ -// -// Generated By: dol2asm -// Translation Unit: JPAExtraShape -// - #include "JSystem/JParticle/JPAExtraShape.h" #include "JSystem/JParticle/JPAParticle.h" #include "JSystem/JParticle/JPAEmitter.h" #include "nw4r/math/math_triangular.h" -/* 8027A918-8027A990 275258 0078+00 0/0 1/1 0/0 .text - * JPACalcScaleX__FP18JPAEmitterWorkDataP15JPABaseParticle */ void JPACalcScaleX(JPAEmitterWorkData* work, JPABaseParticle* ptcl) { JPAExtraShape* esp = work->mpRes->getEsp(); if (work->mScaleAnm < esp->getScaleInTiming()) { @@ -24,8 +17,6 @@ void JPACalcScaleX(JPAEmitterWorkData* work, JPABaseParticle* ptcl) { } } -/* 8027A990-8027AA08 2752D0 0078+00 0/0 1/1 0/0 .text - * JPACalcScaleY__FP18JPAEmitterWorkDataP15JPABaseParticle */ void JPACalcScaleY(JPAEmitterWorkData* work, JPABaseParticle* ptcl) { JPAExtraShape* esp = work->mpRes->getEsp(); if (work->mScaleAnm < esp->getScaleInTiming()) { @@ -40,57 +31,41 @@ void JPACalcScaleY(JPAEmitterWorkData* work, JPABaseParticle* ptcl) { } } -/* 8027AA08-8027AA14 275348 000C+00 0/0 1/1 0/0 .text - * JPACalcScaleCopy__FP18JPAEmitterWorkDataP15JPABaseParticle */ void JPACalcScaleCopy(JPAEmitterWorkData* work, JPABaseParticle* ptcl) { - JPAExtraShape* esp = work->mpRes->getEsp(); ptcl->mParticleScaleY = ptcl->mParticleScaleX; } -/* 8027AA14-8027AA20 275354 000C+00 0/0 1/1 0/0 .text - * JPACalcScaleAnmNormal__FP18JPAEmitterWorkDataP15JPABaseParticle */ void JPACalcScaleAnmNormal(JPAEmitterWorkData* work, JPABaseParticle* ptcl) { work->mScaleAnm = ptcl->mTime; } -/* 8027AA20-8027AA84 275360 0064+00 0/0 1/1 0/0 .text - * JPACalcScaleAnmRepeatX__FP18JPAEmitterWorkDataP15JPABaseParticle */ void JPACalcScaleAnmRepeatX(JPAEmitterWorkData* work, JPABaseParticle* ptcl) { JPAExtraShape* esp = work->mpRes->getEsp(); work->mScaleAnm = (ptcl->mAge % esp->getScaleAnmCycleX()) / (f32)esp->getScaleAnmCycleX(); } -/* 8027AA84-8027AAE8 2753C4 0064+00 0/0 1/1 0/0 .text - * JPACalcScaleAnmRepeatY__FP18JPAEmitterWorkDataP15JPABaseParticle */ void JPACalcScaleAnmRepeatY(JPAEmitterWorkData* work, JPABaseParticle* ptcl) { JPAExtraShape* esp = work->mpRes->getEsp(); work->mScaleAnm = (ptcl->mAge % esp->getScaleAnmCycleY()) / (f32)esp->getScaleAnmCycleY(); } -/* 8027AAE8-8027AB7C 275428 0094+00 0/0 1/1 0/0 .text - * JPACalcScaleAnmReverseX__FP18JPAEmitterWorkDataP15JPABaseParticle */ void JPACalcScaleAnmReverseX(JPAEmitterWorkData* work, JPABaseParticle* ptcl) { JPAExtraShape* esp = work->mpRes->getEsp(); f32 cycle = ptcl->mAge / esp->getScaleAnmCycleX() & 1; f32 base = (ptcl->mAge % esp->getScaleAnmCycleX()) / (f32)esp->getScaleAnmCycleX(); - work->mScaleAnm = base + (cycle * (1.0f - base * 2.0f)); + work->mScaleAnm = base + cycle * (1.0f - base * 2.0f); } -/* 8027AB7C-8027AC10 2754BC 0094+00 0/0 1/1 0/0 .text - * JPACalcScaleAnmReverseY__FP18JPAEmitterWorkDataP15JPABaseParticle */ void JPACalcScaleAnmReverseY(JPAEmitterWorkData* work, JPABaseParticle* ptcl) { JPAExtraShape* esp = work->mpRes->getEsp(); f32 cycle = ptcl->mAge / esp->getScaleAnmCycleY() & 1; f32 base = (ptcl->mAge % esp->getScaleAnmCycleY()) / (f32)esp->getScaleAnmCycleY(); - work->mScaleAnm = base + (cycle * (1.0f - base * 2.0f)); + work->mScaleAnm = base + cycle * (1.0f - base * 2.0f); } -/* 8027AC10-8027AC98 275550 0088+00 0/0 1/1 0/0 .text - * JPACalcAlphaAnm__FP18JPAEmitterWorkDataP15JPABaseParticle */ void JPACalcAlphaAnm(JPAEmitterWorkData* work, JPABaseParticle* ptcl) { - 0.0f; // float order JPAExtraShape* esp = work->mpRes->getEsp(); - f32 alpha; + f32 alpha = 0.0f; if (ptcl->mTime < esp->getAlphaInTiming()) { alpha = 255.0f * (esp->getAlphaInValue() + esp->getAlphaIncRate() * ptcl->mTime); } else if (ptcl->mTime > esp->getAlphaOutTiming()) { @@ -102,11 +77,9 @@ void JPACalcAlphaAnm(JPAEmitterWorkData* work, JPABaseParticle* ptcl) { OSf32tou8(&alpha, &ptcl->mPrmColorAlphaAnm); } -/* 8027AC98-8027AD88 2755D8 00F0+00 0/0 1/1 0/0 .text - * JPACalcAlphaFlickAnm__FP18JPAEmitterWorkDataP15JPABaseParticle */ void JPACalcAlphaFlickAnm(JPAEmitterWorkData* work, JPABaseParticle* ptcl) { JPAExtraShape* esp = work->mpRes->getEsp(); - f32 alpha; + f32 alpha = 0.0f; if (ptcl->mTime < esp->getAlphaInTiming()) { alpha = (esp->getAlphaInValue() + esp->getAlphaIncRate() * ptcl->mTime); } else if (ptcl->mTime > esp->getAlphaOutTiming()) { @@ -115,19 +88,16 @@ void JPACalcAlphaFlickAnm(JPAEmitterWorkData* work, JPABaseParticle* ptcl) { } else { alpha = esp->getAlphaBaseValue(); } - s32 theta = ptcl->mAlphaWaveRandom * ptcl->mAge * 16384.0f * (1.0f - esp->getAlphaFreq()); - f32 wave = nw4r::math::SinIdx(theta); + f32 wave = nw4r::math::SinIdx(ptcl->mAlphaWaveRandom * ptcl->mAge * 16384.0f * (1.0f - esp->getAlphaFreq())); alpha *= (1.0f + esp->getAlphaAmp() * (wave - 1.0f) * 0.5f) * 255.0f; OSf32tou8(&alpha, &ptcl->mPrmColorAlphaAnm); } -/* 8027AD88-8027ADBC 2756C8 0034+00 0/0 1/1 0/0 .text __ct__13JPAExtraShapeFPCUc */ JPAExtraShape::JPAExtraShape(u8 const* data) { mpData = (const JPAExtraShapeData*)data; init(); } -/* 8027ADBC-8027AEBC 2756FC 0100+00 1/1 0/0 0/0 .text init__13JPAExtraShapeFv */ void JPAExtraShape::init() { mAlphaIncRate = (getAlphaInTiming() != 0.0f) ? (getAlphaBaseValue() - getAlphaInValue()) / getAlphaInTiming() : diff --git a/src/JSystem/JParticle/JPAFieldBlock.cpp b/src/JSystem/JParticle/JPAFieldBlock.cpp index da16788e..20da330a 100644 --- a/src/JSystem/JParticle/JPAFieldBlock.cpp +++ b/src/JSystem/JParticle/JPAFieldBlock.cpp @@ -1,16 +1,10 @@ -// -// Generated By: dol2asm -// Translation Unit: JPAFieldBlock -// - #include "egg/core/eggHeap.h" #include "JSystem/JParticle/JPAFieldBlock.h" #include "JSystem/JParticle/JPAEmitter.h" #include "JSystem/JParticle/JPAParticle.h" +#include "JSystem/JUtility/JUTAssert.h" #include "egg/math/eggVector.h" -/* 8027BDEC-8027BF18 27672C 012C+00 8/8 0/0 0/0 .text - * calcAffect__12JPAFieldBaseFP13JPAFieldBlockP15JPABaseParticle */ void JPAFieldBase::calcAffect(JPAFieldBlock* block, JPABaseParticle* ptcl) { EGG::Vector3f vec = mAccel; if (!ptcl->checkStatus(4) && block->checkStatus(0x78)) { @@ -30,8 +24,6 @@ void JPAFieldBase::calcAffect(JPAFieldBlock* block, JPABaseParticle* ptcl) { } } -/* 8027BF18-8027BFB4 276858 009C+00 2/2 0/0 0/0 .text - * calcFadeAffect__12JPAFieldBaseCFP13JPAFieldBlockf */ f32 JPAFieldBase::calcFadeAffect(JPAFieldBlock* block, f32 time) const { f32 fade = 1.0f; if ((block->checkStatus(8) && time < block->getEnTime()) @@ -46,8 +38,6 @@ f32 JPAFieldBase::calcFadeAffect(JPAFieldBlock* block, f32 time) const { return fade; } -/* 8027BFB4-8027C054 2768F4 00A0+00 1/0 0/0 0/0 .text - * prepare__15JPAFieldGravityFP18JPAEmitterWorkDataP13JPAFieldBlock */ void JPAFieldGravity::prepare(JPAEmitterWorkData* work, JPAFieldBlock* block) { if (block->checkStatus(2)) { mAccel = block->getMag() * block->getDir(); @@ -57,14 +47,10 @@ void JPAFieldGravity::prepare(JPAEmitterWorkData* work, JPAFieldBlock* block) { } } -/* 8027C054-8027C07C 276994 0028+00 1/0 0/0 0/0 .text - * calc__15JPAFieldGravityFP18JPAEmitterWorkDataP13JPAFieldBlockP15JPABaseParticle */ void JPAFieldGravity::calc(JPAEmitterWorkData* work, JPAFieldBlock* block, JPABaseParticle* ptcl) { calcAffect(block, ptcl); } -/* 8027C07C-8027C1B8 2769BC 013C+00 1/0 0/0 0/0 .text - * prepare__11JPAFieldAirFP18JPAEmitterWorkDataP13JPAFieldBlock */ void JPAFieldAir::prepare(JPAEmitterWorkData* work, JPAFieldBlock* block) { EGG::Vector3f vec = block->getDir(); vec.normalise(); @@ -76,8 +62,6 @@ void JPAFieldAir::prepare(JPAEmitterWorkData* work, JPAFieldBlock* block) { } } -/* 8027C1B8-8027C24C 276AF8 0094+00 1/0 0/0 0/0 .text - * calc__11JPAFieldAirFP18JPAEmitterWorkDataP13JPAFieldBlockP15JPABaseParticle */ void JPAFieldAir::calc(JPAEmitterWorkData* work, JPAFieldBlock* block, JPABaseParticle* ptcl) { calcAffect(block, ptcl); if (block->checkStatus(4)) { @@ -88,31 +72,23 @@ void JPAFieldAir::calc(JPAEmitterWorkData* work, JPAFieldBlock* block, JPABasePa } } -/* 8027C24C-8027C29C 276B8C 0050+00 1/0 0/0 0/0 .text - * prepare__14JPAFieldMagnetFP18JPAEmitterWorkDataP13JPAFieldBlock */ void JPAFieldMagnet::prepare(JPAEmitterWorkData* work, JPAFieldBlock* block) { mDir = 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* work, JPAFieldBlock* block, JPABaseParticle* ptcl) { mAccel = 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* work, JPAFieldBlock* block) { mDir = block->getPos() - work->mEmitterPos; MTXMultVecSR(work->mRotationMtx, mDir, mDir); mCutoff = block->getVal1() * block->getVal1(); } -/* 8027C3E0-8027C56C 276D20 018C+00 1/0 0/0 0/0 .text - * calc__14JPAFieldNewtonFP18JPAEmitterWorkDataP13JPAFieldBlockP15JPABaseParticle */ void JPAFieldNewton::calc(JPAEmitterWorkData* work, JPAFieldBlock* block, JPABaseParticle* ptcl) { mAccel = mDir - ptcl->mLocalPosition; f32 len_sq = mAccel.squaredLength(); @@ -124,17 +100,13 @@ void JPAFieldNewton::calc(JPAEmitterWorkData* work, JPAFieldBlock* block, JPABas calcAffect(block, ptcl); } -/* 8027C56C-8027C674 276EAC 0108+00 1/0 0/0 0/0 .text - * prepare__14JPAFieldVortexFP18JPAEmitterWorkDataP13JPAFieldBlock */ void JPAFieldVortex::prepare(JPAEmitterWorkData* work, JPAFieldBlock* block) { - PSMTXMultVecSR(work->mGlobalRot, block->getDir(), field_0x10); + MTXMultVecSR(work->mGlobalRot, block->getDir(), field_0x10); field_0x10.normalise(); 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* work, JPAFieldBlock* block, JPABaseParticle* ptcl) { EGG::Vector3f vec; vec = field_0x10.dot(ptcl->mLocalPosition) * field_0x10; @@ -152,8 +124,6 @@ void JPAFieldVortex::calc(JPAEmitterWorkData* work, JPAFieldBlock* block, JPABas calcAffect(block, ptcl); } -/* 8027C814-8027CA94 277154 0280+00 1/0 0/0 0/0 .text - * prepare__18JPAFieldConvectionFP18JPAEmitterWorkDataP13JPAFieldBlock */ void JPAFieldConvection::prepare(JPAEmitterWorkData* work, JPAFieldBlock* block) { EGG::Vector3f vec1, vec2; vec2 = block->getPos().cross(block->getDir()); @@ -166,8 +136,6 @@ void JPAFieldConvection::prepare(JPAEmitterWorkData* work, JPAFieldBlock* block) field_0x28.normalise(); } -/* 8027CA94-8027CCCC 2773D4 0238+00 1/0 0/0 0/0 .text - * calc__18JPAFieldConvectionFP18JPAEmitterWorkDataP13JPAFieldBlockP15JPABaseParticle */ void JPAFieldConvection::calc(JPAEmitterWorkData* work, JPAFieldBlock* block, JPABaseParticle* ptcl) { EGG::Vector3f vec1, vec2, vec3; @@ -182,8 +150,6 @@ void JPAFieldConvection::calc(JPAEmitterWorkData* work, JPAFieldBlock* block, calcAffect(block, ptcl); } -/* 8027CCCC-8027CDE4 27760C 0118+00 1/0 0/0 0/0 .text - * calc__14JPAFieldRandomFP18JPAEmitterWorkDataP13JPAFieldBlockP15JPABaseParticle */ 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; @@ -193,8 +159,6 @@ void JPAFieldRandom::calc(JPAEmitterWorkData* work, JPAFieldBlock* block, JPABas } } -/* 8027CDE4-8027CE64 277724 0080+00 1/0 0/0 0/0 .text - * calc__12JPAFieldDragFP18JPAEmitterWorkDataP13JPAFieldBlockP15JPABaseParticle */ void JPAFieldDrag::calc(JPAEmitterWorkData* work, JPAFieldBlock* block, JPABaseParticle* ptcl) { if (!ptcl->checkStatus(4)) { f32 fade = calcFadeAffect(block, ptcl->mTime); @@ -204,8 +168,6 @@ void JPAFieldDrag::calc(JPAEmitterWorkData* work, JPAFieldBlock* block, JPABaseP } } -/* 8027CE64-8027CFA8 2777A4 0144+00 1/0 0/0 0/0 .text - * prepare__12JPAFieldSpinFP18JPAEmitterWorkDataP13JPAFieldBlock */ void JPAFieldSpin::prepare(JPAEmitterWorkData* work, JPAFieldBlock* block) { EGG::Vector3f axis; MTXMultVecSR(work->mGlobalRot, block->getDir(), axis); @@ -217,8 +179,6 @@ void JPAFieldSpin::prepare(JPAEmitterWorkData* work, JPAFieldBlock* block) { 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* work, JPAFieldBlock* block, JPABaseParticle* ptcl) { Mtx mtx; mtx[0][0] = field_0x10.x; @@ -238,14 +198,11 @@ void JPAFieldSpin::calc(JPAEmitterWorkData* work, JPAFieldBlock* block, JPABaseP calcAffect(block, ptcl); } -/* 8027D088-8027D0C0 2779C8 0038+00 0/0 1/1 0/0 .text __ct__13JPAFieldBlockFPCUcP7JKRHeap - */ JPAFieldBlock::JPAFieldBlock(u8 const* data, EGG::Heap* heap) : mpData((const JPAFieldBlockData*)data) { init(heap); } -/* 8027D0C0-8027D3AC 277A00 02EC+00 2/1 0/0 0/0 .text init__13JPAFieldBlockFP7JKRHeap */ void JPAFieldBlock::init(EGG::Heap* heap) { mFadeInRate = getFadeInTime() - getEnTime(); if (mFadeInRate == 0.0f) { @@ -267,34 +224,36 @@ void JPAFieldBlock::init(EGG::Heap* heap) { switch (getType()) { case FIELD_GRAVITY: - mpField = new (heap, 4) JPAFieldGravity(); + pFld = new (heap) JPAFieldGravity(); break; case FIELD_AIR: - mpField = new (heap, 4) JPAFieldAir(); + pFld = new (heap) JPAFieldAir(); break; case FIELD_MAGNET: - mpField = new (heap, 4) JPAFieldMagnet(); + pFld = new (heap) JPAFieldMagnet(); break; case FIELD_NEWTON: - mpField = new (heap, 4) JPAFieldNewton(); + pFld = new (heap) JPAFieldNewton(); break; case FIELD_VORTEX: - mpField = new (heap, 4) JPAFieldVortex(); + pFld = new (heap) JPAFieldVortex(); break; case FIELD_RANDOM: - mpField = new (heap, 4) JPAFieldRandom(); + pFld = new (heap) JPAFieldRandom(); break; case FIELD_DRAG: - mpField = new (heap, 4) JPAFieldDrag(); + pFld = new (heap) JPAFieldDrag(); break; case FIELD_CONVECTION: - mpField = new (heap, 4) JPAFieldConvection(); + pFld = new (heap) JPAFieldConvection(); break; case FIELD_SPIN: - mpField = new (heap, 4) JPAFieldSpin(); + pFld = new (heap) JPAFieldSpin(); break; default: - mpField = NULL; + pFld = NULL; + JUT_WARN(483, "JPA : WRONG ID (%d) in field data\n", getType()); break; } + JUT_ASSERT(485, pFld != 0); } diff --git a/src/JSystem/JParticle/JPAKeyBlock.cpp b/src/JSystem/JParticle/JPAKeyBlock.cpp index fdb1e8e6..c4cd83ac 100644 --- a/src/JSystem/JParticle/JPAKeyBlock.cpp +++ b/src/JSystem/JParticle/JPAKeyBlock.cpp @@ -1,25 +1,18 @@ -// -// Generated By: dol2asm -// Translation Unit: JPAKeyBlock -// - #include "JSystem/JParticle/JPAKeyBlock.h" #include "JSystem/JParticle/JPAMath.h" -/* 8027D730-8027D740 278070 0010+00 0/0 1/1 0/0 .text __ct__11JPAKeyBlockFPCUc */ JPAKeyBlock::JPAKeyBlock(const u8* data) : mDataStart(data) , field_0x4(reinterpret_cast(&data[0xC])) { } -/* 8027D740-8027D7D4 278080 0094+00 0/0 1/1 0/0 .text calc__11JPAKeyBlockFf */ f32 JPAKeyBlock::calc(float p1) { - if (mDataStart[0xB] != '\0') { - int v1 = (int)field_0x4[(mDataStart[9] - 1) * 4] + 1; + if (isLoop()) { + int v1 = (int)getKeyData()[(getKeyNum() - 1) * 4] + 1; // p1 -= (v1 * ((int)p1 / v1)); int v2 = ((int)p1 / v1); p1 = p1 - (v2 * v1); } - return JPACalcKeyAnmValue(p1, mDataStart[9], field_0x4); + return JPACalcKeyAnmValue(p1, getKeyNum(), getKeyData()); } diff --git a/src/JSystem/JParticle/JPAMath.cpp b/src/JSystem/JParticle/JPAMath.cpp index 8d3eba27..d3e072a8 100644 --- a/src/JSystem/JParticle/JPAMath.cpp +++ b/src/JSystem/JParticle/JPAMath.cpp @@ -1,8 +1,3 @@ -// -// Generated By: dol2asm -// Translation Unit: JPAMath -// - #include "JSystem/JParticle/JPAMath.h" #include "JSystem/JMath/JMath.h" @@ -10,8 +5,6 @@ #include "egg/math/eggVector.h" #include "nw4r/math/math_triangular.h" -/* 80280588-802806C0 27AEC8 0138+00 0/0 1/1 0/0 .text JPAGetDirMtx__FRCQ29JGeometry8TVec3PA4_f - */ void JPAGetDirMtx(EGG::Vector3f const& param_0, f32 (*param_1)[4]) { 1.0f; // probably some dummy function @@ -42,7 +35,6 @@ void JPAGetDirMtx(EGG::Vector3f const& param_0, f32 (*param_1)[4]) { param_1[2][3] = 0.0f; } -/* 802806C0-80280734 27B000 0074+00 0/0 1/1 0/0 .text JPAGetYZRotateMtx__FssPA4_f */ void JPAGetYZRotateMtx(s16 angleY, s16 angleZ, f32 (*param_2)[4]) { f32 cosy = nw4r::math::CosIdx(angleY); f32 cosz = nw4r::math::CosIdx(angleZ); @@ -56,13 +48,9 @@ void JPAGetYZRotateMtx(s16 angleY, s16 angleZ, f32 (*param_2)[4]) { param_2[1][2] = (siny * sinz); param_2[2][0] = -siny; param_2[2][2] = cosy; - param_2[2][3] = 0.0f; - param_2[2][1] = 0.0f; - param_2[1][3] = 0.0f; - param_2[0][3] = 0.0f; + param_2[0][3] = param_2[1][3] = param_2[2][1] = param_2[2][3] = 0.0f; } -/* 80280734-802807E0 27B074 00AC+00 0/0 6/6 11/11 .text JPAGetXYZRotateMtx__FsssPA4_f */ void JPAGetXYZRotateMtx(s16 x, s16 y, s16 z, Mtx mtx) { f32 cosx = nw4r::math::CosIdx(x); f32 cosy = nw4r::math::CosIdx(y); @@ -75,37 +63,26 @@ void JPAGetXYZRotateMtx(s16 x, s16 y, s16 z, Mtx mtx) { mtx[2][0] = -siny; mtx[2][1] = sinx * cosy; mtx[2][2] = cosx * cosy; - f32 sinxsinz; - f32 cosxcosz; - f32 cosxsinz; - f32 sinxcosz; - cosxsinz = cosx * sinz; - sinxcosz = sinx * cosz; - mtx[0][1] = sinxcosz * siny - cosxsinz; - mtx[1][2] = cosxsinz * siny - sinxcosz; - sinxsinz = sinx * sinz; - cosxcosz = cosx * cosz; - mtx[0][2] = sinxsinz + cosxcosz * siny; - mtx[1][1] = cosxcosz + sinxsinz * siny; - mtx[2][3] = 0.0f; - mtx[1][3] = 0.0f; - mtx[0][3] = 0.0f; + f32 f30 = cosx * sinz; + f32 f29 = sinx * cosz; + mtx[0][1] = f29 * siny - f30; + mtx[1][2] = f30 * siny - f29; + f30 = sinx * sinz; + f29 = cosx * cosz; + mtx[0][2] = f30 + f29 * siny; + mtx[1][1] = f29 + f30 * siny; + mtx[0][3] = mtx[1][3] = mtx[2][3] = 0.0f; } -/* 802807E0-80280808 27B120 0028+00 0/0 11/11 71/71 .text - * JPASetRMtxTVecfromMtx__FPA4_CfPA4_fPQ29JGeometry8TVec3 */ -void JPASetRMtxTVecfromMtx(f32 const (*param_0)[4], f32 (*param_1)[4], EGG::Vector3f *param_2) { +void JPASetRMtxTVecfromMtx(f32 const (*param_0)[4], f32 (*param_1)[4], + EGG::Vector3f* param_2) { EGG::Vector3f dummy; JPASetRMtxSTVecfromMtx(param_0, param_1, &dummy, param_2); } -/* 80280808-80280984 27B148 017C+00 1/1 1/1 53/53 .text - * JPASetRMtxSTVecfromMtx__FPA4_CfPA4_fPQ29JGeometry8TVec3PQ29JGeometry8TVec3 */ -void JPASetRMtxSTVecfromMtx( - f32 const (*param_0)[4], f32 (*param_1)[4], EGG::Vector3f *param_2, EGG::Vector3f *param_3 -) { - EGG::Vector3f aTStack_54; - aTStack_54.set(param_0[0][0], param_0[1][0], param_0[2][0]); +void JPASetRMtxSTVecfromMtx(f32 const (*param_0)[4], f32 (*param_1)[4], + EGG::Vector3f* param_2, EGG::Vector3f* param_3) { + EGG::Vector3f aTStack_54(param_0[0][0], param_0[1][0], param_0[2][0]); param_2->x = aTStack_54.length(); aTStack_54.set(param_0[0][1], param_0[1][1], param_0[2][1]); param_2->y = aTStack_54.length(); @@ -133,7 +110,6 @@ void JPASetRMtxSTVecfromMtx( param_3->set(param_0[0][3], param_0[1][3], param_0[2][3]); } -/* 80280984-80280A48 27B2C4 00C4+00 0/0 2/1 0/0 .text JPACalcKeyAnmValue__FfUsPCf */ f32 JPACalcKeyAnmValue(f32 param_0, u16 param_1, f32 const* param_2) { if (param_0 < param_2[0]) { return param_2[1]; diff --git a/src/JSystem/JParticle/JPAParticle.cpp b/src/JSystem/JParticle/JPAParticle.cpp index 5b90f05d..4d205d2c 100644 --- a/src/JSystem/JParticle/JPAParticle.cpp +++ b/src/JSystem/JParticle/JPAParticle.cpp @@ -1,8 +1,3 @@ -// -// Generated By: dol2asm -// Translation Unit: JPAParticle -// - #include "JSystem/JParticle/JPAParticle.h" #include "JSystem/JParticle/JPABaseShape.h" #include "JSystem/JParticle/JPAChildShape.h" @@ -11,13 +6,10 @@ #include "JSystem/JParticle/JPAExtraShape.h" #include "egg/math/eggVector.h" -/* 8027EFA4-8027EFEC 2798E4 0048+00 0/0 11/11 1/1 .text __dt__19JPAParticleCallBackFv */ JPAParticleCallBack::~JPAParticleCallBack() { /* empty function */ } -/* 8027EFEC-8027F8C8 27992C 08DC+00 0/0 1/1 0/0 .text - * init_p__15JPABaseParticleFP18JPAEmitterWorkData */ void JPABaseParticle::init_p(JPAEmitterWorkData* work) { JPABaseEmitter* emtr = work->mpEmtr; JPAExtraShape* esp = work->mpRes->getEsp(); @@ -128,8 +120,6 @@ void JPABaseParticle::init_p(JPAEmitterWorkData* work) { } } -/* 8027F8C8-8027FFD0 27A208 0708+00 0/0 1/1 0/0 .text - * init_c__15JPABaseParticleFP18JPAEmitterWorkDataP15JPABaseParticle */ void JPABaseParticle::init_c(JPAEmitterWorkData* work, JPABaseParticle* parent) { JPABaseEmitter* emtr = work->mpEmtr; JPAChildShape* csp = work->mpRes->getCsp(); @@ -214,8 +204,6 @@ void JPABaseParticle::init_c(JPAEmitterWorkData* work, JPABaseParticle* parent) mTexAnmIdx = 0; } -/* 8027FFD0-80280260 27A910 0290+00 0/0 1/1 0/0 .text - * calc_p__15JPABaseParticleFP18JPAEmitterWorkData */ bool JPABaseParticle::calc_p(JPAEmitterWorkData* work) { if (++mAge >= mLifeTime) { return true; @@ -262,8 +250,6 @@ bool JPABaseParticle::calc_p(JPAEmitterWorkData* work) { return false; } -/* 80280260-802804C8 27ABA0 0268+00 0/0 1/1 0/0 .text - * calc_c__15JPABaseParticleFP18JPAEmitterWorkData */ bool JPABaseParticle::calc_c(JPAEmitterWorkData* work) { if (++mAge >= mLifeTime) { return true; @@ -306,8 +292,6 @@ bool JPABaseParticle::calc_c(JPAEmitterWorkData* work) { return false; } -/* 802804C8-80280548 27AE08 0080+00 1/1 0/0 0/0 .text - * canCreateChild__15JPABaseParticleFP18JPAEmitterWorkData */ bool JPABaseParticle::canCreateChild(JPAEmitterWorkData* work) { JPAChildShape* csp = work->mpRes->getCsp(); bool ret = false; @@ -318,16 +302,10 @@ bool JPABaseParticle::canCreateChild(JPAEmitterWorkData* work) { return ret; } -/* 80280548-80280568 27AE88 0020+00 0/0 3/3 0/0 .text - * getWidth__15JPABaseParticleCFPC14JPABaseEmitter */ f32 JPABaseParticle::getWidth(JPABaseEmitter const* emtr) const { - f32 scale = 2.0f * mParticleScaleX; - return scale * emtr->mpEmtrMgr->pWd->mGlobalPtclScl.x; + return mParticleScaleX * 2.0f * emtr->mpEmtrMgr->pWd->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 = 2.0f * mParticleScaleY; - return scale * emtr->mpEmtrMgr->pWd->mGlobalPtclScl.y; + return mParticleScaleY * 2.0f * emtr->mpEmtrMgr->pWd->mGlobalPtclScl.y; } diff --git a/src/JSystem/JParticle/JPAResource.cpp b/src/JSystem/JParticle/JPAResource.cpp index d678396e..33dcaad2 100644 --- a/src/JSystem/JParticle/JPAResource.cpp +++ b/src/JSystem/JParticle/JPAResource.cpp @@ -1,8 +1,3 @@ -// -// Generated By: dol2asm -// Translation Unit: JPAResource -// - #include "egg/core/eggHeap.h" #include "JSystem/JParticle/JPAResource.h" #include "JSystem/JParticle/JPABaseShape.h" @@ -14,39 +9,23 @@ #include "JSystem/JParticle/JPAKeyBlock.h" #include "JSystem/JParticle/JPAParticle.h" #include "JSystem/JParticle/JPAResourceManager.h" +#include "JSystem/JUtility/JUTAssert.h" #include "rvl/GX.h" -/* 80274010-80274080 26E950 0070+00 0/0 1/1 0/0 .text __ct__11JPAResourceFv */ JPAResource::JPAResource() { - mpDrawEmitterChildFuncList = NULL; - mpDrawEmitterFuncList = NULL; - mpCalcEmitterFuncList = NULL; - mpDrawParticleChildFuncList = NULL; - mpCalcParticleChildFuncList = NULL; - mpDrawParticleFuncList = NULL; - mpCalcParticleFuncList = NULL; - mpBaseShape = NULL; - mpExtraShape = NULL; - mpChildShape = NULL; - mpExTexShape = NULL; - mpDynamicsBlock = NULL; - mpFieldBlocks = NULL; - mpKeyBlocks = NULL; + mpCalcEmitterFuncList = mpDrawEmitterFuncList = mpDrawEmitterChildFuncList = NULL; + mpCalcParticleFuncList = mpDrawParticleFuncList = mpCalcParticleChildFuncList = mpDrawParticleChildFuncList = NULL; + pBsp = NULL; + pEsp = NULL; + pCsp = NULL; + pEts = NULL; + pDyn = NULL; + ppFld = NULL; + ppKey = NULL; mpTDB1 = NULL; - mpDrawParticleChildFuncListNum = 0; - mpCalcParticleChildFuncListNum = 0; - mpDrawParticleFuncListNum = 0; - mpCalcParticleFuncListNum = 0; - mpDrawEmitterChildFuncListNum = 0; - mpDrawEmitterFuncListNum = 0; - mpCalcEmitterFuncListNum = 0; - mTDB1Num = 0; - mKeyBlockNum = 0; - mFieldBlockNum = 0; - mUsrIdx = 0; + mUsrIdx = fldNum = keyNum = texNum = mpCalcEmitterFuncListNum = mpDrawEmitterFuncListNum = mpDrawEmitterChildFuncListNum = mpCalcParticleFuncListNum = mpDrawParticleFuncListNum = mpCalcParticleChildFuncListNum = mpDrawParticleChildFuncListNum = 0; } -/* 803C40C0-803C4220 0211E0 0144+1C 2/2 0/0 0/0 .data jpa_pos */ 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, @@ -71,39 +50,38 @@ static u8 jpa_pos[324] ALIGN_DECL(32) = { 0x00, 0x00, 0x00, 0xCE, }; -/* 803C4220-803C4240 021340 0020+00 2/2 0/0 0/0 .data jpa_crd */ 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, }; -/* 80274080-802755E8 26E9C0 1568+00 2/0 1/1 0/0 .text init__11JPAResourceFP7JKRHeap */ void JPAResource::init(EGG::Heap* heap) { - // The s32s here are probably fake but fixes the regswaps - s32 is_glbl_clr_anm = mpBaseShape->isGlblClrAnm(); - s32 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(); + // The s32s here are fake but fixes the regswaps + s32 is_glbl_clr_anm = pBsp->isGlblClrAnm(); + s32 is_glbl_tex_anm = pBsp->isGlblTexAnm(); + BOOL is_prm_anm = pBsp->isPrmAnm(); + BOOL is_env_anm = pBsp->isEnvAnm(); + BOOL is_tex_anm = pBsp->isTexAnm(); + BOOL is_tex_crd_anm = pBsp->isTexCrdAnm(); + BOOL is_prj_tex = pBsp->isPrjTex(); + BOOL is_enable_scale_anm = pEsp != NULL && pEsp->isEnableScaleAnm(); + BOOL is_enable_alpha_anm = pEsp != NULL && pEsp->isEnableAlphaAnm(); + BOOL is_enable_alpha_flick = pEsp != NULL && pEsp->isEnableAlphaAnm() + && pEsp->isEnableAlphaFlick(); + BOOL is_enable_rotate_anm = pEsp != NULL && pEsp->isEnableRotateAnm(); BOOL is_rotate_on = is_enable_rotate_anm - || (mpChildShape != NULL && mpChildShape->isRotateOn()); - BOOL base_type_5_6 = mpBaseShape->getType() == 5 || mpBaseShape->getType() == 6; - BOOL base_type_0 = mpBaseShape->getType() == 0; - BOOL base_type_0_1 = mpBaseShape->getType() == 0 || mpBaseShape->getType() == 1; - BOOL child_type_5_6 = mpChildShape != NULL - && (mpChildShape->getType() == 5 || mpChildShape->getType() == 6); - BOOL child_type_0 = mpChildShape != NULL && mpChildShape->getType() == 0; - BOOL child_type_0_1 = mpChildShape != NULL - && (mpChildShape->getType() == 0 || mpChildShape->getType() == 1); - BOOL is_draw_parent = !mpBaseShape->isNoDrawParent(); - BOOL is_draw_child = !mpBaseShape->isNoDrawChild(); + || (pCsp != NULL && pCsp->isRotateOn()); + BOOL base_type_5_6 = pBsp->getType() == 5 || pBsp->getType() == 6; + BOOL base_type_0 = pBsp->getType() == 0; + BOOL base_type_0_1 = pBsp->getType() == 0 || pBsp->getType() == 1; + BOOL child_type_5_6 = pCsp != NULL + && (pCsp->getType() == 5 || pCsp->getType() == 6); + BOOL child_type_0 = pCsp != NULL && pCsp->getType() == 0; + BOOL child_type_0_1 = pCsp != NULL + && (pCsp->getType() == 0 || pCsp->getType() == 1); + BOOL is_draw_parent = !pBsp->isNoDrawParent(); + BOOL is_draw_child = !pBsp->isNoDrawChild(); + int func_no = 0; if (is_glbl_tex_anm && is_tex_anm) { mpCalcEmitterFuncListNum++; @@ -126,10 +104,10 @@ void JPAResource::init(EGG::Heap* heap) { (EmitterFunc*)heap->alloc(mpCalcEmitterFuncListNum * 4, 4); } - int func_no = 0; + func_no = 0; if (is_glbl_tex_anm && is_tex_anm) { - switch (mpBaseShape->getTexAnmType()) { + switch ((int)pBsp->getTexAnmType()) { case 0: mpCalcEmitterFuncList[func_no] = &JPACalcTexIdxNormal; break; @@ -159,7 +137,7 @@ void JPAResource::init(EGG::Heap* heap) { func_no++; } if (is_prm_anm || is_env_anm) { - switch (mpBaseShape->getClrAnmType()) { + switch ((int)pBsp->getClrAnmType()) { case 0: mpCalcEmitterFuncList[func_no] = &JPACalcClrIdxNormal; break; @@ -176,6 +154,7 @@ void JPAResource::init(EGG::Heap* heap) { mpCalcEmitterFuncList[func_no] = &JPACalcClrIdxRandom; break; } + func_no++; } } @@ -202,9 +181,9 @@ void JPAResource::init(EGG::Heap* heap) { } if (is_enable_scale_anm) { - if (mpBaseShape->getType() != 0) { - if (mpExtraShape->isScaleXYDiff()) { - if (mpExtraShape->getScaleAnmTypeX() == 0 && mpExtraShape->getScaleAnmTypeY() == 0) { + if (pBsp->getType() != 0) { + if (pEsp->isScaleXYDiff()) { + if (pEsp->getScaleAnmTypeX() == 0 && pEsp->getScaleAnmTypeY() == 0) { mpCalcParticleFuncListNum++; } else { mpCalcParticleFuncListNum++; @@ -226,7 +205,7 @@ void JPAResource::init(EGG::Heap* heap) { func_no = 0; if (!is_glbl_tex_anm && is_tex_anm) { - switch (mpBaseShape->getTexAnmType()) { + switch ((int)pBsp->getTexAnmType()) { case 0: mpCalcParticleFuncList[func_no] = &JPACalcTexIdxNormal; break; @@ -266,7 +245,7 @@ void JPAResource::init(EGG::Heap* heap) { func_no++; } if (is_prm_anm || is_env_anm) { - switch (mpBaseShape->getClrAnmType()) { + switch ((int)pBsp->getClrAnmType()) { case 0: mpCalcParticleFuncList[func_no] = &JPACalcClrIdxNormal; break; @@ -291,12 +270,12 @@ void JPAResource::init(EGG::Heap* heap) { } if (is_enable_scale_anm) { - if (mpBaseShape->getType() != 0) { - if (mpExtraShape->isScaleXYDiff()) { + if (pBsp->getType() != 0) { + if (pEsp->isScaleXYDiff()) { mpCalcParticleFuncList[func_no] = &JPACalcScaleY; func_no++; - if (mpExtraShape->getScaleAnmTypeY() != 0 || mpExtraShape->getScaleAnmTypeX() != 0) { - switch (mpExtraShape->getScaleAnmTypeY()) { + if (pEsp->getScaleAnmTypeY() != 0 || pEsp->getScaleAnmTypeX() != 0) { + switch (pEsp->getScaleAnmTypeY()) { case 0: mpCalcParticleFuncList[func_no] = &JPACalcScaleAnmNormal; break; @@ -316,7 +295,7 @@ void JPAResource::init(EGG::Heap* heap) { } mpCalcParticleFuncList[func_no] = &JPACalcScaleX; func_no++; - switch (mpExtraShape->getScaleAnmTypeX()) { + switch (pEsp->getScaleAnmTypeX()) { case 0: mpCalcParticleFuncList[func_no] = &JPACalcScaleAnmNormal; break; @@ -327,13 +306,14 @@ void JPAResource::init(EGG::Heap* heap) { mpCalcParticleFuncList[func_no] = &JPACalcScaleAnmReverseX; break; } + func_no++; } - if (mpChildShape != NULL && mpChildShape->isScaleOutOn()) { + if (pCsp != NULL && pCsp->isScaleOutOn()) { mpCalcParticleChildFuncListNum++; } - if (mpChildShape != NULL && mpChildShape->isAlphaOutOn()) { + if (pCsp != NULL && pCsp->isAlphaOutOn()) { mpCalcParticleChildFuncListNum++; } @@ -344,25 +324,26 @@ void JPAResource::init(EGG::Heap* heap) { func_no = 0; - if (mpChildShape != NULL && mpChildShape->isScaleOutOn()) { + if (pCsp != NULL && pCsp->isScaleOutOn()) { mpCalcParticleChildFuncList[func_no] = &JPACalcChildScaleOut; func_no++; } - if (mpChildShape != NULL && mpChildShape->isAlphaOutOn()) { + if (pCsp != NULL && pCsp->isAlphaOutOn()) { mpCalcParticleChildFuncList[func_no] = &JPACalcChildAlphaOut; + func_no++; } if (is_draw_parent && base_type_5_6) { mpDrawEmitterFuncListNum++; - if (mpExTexShape != NULL && mpExTexShape->isUseIndirect() && mpExTexShape->getfield_0x4C()) { + if (pEts != NULL && pEts->isUseIndirect() && pEts->getfield_0x4C()) { mpDrawEmitterFuncListNum++; } } mpDrawEmitterFuncListNum++; - if (mpExTexShape != NULL) { + if (pEts != NULL) { mpDrawEmitterFuncListNum++; } @@ -392,14 +373,14 @@ void JPAResource::init(EGG::Heap* heap) { func_no = 0; if (is_draw_parent && base_type_5_6) { - if (mpBaseShape->getType() == 5) { + if (pBsp->getType() == 5) { mpDrawEmitterFuncList[func_no] = &JPADrawStripe; func_no++; } else { mpDrawEmitterFuncList[func_no] = &JPADrawStripeX; func_no++; } - if (mpExTexShape != NULL && mpExTexShape->isUseIndirect() && mpExTexShape->getfield_0x4C()) { + if (pEts != NULL && pEts->isUseIndirect() && pEts->getfield_0x4C()) { mpDrawEmitterFuncList[func_no] = &fn_8031C2C0; func_no++; } @@ -408,7 +389,7 @@ void JPAResource::init(EGG::Heap* heap) { mpDrawEmitterFuncList[func_no] = &JPADrawEmitterCallBackB; func_no++; - if (mpExTexShape != NULL) { + if (pEts != NULL) { mpDrawEmitterFuncList[func_no] = &JPALoadExTex; func_no++; } @@ -458,17 +439,22 @@ void JPAResource::init(EGG::Heap* heap) { if (is_glbl_clr_anm) { if (base_type_5_6 || !is_enable_alpha_anm) { mpDrawEmitterFuncList[func_no] = &JPARegistPrmEnv; + func_no++; } else if (is_enable_alpha_anm) { mpDrawEmitterFuncList[func_no] = &JPARegistEnv; + func_no++; } } else if (!is_prm_anm && !is_enable_alpha_anm) { if (!is_env_anm) { mpDrawEmitterFuncList[func_no] = &JPARegistPrmEnv; + func_no++; } else { mpDrawEmitterFuncList[func_no] = &JPARegistPrm; + func_no++; } } else if (!is_env_anm) { mpDrawEmitterFuncList[func_no] = &JPARegistEnv; + func_no++; } if (is_draw_child && child_type_5_6) { @@ -481,8 +467,8 @@ void JPAResource::init(EGG::Heap* heap) { mpDrawEmitterChildFuncListNum++; } - if (mpChildShape != NULL && ((!mpChildShape->isAlphaOutOn() && !mpChildShape->isAlphaInherited() - && !mpChildShape->isColorInherited()) || is_draw_child && child_type_5_6)) { + if (pCsp != NULL && ((!pCsp->isAlphaOutOn() && !pCsp->isAlphaInherited() + && !pCsp->isColorInherited()) || is_draw_child && child_type_5_6)) { mpDrawEmitterChildFuncListNum++; } @@ -494,7 +480,7 @@ void JPAResource::init(EGG::Heap* heap) { func_no = 0; if (is_draw_child && child_type_5_6) { - if (mpChildShape->getType() == 5) { + if (pCsp->getType() == 5) { mpDrawEmitterChildFuncList[func_no] = &JPADrawStripe; func_no++; } else { @@ -511,11 +497,14 @@ void JPAResource::init(EGG::Heap* heap) { func_no++; } - if (mpChildShape != NULL) { - if (!mpChildShape->isAlphaOutOn() && !mpChildShape->isAlphaInherited() && !mpChildShape->isColorInherited()) { + if (pCsp != NULL) { + if (!pCsp->isAlphaOutOn() && !pCsp->isAlphaInherited() + && !pCsp->isColorInherited()) { mpDrawEmitterChildFuncList[func_no] = &JPARegistChildPrmEnv; + func_no++; } else if (is_draw_child && child_type_5_6) { mpDrawEmitterChildFuncList[func_no] = &fn_8031DBA0; + func_no++; } } @@ -528,14 +517,14 @@ void JPAResource::init(EGG::Heap* heap) { if (!is_glbl_tex_anm && is_tex_anm) { mpDrawParticleFuncListNum++; } - + if (base_type_0_1 && is_enable_scale_anm) { mpDrawParticleFuncListNum++; } else { if (is_tex_crd_anm && !is_prj_tex) { mpDrawParticleFuncListNum++; } - if (mpExTexShape != NULL && mpExTexShape->isUseIndirect() && mpExTexShape->getfield_0x4C()) { + if (pEts != NULL && pEts->isUseIndirect() && pEts->getfield_0x4C()) { mpDrawParticleFuncListNum++; } } @@ -553,7 +542,7 @@ void JPAResource::init(EGG::Heap* heap) { func_no = 0; if (is_draw_parent && !base_type_5_6) { - switch (mpBaseShape->getType()) { + switch (pBsp->getType()) { case 2: if (is_enable_rotate_anm) { mpDrawParticleFuncList[func_no] = &JPADrawRotBillboard; @@ -615,7 +604,7 @@ void JPAResource::init(EGG::Heap* heap) { func_no++; } - if (mpExTexShape != NULL && mpExTexShape->isUseIndirect() && mpExTexShape->getfield_0x4C()) { + if (pEts != NULL && pEts->isUseIndirect() && pEts->getfield_0x4C()) { mpDrawParticleFuncList[func_no] = &fn_8031A8C0; func_no++; } @@ -625,23 +614,29 @@ void JPAResource::init(EGG::Heap* heap) { if (is_prm_anm) { if (is_env_anm) { mpDrawParticleFuncList[func_no] = &JPARegistPrmAlphaEnv; + func_no++; } else { mpDrawParticleFuncList[func_no] = &JPARegistPrmAlpha; + func_no++; } } else if (is_enable_alpha_anm) { if (is_env_anm) { mpDrawParticleFuncList[func_no] = &JPARegistAlphaEnv; + func_no++; } else { mpDrawParticleFuncList[func_no] = &JPARegistAlpha; + func_no++; } } else if (is_env_anm) { mpDrawParticleFuncList[func_no] = &JPARegistEnv; + func_no++; } } else if (is_enable_alpha_anm && !base_type_5_6) { mpDrawParticleFuncList[func_no] = &JPARegistAlpha; + func_no++; } - if (is_draw_child && mpChildShape != NULL && !child_type_5_6) { + if (is_draw_child && pCsp != NULL && !child_type_5_6) { mpDrawParticleChildFuncListNum++; } @@ -651,8 +646,8 @@ void JPAResource::init(EGG::Heap* heap) { mpDrawParticleChildFuncListNum++; } - if (mpChildShape != NULL && (mpChildShape->isAlphaOutOn() || mpChildShape->isAlphaInherited() - || mpChildShape->isColorInherited())) { + if (pCsp != NULL && (pCsp->isAlphaOutOn() || pCsp->isAlphaInherited() + || pCsp->isColorInherited())) { mpDrawParticleChildFuncListNum++; } @@ -663,8 +658,8 @@ void JPAResource::init(EGG::Heap* heap) { func_no = 0; - if (is_draw_child && mpChildShape != NULL && !child_type_5_6) { - switch (mpChildShape->getType()) { + if (is_draw_child && pCsp != NULL && !child_type_5_6) { + switch (pCsp->getType()) { case 2: if (is_rotate_on) { mpDrawParticleChildFuncList[func_no] = &JPADrawRotBillboard; @@ -717,14 +712,13 @@ void JPAResource::init(EGG::Heap* heap) { } } - if (mpChildShape != NULL && (mpChildShape->isAlphaOutOn() || mpChildShape->isAlphaInherited() - || mpChildShape->isColorInherited())) { + if (pCsp != NULL && (pCsp->isAlphaOutOn() || pCsp->isAlphaInherited() + || pCsp->isColorInherited())) { mpDrawParticleChildFuncList[func_no] = &JPARegistPrmAlphaEnv; + func_no++; } } -/* 802755E8-80275A94 26FF28 04AC+00 0/0 1/1 0/0 .text - * calc__11JPAResourceFP18JPAEmitterWorkDataP14JPABaseEmitter */ bool JPAResource::calc(JPAEmitterWorkData* work, JPABaseEmitter* emtr) { work->mpEmtr = emtr; work->mpRes = this; @@ -753,8 +747,8 @@ bool JPAResource::calc(JPAEmitterWorkData* work, JPABaseEmitter* emtr) { } else { calcKey(work); - for (int i = mFieldBlockNum - 1; i >= 0; i--) { - mpFieldBlocks[i]->initOpParam(); + for (int i = fldNum - 1; i >= 0; i--) { + ppFld[i]->initOpParam(); } if (emtr->mpEmtrCallBack != NULL) { @@ -770,12 +764,12 @@ bool JPAResource::calc(JPAEmitterWorkData* work, JPABaseEmitter* emtr) { (*mpCalcEmitterFuncList[i])(work); } - for (int i = mFieldBlockNum - 1; i >= 0; i--) { - mpFieldBlocks[i]->prepare(work); + for (int i = fldNum - 1; i >= 0; i--) { + ppFld[i]->prepare(work); } if (!emtr->checkStatus(8)) { - mpDynamicsBlock->create(work); + pDyn->create(work); } if (emtr->mpEmtrCallBack != NULL) { @@ -785,23 +779,19 @@ bool JPAResource::calc(JPAEmitterWorkData* work, JPABaseEmitter* emtr) { } } - JPANode* node = emtr->mAlivePtclBase.getFirst(); - JPANode* next; - while (node != emtr->mAlivePtclBase.getEnd()) { + JPANode* next = NULL; + for (JPANode* node = emtr->mAlivePtclBase.getFirst(); node != emtr->mAlivePtclBase.getEnd(); node = next) { next = node->getNext(); if (node->getObject()->calc_p(work)) { emtr->mpPtclPool->push_front(emtr->mAlivePtclBase.erase(node)); } - node = next; } - node = emtr->mAlivePtclChld.getFirst(); - while (node != emtr->mAlivePtclChld.getEnd()) { + for (JPANode* node = emtr->mAlivePtclChld.getFirst(); node != emtr->mAlivePtclChld.getEnd(); node = next) { next = node->getNext(); if (node->getObject()->calc_c(work)) { emtr->mpPtclPool->push_front(emtr->mAlivePtclChld.erase(node)); } - node = next; } emtr->mTick++; @@ -810,51 +800,47 @@ bool JPAResource::calc(JPAEmitterWorkData* work, JPABaseEmitter* emtr) { return false; } -/* 80275A94-80275B74 2703D4 00E0+00 0/0 1/1 0/0 .text - * draw__11JPAResourceFP18JPAEmitterWorkDataP14JPABaseEmitter */ void JPAResource::draw(JPAEmitterWorkData* work, JPABaseEmitter* emtr) { work->mpEmtr = emtr; work->mpRes = this; work->mDrawCount = 0; calcWorkData_d(work); - mpBaseShape->setGX(work); + pBsp->setGX(work); for (s32 i = 1; i <= emtr->getDrawTimes(); i++) { work->mDrawCount++; - if (mpBaseShape->isDrawPrntAhead() && mpChildShape != NULL) + if (pBsp->isDrawPrntAhead() && pCsp != NULL) drawC(work); drawP(work); - if (!mpBaseShape->isDrawPrntAhead() && mpChildShape != NULL) + if (!pBsp->isDrawPrntAhead() && pCsp != NULL) drawC(work); } } -/* 80275B74-80275EB0 2704B4 033C+00 1/1 0/0 0/0 .text drawP__11JPAResourceFP18JPAEmitterWorkData - */ void JPAResource::drawP(JPAEmitterWorkData* work) { work->mpEmtr->clearStatus(0x80); - work->mGlobalPtclScl.x = work->mpEmtr->mGlobalPScl.x * mpBaseShape->getBaseSizeX(); - work->mGlobalPtclScl.y = work->mpEmtr->mGlobalPScl.y * mpBaseShape->getBaseSizeY(); + work->mGlobalPtclScl.x = work->mpEmtr->mGlobalPScl.x * pBsp->getBaseSizeX(); + work->mGlobalPtclScl.y = work->mpEmtr->mGlobalPScl.y * pBsp->getBaseSizeY(); - if (mpBaseShape->getType() == 0) { + if (pBsp->getType() == 0) { work->mGlobalPtclScl.x *= 1.02f; - } else if (mpBaseShape->getType() == 1) { + } else if (pBsp->getType() == 1) { work->mGlobalPtclScl.x *= 1.02f; work->mGlobalPtclScl.y *= 0.4f; } - if (mpExtraShape != NULL && mpExtraShape->isEnableScaleAnm()) { - work->mPivot.x = mpExtraShape->getScaleCenterX() - 1.0f; - work->mPivot.y = mpExtraShape->getScaleCenterY() - 1.0f; + if (pEsp != NULL && pEsp->isEnableScaleAnm()) { + work->mPivot.x = pEsp->getScaleCenterX() - 1.0f; + work->mPivot.y = pEsp->getScaleCenterY() - 1.0f; } else { work->mPivot.x = work->mPivot.y = 0.0f; } - work->mDirType = mpBaseShape->getDirType(); - work->mRotType = mpBaseShape->getRotType(); - work->mDLType = mpBaseShape->getType() == 4 || mpBaseShape->getType() == 8; - work->mPlaneType = work->mDLType ? 2 : mpBaseShape->getBasePlaneType(); - work->mPrjType = mpBaseShape->isPrjTex() ? (mpBaseShape->isTexCrdAnm() ? 2 : 1) : 0; + work->mDirType = pBsp->getDirType(); + work->mRotType = pBsp->getRotType(); + work->mDLType = pBsp->getType() == 4 || pBsp->getType() == 8; + work->mPlaneType = work->mDLType ? 2 : pBsp->getBasePlaneType(); + work->mPrjType = pBsp->isPrjTex() ? (pBsp->isTexCrdAnm() ? 2 : 1) : 0; work->mpAlivePtcl = &work->mpEmtr->mAlivePtclBase; setPTev(); @@ -863,7 +849,7 @@ void JPAResource::drawP(JPAEmitterWorkData* work) { (*mpDrawEmitterFuncList[i])(work); } - if (mpBaseShape->isDrawFwdAhead()) { + if (pBsp->isDrawFwdAhead()) { JPANode* node = work->mpEmtr->mAlivePtclBase.getLast(); for (; node != work->mpEmtr->mAlivePtclBase.getEnd(); node = node->getPrev()) { work->mpCurNode = node; @@ -892,32 +878,30 @@ void JPAResource::drawP(JPAEmitterWorkData* work) { } } -/* 80275EB0-802761A8 2707F0 02F8+00 1/1 0/0 0/0 .text drawC__11JPAResourceFP18JPAEmitterWorkData - */ void JPAResource::drawC(JPAEmitterWorkData* work) { work->mpEmtr->setStatus(0x80); - if (mpChildShape->isScaleInherited()) { - work->mGlobalPtclScl.x = work->mpEmtr->mGlobalPScl.x * mpBaseShape->getBaseSizeX(); - work->mGlobalPtclScl.y = work->mpEmtr->mGlobalPScl.y * mpBaseShape->getBaseSizeY(); + if (pCsp->isScaleInherited()) { + work->mGlobalPtclScl.x = work->mpEmtr->mGlobalPScl.x * pBsp->getBaseSizeX(); + work->mGlobalPtclScl.y = work->mpEmtr->mGlobalPScl.y * pBsp->getBaseSizeY(); } else { - work->mGlobalPtclScl.x = work->mpEmtr->mGlobalPScl.x * mpChildShape->getScaleX(); - work->mGlobalPtclScl.y = work->mpEmtr->mGlobalPScl.y * mpChildShape->getScaleY(); + work->mGlobalPtclScl.x = work->mpEmtr->mGlobalPScl.x * pCsp->getScaleX(); + work->mGlobalPtclScl.y = work->mpEmtr->mGlobalPScl.y * pCsp->getScaleY(); } - if (mpChildShape->getType() == 0) { + if (pCsp->getType() == 0) { work->mGlobalPtclScl.x *= 1.02f; - } else if (mpChildShape->getType() == 1) { + } else if (pCsp->getType() == 1) { work->mGlobalPtclScl.x *= 1.02f; work->mGlobalPtclScl.y *= 0.4f; } work->mPivot.x = work->mPivot.y = 0.0f; - work->mDirType = mpChildShape->getDirType(); - work->mRotType = mpChildShape->getRotType(); - work->mDLType = mpChildShape->getType() == 4 || mpChildShape->getType() == 8; - work->mPlaneType = work->mDLType ? 2 : mpChildShape->getBasePlaneType(); + work->mDirType = pCsp->getDirType(); + work->mRotType = pCsp->getRotType(); + work->mDLType = pCsp->getType() == 4 || pCsp->getType() == 8; + work->mPlaneType = work->mDLType ? 2 : pCsp->getBasePlaneType(); work->mPrjType = 0; work->mpAlivePtcl = &work->mpEmtr->mAlivePtclChld; @@ -927,7 +911,7 @@ void JPAResource::drawC(JPAEmitterWorkData* work) { (*mpDrawEmitterChildFuncList[i])(work); } - if (mpBaseShape->isDrawFwdAhead()) { + if (pBsp->isDrawFwdAhead()) { JPANode* node = work->mpEmtr->mAlivePtclChld.getLast(); for (; node != work->mpEmtr->mAlivePtclChld.getEnd(); node = node->getPrev()) { work->mpCurNode = node; @@ -956,40 +940,33 @@ void JPAResource::drawC(JPAEmitterWorkData* work) { } } -/* 802761A8-8027642C 270AE8 0284+00 1/1 0/0 0/0 .text setPTev__11JPAResourceFv */ void JPAResource::setPTev() { 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 base_plane_type = (pBsp->getType() == 3 || pBsp->getType() == 7) ? + pBsp->getBasePlaneType() : 0; + int center_offset = pEsp != NULL ? (pEsp->getScaleCenterX() + 3 * pEsp->getScaleCenterY()) * 0xC : 0x30; int pos_offset = center_offset + base_plane_type * 0x6C; - int crd_offset = (mpBaseShape->getTilingS() + 2 * mpBaseShape->getTilingT()) * 8; + int crd_offset = (pBsp->getTilingS() + 2 * pBsp->getTilingT()) * 8; GXSetArray(GX_VA_POS, jpa_pos + pos_offset, 3); GXSetArray(GX_VA_TEX0, jpa_crd + crd_offset, 2); GXSetTevOrder(GX_TEVSTAGE0, GX_TEXCOORD0, GX_TEXMAP0, GX_COLOR_NULL); - if (mpExTexShape != NULL) { - if (mpExTexShape->isUseIndirect()) { - GXSetIndTexOrder(GX_INDTEXSTAGE0, GX_TEXCOORD1, GX_TEXMAP2); + if (pEts != NULL) { + if (pEts->isUseIndirect()) { + GXSetIndTexOrder(GX_INDTEXSTAGE0, tex_coord, GX_TEXMAP2); GXSetIndTexCoordScale(GX_INDTEXSTAGE0, GX_ITS_1, GX_ITS_1); - GXSetIndTexMtx(GX_ITM_0, (f32(*)[3])mpExTexShape->getIndTexMtx(), mpExTexShape->getExpScale()); + GXSetIndTexMtx(GX_ITM_0, (f32(*)[3])pEts->getIndTexMtx(), pEts->getExpScale()); GXSetTevIndirect(GX_TEVSTAGE0, GX_INDTEXSTAGE0, GX_ITF_8, GX_ITB_STU, GX_ITM_0, GX_ITW_OFF, GX_ITW_OFF, 0, 0, GX_ITBA_OFF); ind_stages++; tex_gens++; tex_coord = GX_TEXCOORD2; } - if (mpExTexShape->isUseSecTex()) { + if (pEts->isUseSecTex()) { GXSetTevOrder(GX_TEVSTAGE1, tex_coord, GX_TEXMAP3, GX_COLOR_NULL); GXSetTevColorIn(GX_TEVSTAGE1, GX_CC_ZERO, GX_CC_TEXC, GX_CC_CPREV, GX_CC_ZERO); GXSetTevAlphaIn(GX_TEVSTAGE1, GX_CA_ZERO, GX_CA_TEXA, GX_CA_APREV, GX_CA_ZERO); @@ -1004,7 +981,7 @@ void JPAResource::setPTev() { GXSetNumTevStages(tev_stages); GXSetNumIndStages(ind_stages); - if (mpBaseShape->isClipOn()) { + if (pBsp->isClipOn()) { GXSetMisc(GX_MT_XF_FLUSH, 8); GXSetClipMode(GX_CLIP_ENABLE); } else { @@ -1013,11 +990,9 @@ void JPAResource::setPTev() { GXSetNumTexGens(tex_gens); } -/* 8027642C-8027658C 270D6C 0160+00 1/1 0/0 0/0 .text setCTev__11JPAResourceFP18JPAEmitterWorkData - */ void JPAResource::setCTev(JPAEmitterWorkData* work) { - int base_plane_type = (mpChildShape->getType() == 3 || mpChildShape->getType() == 7) ? - mpChildShape->getBasePlaneType() : 0; + int base_plane_type = (pCsp->getType() == 3 || pCsp->getType() == 7) ? + pCsp->getBasePlaneType() : 0; int pos_offset = 0x30 + base_plane_type * 0x6C; GXSetArray(GX_VA_POS, jpa_pos + pos_offset, 3); GXSetArray(GX_VA_TEX0, jpa_crd, 2); @@ -1026,18 +1001,16 @@ void JPAResource::setCTev(JPAEmitterWorkData* work) { GXSetTevDirect(GX_TEVSTAGE0); GXSetNumTevStages(1); GXSetNumIndStages(0); - if (mpChildShape->isClipOn()) { + if (pCsp->isClipOn()) { GXSetMisc(GX_MT_XF_FLUSH, 8); GXSetClipMode(GX_CLIP_ENABLE); } else { GXSetClipMode(GX_CLIP_DISABLE); } GXSetNumTexGens(1); - work->mpResMgr->load(work->mpRes->getTexIdx(mpChildShape->getTexIdx()), GX_TEXMAP1); + work->mpResMgr->load(work->mpRes->getTexIdx(pCsp->getTexIdx()), GX_TEXMAP1); } -/* 8027658C-80276608 270ECC 007C+00 0/0 1/1 0/0 .text - * calc_p__11JPAResourceFP18JPAEmitterWorkDataP15JPABaseParticle */ void JPAResource::calc_p(JPAEmitterWorkData* work, JPABaseParticle* ptcl) { if (mpCalcParticleFuncList != NULL) { for (int i = mpCalcParticleFuncListNum - 1; i >= 0; i--) { @@ -1046,8 +1019,6 @@ void JPAResource::calc_p(JPAEmitterWorkData* work, JPABaseParticle* ptcl) { } } -/* 80276608-80276684 270F48 007C+00 0/0 1/1 0/0 .text - * calc_c__11JPAResourceFP18JPAEmitterWorkDataP15JPABaseParticle */ void JPAResource::calc_c(JPAEmitterWorkData* work, JPABaseParticle* ptcl) { if (mpCalcParticleChildFuncList != NULL) { for (int i = mpCalcParticleChildFuncListNum - 1; i >= 0; i--) { @@ -1056,20 +1027,16 @@ void JPAResource::calc_c(JPAEmitterWorkData* work, JPABaseParticle* ptcl) { } } -/* 80276684-80276700 270FC4 007C+00 0/0 2/2 0/0 .text - * calcField__11JPAResourceFP18JPAEmitterWorkDataP15JPABaseParticle */ void JPAResource::calcField(JPAEmitterWorkData* work, JPABaseParticle* ptcl) { - for (int i = mFieldBlockNum - 1; i >= 0; i--) { - mpFieldBlocks[i]->calc(work, ptcl); + for (int i = fldNum - 1; i >= 0; i--) { + ppFld[i]->calc(work, ptcl); } } -/* 80276700-80276840 271040 0140+00 2/1 0/0 0/0 .text calcKey__11JPAResourceFP18JPAEmitterWorkData - */ void JPAResource::calcKey(JPAEmitterWorkData* work) { - for (int i = mKeyBlockNum - 1; i >= 0; i--) { - f32 val = mpKeyBlocks[i]->calc(work->mpEmtr->mTick); - switch (mpKeyBlocks[i]->getID()) { + for (int i = keyNum - 1; i >= 0; i--) { + f32 val = ppKey[i]->calc(work->mpEmtr->mTick); + switch (ppKey[i]->getID()) { case 0: work->mpEmtr->mRate = val; break; @@ -1097,20 +1064,20 @@ void JPAResource::calcKey(JPAEmitterWorkData* work) { case 10: work->mpEmtr->mScaleOut = val; break; + default: + JUT_WARN(917, "%s", "JPA : WRONG ID in key data\n"); + break; } } } -/* 80276840-80276A0C 271180 01CC+00 1/1 0/0 0/0 .text - * calcWorkData_c__11JPAResourceFP18JPAEmitterWorkData */ void JPAResource::calcWorkData_c(JPAEmitterWorkData* work) { work->mVolumeSize = work->mpEmtr->mVolumeSize; work->mVolumeMinRad = work->mpEmtr->mVolumeMinRad; work->mVolumeSweep = work->mpEmtr->mVolumeSweep; - work->mVolumeX = 0; - work->mVolumeAngleNum = 0; + work->mVolumeAngleNum = work->mVolumeX = 0; work->mVolumeAngleMax = 1; - work->mDivNumber = mpDynamicsBlock->getDivNumber() * 2 + 1; + work->mDivNumber = pDyn->getDivNumber() * 2 + 1; Mtx local_scl_mtx, local_rot_mtx, global_mtx; MTXScale(local_scl_mtx, work->mpEmtr->mLocalScl.x, work->mpEmtr->mLocalScl.y, work->mpEmtr->mLocalScl.z); @@ -1127,14 +1094,11 @@ void JPAResource::calcWorkData_c(JPAEmitterWorkData* work) { 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 - * calcWorkData_d__11JPAResourceFP18JPAEmitterWorkData */ void JPAResource::calcWorkData_d(JPAEmitterWorkData* work) { Mtx mtx; JPAGetXYZRotateMtx(work->mpEmtr->mLocalRot.x * 0xB6, work->mpEmtr->mLocalRot.y * 0xB6, @@ -1142,9 +1106,3 @@ void JPAResource::calcWorkData_d(JPAEmitterWorkData* work) { MTXConcat(work->mpEmtr->mGlobalRot, mtx, work->mGlobalRot); MTXMultVecSR(work->mGlobalRot, work->mpEmtr->mLocalDir, work->mGlobalEmtrDir); } -/* -#pragma push -#pragma force_active on -static u8 jpa_resource_padding[28] = {0}; -#pragma pop -*/ diff --git a/src/JSystem/JParticle/JPAResourceLoader.cpp b/src/JSystem/JParticle/JPAResourceLoader.cpp index c43c70ab..8928a575 100644 --- a/src/JSystem/JParticle/JPAResourceLoader.cpp +++ b/src/JSystem/JParticle/JPAResourceLoader.cpp @@ -1,8 +1,3 @@ -// -// Generated By: dol2asm -// Translation Unit: JPAResourceLoader -// - #include "egg/core/eggHeap.h" #include "JSystem/JParticle/JPAResourceLoader.h" #include "JSystem/JParticle/JPABaseShape.h" @@ -14,12 +9,13 @@ #include "JSystem/JParticle/JPAKeyBlock.h" #include "JSystem/JParticle/JPAResource.h" #include "JSystem/JParticle/JPAResourceManager.h" +#include "JSystem/JUtility/JUTAssert.h" -/* 8027D8A0-8027D8E0 2781E0 0040+00 0/0 1/1 0/0 .text - * __ct__17JPAResourceLoaderFPCUcP18JPAResourceManager */ JPAResourceLoader::JPAResourceLoader(u8 const* data, JPAResourceManager* mgr) { if (*(u32*)(data + 4) == '2-11') { load_jpc(data, mgr); + } else { + JUT_WARN(48, "JPA : wrong version file\n"); } } @@ -31,76 +27,89 @@ struct JPAResourceHeader { /* 0x6 */ u8 mTDB1Num; }; -/* 8027D8E0-8027DCA0 278220 03C0+00 1/1 0/0 0/0 .text - * load_jpc__17JPAResourceLoaderFPCUcP18JPAResourceManager */ -void JPAResourceLoader::load_jpc(u8 const* data, JPAResourceManager* mgr) { - EGG::Heap* heap = mgr->mpHeap; - mgr->mResMax = *(u16*)(data + 8); - mgr->mTexMax = *(u16*)(data + 0xA); - mgr->mpResArr = new (heap, 4) JPAResource*[mgr->mResMax]; - mgr->mpTexArr = new (heap, 4) JPATexture*[mgr->mTexMax]; +void JPAResourceLoader::load_jpc(u8 const* data, JPAResourceManager* p_res_mgr) { + EGG::Heap* heap = p_res_mgr->mpHeap; + p_res_mgr->resMaxNum = *(u16*)(data + 8); + p_res_mgr->texMaxNum = *(u16*)(data + 0xA); + p_res_mgr->pResAry = new (heap) JPAResource*[p_res_mgr->resMaxNum]; + p_res_mgr->pTexAry = new (heap) JPATexture*[p_res_mgr->texMaxNum]; + JUT_ASSERT(199, (p_res_mgr->pResAry != NULL) && (p_res_mgr->pTexAry != 0)); u32 offset = 0x10; for (int i = 0; i < *(u16*)(data + 8); i++) { JPAResourceHeader* header = (JPAResourceHeader*)(data + offset); - JPAResource* res = new (heap, 4) JPAResource(); - res->mFieldBlockNum = header->mFieldBlockNum; - res->mpFieldBlocks = res->mFieldBlockNum != 0 ? - new (heap, 4) JPAFieldBlock*[res->mFieldBlockNum] : NULL; - res->mKeyBlockNum = header->mKeyBlockNum; - res->mpKeyBlocks = res->mKeyBlockNum != 0 ? - new (heap, 4) JPAKeyBlock*[res->mKeyBlockNum] : NULL; - res->mTDB1Num = header->mTDB1Num; - res->mpTDB1 = NULL; - res->mUsrIdx = header->mUsrIdx; + JPAResource* p_res = new (heap) JPAResource(); + JUT_ASSERT(211, p_res != NULL); + p_res->fldNum = header->mFieldBlockNum; + p_res->ppFld = p_res->fldNum != 0 ? + new (heap) JPAFieldBlock*[p_res->fldNum] : NULL; + JUT_ASSERT(216, (p_res->ppFld != NULL) || (p_res->fldNum == 0)); + p_res->keyNum = header->mKeyBlockNum; + p_res->ppKey = p_res->keyNum != 0 ? + new (heap) JPAKeyBlock*[p_res->keyNum] : NULL; + JUT_ASSERT(221, (p_res->ppKey != NULL) || (p_res->keyNum == 0)); + p_res->texNum = header->mTDB1Num; + p_res->mpTDB1 = NULL; + p_res->mUsrIdx = header->mUsrIdx; offset += 8; - u32 field_idx = 0; - u32 key_idx = 0; + u32 fld_no = 0; + u32 key_no = 0; for (int j = 0; j < header->mBlockNum; j++) { u32 magic = *(u32*)(data + offset); u32 size = *(u32*)(data + offset + 4); switch (magic) { case 'FLD1': - res->mpFieldBlocks[field_idx] = new (heap, 4) JPAFieldBlock(data + offset, heap); - field_idx++; + p_res->ppFld[fld_no] = new (heap) JPAFieldBlock(data + offset, heap); + JUT_ASSERT(244, p_res->ppFld[fld_no] != NULL); + fld_no++; break; case 'KFA1': - res->mpKeyBlocks[key_idx] = new (heap, 4) JPAKeyBlock(data + offset); - key_idx++; + p_res->ppKey[key_no] = new (heap) JPAKeyBlock(data + offset); + JUT_ASSERT(249, p_res->ppKey[key_no] != NULL); + key_no++; break; case 'BEM1': - res->mpDynamicsBlock = new (heap, 4) JPADynamicsBlock(data + offset); + p_res->pDyn = new (heap) JPADynamicsBlock(data + offset); + JUT_ASSERT(254, p_res->pDyn != NULL); break; case 'BSP1': - res->mpBaseShape = new (heap, 4) JPABaseShape(data + offset, heap); + p_res->pBsp = new (heap) JPABaseShape(data + offset, heap); + JUT_ASSERT(258, p_res->pBsp != NULL); break; case 'ESP1': - res->mpExtraShape = new (heap, 4) JPAExtraShape(data + offset); + p_res->pEsp = new (heap) JPAExtraShape(data + offset); + JUT_ASSERT(262, p_res->pEsp != NULL); break; case 'SSP1': - res->mpChildShape = new (heap, 4) JPAChildShape(data + offset); + p_res->pCsp = new (heap) JPAChildShape(data + offset); + JUT_ASSERT(266, p_res->pCsp != NULL); break; case 'ETX1': - res->mpExTexShape = new (heap, 4) JPAExTexShape(data + offset); + p_res->pEts = new (heap) JPAExTexShape(data + offset); + JUT_ASSERT(270, p_res->pEts != NULL); break; case 'TDB1': - res->mpTDB1 = (const u16*)(data + offset + 8); + p_res->mpTDB1 = (const u16*)(data + offset + 8); + break; + default: + JUT_WARN(275, "JPA : wrong type block in jpc file %d %x\n", header->mBlockNum, offset); break; } offset += size; } - res->init(heap); - mgr->registRes(res); + p_res->init(heap); + p_res_mgr->registRes(p_res); } offset = *(u32*)(data + 0xC); for (int i = 0; i < *(u16*)(data + 0xA); i++) { u32 size = *(u32*)(data + offset + 4); - JPATexture* tex = new (heap, 4) JPATexture(data + offset); - mgr->registTex(tex); + JPATexture* p_tex = new (heap) JPATexture(data + offset); + JUT_ASSERT(298, p_tex != NULL); + p_res_mgr->registTex(p_tex); offset += size; } } diff --git a/src/JSystem/JParticle/JPAResourceManager.cpp b/src/JSystem/JParticle/JPAResourceManager.cpp index 09a80c74..430ad101 100644 --- a/src/JSystem/JParticle/JPAResourceManager.cpp +++ b/src/JSystem/JParticle/JPAResourceManager.cpp @@ -1,54 +1,47 @@ -// -// Generated By: dol2asm -// Translation Unit: JPAResourceManager -// - #include "JSystem/JParticle/JPAResourceManager.h" #include "JSystem/JParticle/JPADynamicsBlock.h" #include "JSystem/JParticle/JPAResource.h" -#include "string.h" +#include "JSystem/JUtility/JUTAssert.h" +#include "egg/core/eggHeap.h" +#include struct JPAResourceLoader { - /* 8027D8A0 */ JPAResourceLoader(u8 const*, JPAResourceManager*); + JPAResourceLoader(u8 const*, JPAResourceManager*); }; -/* 80273E10-80273E68 26E750 0058+00 0/0 2/2 0/0 .text __ct__18JPAResourceManagerFPCvP7JKRHeap */ -JPAResourceManager::JPAResourceManager(void const* pData, EGG::Heap* pHeap) { - mpResArr = NULL; - mpTexArr = NULL; - mResMax = 0; - mResNum = 0; - mTexMax = 0; - mTexNum = 0; +JPAResourceManager::JPAResourceManager(void const* p_jpc, EGG::Heap* pHeap) { + pResAry = NULL; + pTexAry = NULL; + resMaxNum = 0; + resRegNum = 0; + texMaxNum = 0; + texRegNum = 0; mpHeap = pHeap; - JPAResourceLoader loader((u8 const*)pData, this); + JUT_ASSERT(49, (p_jpc != 0) && (pHeap != 0)); + JPAResourceLoader loader((u8 const*)p_jpc, this); } -/* 80273E68-80273EA8 26E7A8 0040+00 1/1 1/1 0/0 .text getResource__18JPAResourceManagerCFUs */ JPAResource* JPAResourceManager::getResource(u16 usrIdx) const { - for (u16 i = 0; i < mResNum; i++) - if (mpResArr[i]->getUsrIdx() == usrIdx) - return mpResArr[i]; + for (u16 i = 0; i < resRegNum; i++) + if (pResAry[i]->getUsrIdx() == usrIdx) + return pResAry[i]; return NULL; } -/* 80273EA8-80273EEC 26E7E8 0044+00 0/0 2/2 0/0 .text - * checkUserIndexDuplication__18JPAResourceManagerCFUs */ bool JPAResourceManager::checkUserIndexDuplication(u16 usrIdx) const { - for (s32 i = 0; i < mResNum; i++) - if (mpResArr[i]->getUsrIdx() == usrIdx) + for (s32 i = 0; i < resRegNum; i++) + if (pResAry[i]->getUsrIdx() == usrIdx) return true; return false; } -/* 80273EEC-80273F8C 26E82C 00A0+00 0/0 2/2 0/0 .text - * swapTexture__18JPAResourceManagerFPC7ResTIMGPCc */ const EGG::ResTIMG* JPAResourceManager::swapTexture(EGG::ResTIMG const* img, char const* swapName) { const EGG::ResTIMG* ret = NULL; + EGG::Texture* tex = NULL; - for (s32 i = 0; i < mTexNum; i++) { - if (strcmp(swapName, mpTexArr[i]->getName()) == 0) { - EGG::Texture* tex = mpTexArr[i]->getJUTTexture(); + for (s32 i = 0; i < texRegNum; i++) { + if (strcmp(swapName, pTexAry[i]->getName()) == 0) { + tex = pTexAry[i]->getJUTTexture(); ret = tex->getTexInfo(); tex->storeTIMG(img, (u8)0); break; @@ -58,21 +51,18 @@ const EGG::ResTIMG* JPAResourceManager::swapTexture(EGG::ResTIMG const* img, cha return ret; } -/* 80273F8C-80273FAC 26E8CC 0020+00 0/0 1/1 0/0 .text - * registRes__18JPAResourceManagerFP11JPAResource */ void JPAResourceManager::registRes(JPAResource* res) { - mpResArr[mResNum] = res; - mResNum++; + JUT_ASSERT(151, resRegNum < resMaxNum); + pResAry[resRegNum] = res; + resRegNum++; } -/* 80273FAC-80273FCC 26E8EC 0020+00 0/0 1/1 0/0 .text - * registTex__18JPAResourceManagerFP10JPATexture */ void JPAResourceManager::registTex(JPATexture* tex) { - mpTexArr[mTexNum] = tex; - mTexNum++; + JUT_ASSERT(166, texRegNum < texMaxNum); + pTexAry[texRegNum] = tex; + texRegNum++; } -/* 80273FCC-80274010 26E90C 0044+00 0/0 6/6 0/0 .text getResUserWork__18JPAResourceManagerCFUs */ u32 JPAResourceManager::getResUserWork(u16 usrIdx) const { u32 ret = 0; diff --git a/src/JSystem/JParticle/JPATexture.cpp b/src/JSystem/JParticle/JPATexture.cpp index d137b762..18826218 100644 --- a/src/JSystem/JParticle/JPATexture.cpp +++ b/src/JSystem/JParticle/JPATexture.cpp @@ -1,15 +1,8 @@ -// -// Generated By: dol2asm -// Translation Unit: JPATexture -// - #include "JSystem/JParticle/JPATexture.h" -/* 8027D7D4-8027D83C 278114 0068+00 0/0 1/1 0/0 .text __ct__10JPATextureFPCUc */ JPATexture::JPATexture(u8 const* pData) { mpData = (const JPATextureData*)pData; mTexture.store(&mpData->mResTIMG); } -/* 8027D83C-8027D8A0 27817C 0064+00 1/0 0/0 0/0 .text __dt__10JPATextureFv */ JPATexture::~JPATexture() {} diff --git a/src/REL/d/a/d_a_bombf.cpp b/src/REL/d/a/d_a_bombf.cpp index 5a416522..d94a76d0 100644 --- a/src/REL/d/a/d_a_bombf.cpp +++ b/src/REL/d/a/d_a_bombf.cpp @@ -54,7 +54,7 @@ int dAcBombf_c::actorPostCreate() { mMtx_c mtx; mtx.ZXYrotS(mRotation.x, mRotation.y, mRotation.z); mVec3_c v; - PSMTXMultVecSR(mtx, mVec3_c::Ey, v); + MTXMultVecSR(mtx, mVec3_c::Ey, v); mVec3_c v3 = mPosition + v * 10.0f; mVec3_c v4 = mPosition - v * 10.0f; @@ -184,7 +184,7 @@ void dAcBombf_c::executeState_Wait() { f32 scaleFactor = mScale.x; if (field_0x3D2 == 0 || field_0x3D2 == 2) { mVec3_c up; - PSMTXMultVecSR(mWorldMtx, mVec3_c::Ey, up); + MTXMultVecSR(mWorldMtx, mVec3_c::Ey, up); mVec3_c upScaled = up * 30.0f; mVec3_c checkPos = mPosition + upScaled; diff --git a/src/REL/d/a/d_a_t_wood_area.cpp b/src/REL/d/a/d_a_t_wood_area.cpp index 23106844..9a92f9db 100644 --- a/src/REL/d/a/d_a_t_wood_area.cpp +++ b/src/REL/d/a/d_a_t_wood_area.cpp @@ -14,7 +14,7 @@ STATE_DEFINE(dAcTWoodArea_c, Wait); int dAcTWoodArea_c::actorCreate() { mStateMgr.changeState(StateID_Init); - PSMTXTrans(mWorldMtx.m, mPosition.x, mPosition.y, mPosition.z); + MTXTrans(mWorldMtx.m, mPosition.x, mPosition.y, mPosition.z); mBoundingBox.mMin = mVec3_c(-0.0f, -0.0f, -0.0f); mBoundingBox.mMax = mVec3_c(0.0f, 0.0f, 0.0f); return SUCCEEDED; diff --git a/src/REL/d/a/e/d_a_e_hb_leaf.cpp b/src/REL/d/a/e/d_a_e_hb_leaf.cpp index c1d0e291..92047ba0 100644 --- a/src/REL/d/a/e/d_a_e_hb_leaf.cpp +++ b/src/REL/d/a/e/d_a_e_hb_leaf.cpp @@ -75,8 +75,8 @@ int dAcEhb_leaf_c::actorExecute() { updateMatrix(); if (mType != 0) { Mtx m; - PSMTXScale(m, mTimeAreaStruct.field_0x00, mTimeAreaStruct.field_0x00, mTimeAreaStruct.field_0x00); - PSMTXConcat(mWorldMtx.m, m, mWorldMtx.m); + MTXScale(m, mTimeAreaStruct.field_0x00, mTimeAreaStruct.field_0x00, mTimeAreaStruct.field_0x00); + MTXConcat(mWorldMtx.m, m, mWorldMtx.m); } mModel.getModel().setLocalMtx(mWorldMtx); mModel.getModel().calc(false); diff --git a/src/REL/d/a/e/d_a_e_remly.cpp b/src/REL/d/a/e/d_a_e_remly.cpp index df9c8ddc..fdf8a5a3 100644 --- a/src/REL/d/a/e/d_a_e_remly.cpp +++ b/src/REL/d/a/e/d_a_e_remly.cpp @@ -1148,7 +1148,7 @@ void dAcEremly_c::executeState_Fly() { mSomeCounter++; mVec3_c v(0.f, 0.f, 0.f); - v.offsetWithAngle(a, -10.f + _weird_zero); + getXZCirclePoint(v, a, -10.f + _weird_zero); field_0xAF8.set(v); } diff --git a/src/REL/d/a/obj/d_a_obj_F400_gate_seal.cpp b/src/REL/d/a/obj/d_a_obj_F400_gate_seal.cpp index c3ce8ad7..e3834de2 100644 --- a/src/REL/d/a/obj/d_a_obj_F400_gate_seal.cpp +++ b/src/REL/d/a/obj/d_a_obj_F400_gate_seal.cpp @@ -55,7 +55,7 @@ int dAcOF400GateSeal_c::actorPostCreate() { dAcOdoor_c *door; while (notDone && parent != nullptr) { - if (10000.0f < PSVECSquareDistance(mPosition, parent->mPosition)) { + if (10000.0f < VECSquareDistance(mPosition, parent->mPosition)) { parent = (dAcOdoor_c *)fManager_c::searchBaseByProfName(fProfile::OBJ_DOOR, parent); door = parent; } else { diff --git a/src/REL/d/a/obj/d_a_obj_bird_sp.cpp b/src/REL/d/a/obj/d_a_obj_bird_sp.cpp index 94b769bd..11d8e883 100644 --- a/src/REL/d/a/obj/d_a_obj_bird_sp.cpp +++ b/src/REL/d/a/obj/d_a_obj_bird_sp.cpp @@ -42,7 +42,7 @@ int dAcObjBirdSp_c::actorExecute() { mVec3_c posChange(0, -0.2, 1.0); mMtx_c matrix; matrix.ZXYrotS(mRotation); - PSMTXMultVec(matrix.m, posChange, posChange); + MTXMultVec(matrix.m, posChange, posChange); f32 angle = (mPosition - dBird_c::getInstance()->mPosition).dot(posChange); if (angle < 0.0f) { diff --git a/src/REL/d/a/obj/d_a_obj_decoB.cpp b/src/REL/d/a/obj/d_a_obj_decoB.cpp index 36d3e075..ba3fc3fb 100644 --- a/src/REL/d/a/obj/d_a_obj_decoB.cpp +++ b/src/REL/d/a/obj/d_a_obj_decoB.cpp @@ -35,7 +35,7 @@ int dAcODecoB_c::doDelete() { int dAcODecoB_c::actorExecute() { mStateMgr.executeState(); - PSMTXTrans(mWorldMtx, mPosition.x, mPosition.y, mPosition.z); + MTXTrans(mWorldMtx, mPosition.x, mPosition.y, mPosition.z); mWorldMtx.ZXYrotM(mRotation); mMdl.setLocalMtx(mWorldMtx); return SUCCEEDED; diff --git a/src/REL/d/a/obj/d_a_obj_flying_clawshot_target.cpp b/src/REL/d/a/obj/d_a_obj_flying_clawshot_target.cpp index 3bde0aa3..d48e43f5 100644 --- a/src/REL/d/a/obj/d_a_obj_flying_clawshot_target.cpp +++ b/src/REL/d/a/obj/d_a_obj_flying_clawshot_target.cpp @@ -85,7 +85,7 @@ int dAcOFlyingClawshotTarget_c::actorExecute() { dAcPy_c *player = dAcPy_c::LINK; mVec3_c markPoint; - PSMTXMultVec(mWorldMtx, mMarkPoint, markPoint); + MTXMultVec(mWorldMtx, mMarkPoint, markPoint); f32 dist_to = markPoint.squareDistance(player->mPosition); diff --git a/src/REL/d/a/obj/d_a_obj_ivy_rope.cpp b/src/REL/d/a/obj/d_a_obj_ivy_rope.cpp index ebf95f33..b1976feb 100644 --- a/src/REL/d/a/obj/d_a_obj_ivy_rope.cpp +++ b/src/REL/d/a/obj/d_a_obj_ivy_rope.cpp @@ -852,7 +852,7 @@ void dAcOivyRope_c::fn_256_D3D0(mVec3_c &pOut1, mVec3_c &pOut2, s16 param2, bool getXZCirclePoint(somevec, swingAngle, something); mVec3_c somevec2(0.f, -25.f, float0); - PSMTXMultVec(m, somevec, somevec2); + MTXMultVec(m, somevec, somevec2); somevec2 += somevec; if (somevec2.z < float0) { somevec2.z = float0; @@ -860,7 +860,7 @@ void dAcOivyRope_c::fn_256_D3D0(mVec3_c &pOut1, mVec3_c &pOut2, s16 param2, bool // name 100% guess mVec3_c swingTarget; - PSMTXMultVec(m, somevec, swingTarget); + MTXMultVec(m, somevec, swingTarget); cLib::addCalcPos(&pOut2, swingTarget, 0.3f, 50.f, 1.f); diff --git a/src/REL/d/a/obj/d_a_obj_pool_cock.cpp b/src/REL/d/a/obj/d_a_obj_pool_cock.cpp index c455a9bf..0c0a2d73 100644 --- a/src/REL/d/a/obj/d_a_obj_pool_cock.cpp +++ b/src/REL/d/a/obj/d_a_obj_pool_cock.cpp @@ -60,12 +60,12 @@ int dAcOPoolCock_c::actorExecute() { mMtx_c tmp2; mVec3_c translation = mOpenDirection * mOpenProgress; - PSMTXTrans(tmp1, translation.x, translation.y, translation.z); - PSMTXConcat(mdl1Transform, tmp1, mdl1Transform); + MTXTrans(tmp1, translation.x, translation.y, translation.z); + MTXConcat(mdl1Transform, tmp1, mdl1Transform); mVec3_c translation2 = -translation; - PSMTXTrans(tmp2, translation2.x, translation2.y, translation2.z); - PSMTXConcat(mdl2Transform, tmp2, mdl2Transform); + MTXTrans(tmp2, translation2.x, translation2.y, translation2.z); + MTXConcat(mdl2Transform, tmp2, mdl2Transform); mdl2Transform.YrotM(-0x8000); mModels[0].setLocalMtx(mdl1Transform); diff --git a/src/REL/d/a/obj/d_a_obj_soil.cpp b/src/REL/d/a/obj/d_a_obj_soil.cpp index 15b1dc78..5a06cbf0 100644 --- a/src/REL/d/a/obj/d_a_obj_soil.cpp +++ b/src/REL/d/a/obj/d_a_obj_soil.cpp @@ -11,6 +11,7 @@ #include "d/d_camera.h" #include "d/d_sc_game.h" #include "d/d_stage_mgr.h" +#include "d/d_vec.h" #include "d/flag/sceneflag_manager.h" #include "d/snd/d_snd_small_effect_mgr.h" #include "d/t/d_t_insect.h" @@ -476,7 +477,8 @@ void dAcOsoil_c::giveItemFinal() { void dAcOsoil_c::calcItemAndInsectSpawnPos() { mItemAndInsectSpawnPos = mPosition; - mItemAndInsectSpawnPos.offsetWithAngle(dAcPy_c::LINK->getRotation().y, 30.f); + // TODO not sure about this s16 cast + getXZCirclePoint(mItemAndInsectSpawnPos, (s16)dAcPy_c::LINK->getRotation().y, 30.f); } void dAcOsoil_c::fn_255_1A50() { diff --git a/src/REL/d/a/obj/d_a_obj_spike.cpp b/src/REL/d/a/obj/d_a_obj_spike.cpp index 9cec9808..2e5be594 100644 --- a/src/REL/d/a/obj/d_a_obj_spike.cpp +++ b/src/REL/d/a/obj/d_a_obj_spike.cpp @@ -35,15 +35,15 @@ int dAcOspike_c::create() { updateMatrix(); mMdl.setLocalMtx(mWorldMtx); mVec3_c tmp; - PSMTXMultVecSR(mWorldMtx.m, mVec3_c::Ex, tmp); + MTXMultVecSR(mWorldMtx.m, mVec3_c::Ex, tmp); mCollision.SetAtVec(tmp); mMtx_c mtx; mtx.XrotS(mRotation.x); mtx.ZrotM(mRotation.z); mVec3_c tmp2, tmp3; - PSMTXMultVecSR(mtx.m, sVec1, tmp2); - PSMTXMultVecSR(mtx.m, sVec2, tmp3); + MTXMultVecSR(mtx.m, sVec1, tmp2); + MTXMultVecSR(mtx.m, sVec2, tmp3); if (tmp2.x > tmp3.x) { f32 copy = tmp2.x; diff --git a/src/REL/d/a/obj/d_a_obj_tower_hand_D101.cpp b/src/REL/d/a/obj/d_a_obj_tower_hand_D101.cpp index 55d20a1d..b36f9045 100644 --- a/src/REL/d/a/obj/d_a_obj_tower_hand_D101.cpp +++ b/src/REL/d/a/obj/d_a_obj_tower_hand_D101.cpp @@ -176,7 +176,7 @@ int dAcOTowerHandD101_c::actorPostCreate() { dAcObjBase_c *ac = dAcObjBase_c::getNextObject(&dAcItem_c::sItemList, nullptr); f32 distLimit = 90000.0f; while (handClosed && ac != nullptr) { - if (PSVECSquareDistance(pos, ac->mPosition) < distLimit) { + if (VECSquareDistance(pos, ac->mPosition) < distLimit) { handClosed = false; mHeldItem.link(static_cast(ac)); } else { @@ -210,7 +210,7 @@ int dAcOTowerHandD101_c::actorExecute() { UNKWORD w = link->IfCurrentActionToActor(this, 0x3D); bool b = getItem(item); if (!b && item->isStateWait()) { - f32 dist = PSVECSquareDistance(item->mPosition, link->mPosition); + f32 dist = VECSquareDistance(item->mPosition, link->mPosition); if (w == 0 && dist < 15625.0f) { item->getItemFromBWheelItem(); } else { @@ -240,13 +240,13 @@ int dAcOTowerHandD101_c::actorExecute() { mMtx_c tmpMtx4; getLoc1Mtx(tmpMtx2); - PSMTXScale(tmpMtx1, newScale.x, newScale.y, newScale.z); - PSMTXConcat(tmpMtx2, tmpMtx1, tmpMtx2); + MTXScale(tmpMtx1, newScale.x, newScale.y, newScale.z); + MTXConcat(tmpMtx2, tmpMtx1, tmpMtx2); mLoc1Mtx.copyFrom(tmpMtx2); getLoc2Mtx(tmpMtx3); - PSMTXScale(tmpMtx4, newScale.x, newScale.y, newScale.z); - PSMTXConcat(tmpMtx3, tmpMtx4, tmpMtx3); + MTXScale(tmpMtx4, newScale.x, newScale.y, newScale.z); + MTXConcat(tmpMtx3, tmpMtx4, tmpMtx3); mLoc2Mtx.copyFrom(tmpMtx3); if (mEffects.hasEmitters()) { @@ -292,13 +292,13 @@ int dAcOTowerHandD101_c::actorExecuteInEvent() { mMtx_c tmpMtx4; getLoc1Mtx(tmpMtx2); - PSMTXScale(tmpMtx1, newScale.x, newScale.y, newScale.z); - PSMTXConcat(tmpMtx2, tmpMtx1, tmpMtx2); + MTXScale(tmpMtx1, newScale.x, newScale.y, newScale.z); + MTXConcat(tmpMtx2, tmpMtx1, tmpMtx2); mLoc1Mtx.copyFrom(tmpMtx2); getLoc2Mtx(tmpMtx3); - PSMTXScale(tmpMtx4, newScale.x, newScale.y, newScale.z); - PSMTXConcat(tmpMtx3, tmpMtx4, tmpMtx3); + MTXScale(tmpMtx4, newScale.x, newScale.y, newScale.z); + MTXConcat(tmpMtx3, tmpMtx4, tmpMtx3); mLoc2Mtx.copyFrom(tmpMtx3); if (mEffects.hasEmitters()) { @@ -572,7 +572,7 @@ void dAcOTowerHandD101_c::executeState_RemainOpen() { dAcPy_c *link = dAcPy_c::LINK; mVec3_c pos; getItemPos(pos); - f32 linkDistToItem = PSVECSquareDistance(pos, link->mPosition); + f32 linkDistToItem = VECSquareDistance(pos, link->mPosition); if (EventManager::isInEvent() && getEventStuff().getCurrentEventCommand() == 'wait') { return; } @@ -604,7 +604,7 @@ void dAcOTowerHandD101_c::executeState_Close() { dAcPy_c *link = dAcPy_c::LINK; mVec3_c pos; getItemPos(pos); - f32 linkDistToItem = PSVECSquareDistance(pos, link->mPosition); + f32 linkDistToItem = VECSquareDistance(pos, link->mPosition); if (EventManager::isInEvent() && getEventStuff().getCurrentEventCommand() == 'wait') { mStateMgr.changeState(StateID_Open); return; @@ -656,7 +656,7 @@ void dAcOTowerHandD101_c::executeState_Open() { dAcPy_c *link = dAcPy_c::LINK; mVec3_c pos; getItemPos(pos); - f32 linkDistToItem = PSVECSquareDistance(pos, link->mPosition); + f32 linkDistToItem = VECSquareDistance(pos, link->mPosition); if (EventManager::isInEvent() && getEventStuff().getCurrentEventCommand() == 'wait') { if (mMdl.getAnm().isStop()) { mStateMgr.changeState(StateID_RemainOpen); @@ -714,7 +714,7 @@ void dAcOTowerHandD101_c::executeState_RemainClosed() { dAcPy_c *link = dAcPy_c::LINK; mVec3_c pos; getItemPos(pos); - f32 linkDistToItem = PSVECSquareDistance(pos, link->mPosition); + f32 linkDistToItem = VECSquareDistance(pos, link->mPosition); if (EventManager::isInEvent() && getEventStuff().getCurrentEventCommand() == 'wait') { mStateMgr.changeState(StateID_Open); return; diff --git a/src/REL/d/a/obj/d_a_obj_triforce.cpp b/src/REL/d/a/obj/d_a_obj_triforce.cpp index 4c17ba02..d8b1045f 100644 --- a/src/REL/d/a/obj/d_a_obj_triforce.cpp +++ b/src/REL/d/a/obj/d_a_obj_triforce.cpp @@ -67,8 +67,8 @@ int dAcOtriforce_c::actorExecute() { dCcS::GetInstance()->Set(&mCollision); updateMatrix(); Mtx m; - PSMTXScale(m, mScale.x, mScale.y, mScale.z); - PSMTXConcat(mWorldMtx.m, m, mWorldMtx.m); + MTXScale(m, mScale.x, mScale.y, mScale.z); + MTXConcat(mWorldMtx.m, m, mWorldMtx.m); mMdl.setLocalMtx(mWorldMtx); mAnm.play(); mEffects.holdEffect(PARTICLE_RESOURCE_ID_MAPPING_967_, mWorldMtx, nullptr, nullptr); diff --git a/src/REL/d/a/obj/d_a_obj_tubo.cpp b/src/REL/d/a/obj/d_a_obj_tubo.cpp index 68e71f1e..c5efcdf1 100644 --- a/src/REL/d/a/obj/d_a_obj_tubo.cpp +++ b/src/REL/d/a/obj/d_a_obj_tubo.cpp @@ -681,7 +681,7 @@ mVec3_c dAcOtubo_c::getCenter() const { mMtx_c m; m.ZXYrotS(mRotation.x, mRotation.y, mRotation.z); mVec3_c dir; - PSMTXMultVecSR(m, mVec3_c::Ey, dir); + MTXMultVecSR(m, mVec3_c::Ey, dir); return mPosition + dir * 28.f; } diff --git a/src/REL/d/a/obj/d_a_obj_tumble_weed.cpp b/src/REL/d/a/obj/d_a_obj_tumble_weed.cpp index 8e319c59..bbe61c61 100644 --- a/src/REL/d/a/obj/d_a_obj_tumble_weed.cpp +++ b/src/REL/d/a/obj/d_a_obj_tumble_weed.cpp @@ -385,7 +385,7 @@ mVec3_c dAcOTumbleWeed_c::getTumblePosition() const { mMtx_c mtx; mVec3_c vec; mtx.ZXYrotS(mRotation.x, mRotation.y, mRotation.z); - PSMTXMultVecSR(mtx, mVec3_c::Ey, vec); + MTXMultVecSR(mtx, mVec3_c::Ey, vec); return mPosition + vec * 40.f; } diff --git a/src/REL/d/t/d_t_col_bomb_shield.cpp b/src/REL/d/t/d_t_col_bomb_shield.cpp index ed9fa5bf..d4598712 100644 --- a/src/REL/d/t/d_t_col_bomb_shield.cpp +++ b/src/REL/d/t/d_t_col_bomb_shield.cpp @@ -25,7 +25,7 @@ int dTgColBombShield::create() { mColMtx.transS(mPosition.x, mPosition.y + mScale.y * 0.5f - 0.05f, mPosition.z); mColMtx.ZXYrotM(mRotation.x, mRotation.y, mRotation.z); mMtx_c tmp; - PSMTXScale(tmp, mScale.x, mScale.y, mScale.z); + MTXScale(tmp, mScale.x, mScale.y, mScale.z); mColMtx += tmp; mStateMgr.changeState(StateID_Wait); return SUCCEEDED; diff --git a/src/REL/d/t/d_t_insect.cpp b/src/REL/d/t/d_t_insect.cpp index 125387f8..8f5b5e4e 100644 --- a/src/REL/d/t/d_t_insect.cpp +++ b/src/REL/d/t/d_t_insect.cpp @@ -187,10 +187,10 @@ void dTgInsect_c::executeState_Wait() { mInsectRespawnTimers[i]--; } else if (mInsectRespawnTimers[i] == 0) { nw4r::math::MTX34 mtx; - PSMTXTrans(mtx, mPosition.x, mPosition.y, mPosition.z); + MTXTrans(mtx, mPosition.x, mPosition.y, mPosition.z); nw4r::math::MTX34 scale; - PSMTXScale(scale, mScale.x, mScale.y, mScale.x); - PSMTXConcat(mtx, scale, mtx); + MTXScale(scale, mScale.x, mScale.y, mScale.x); + MTXConcat(mtx, scale, mtx); nw4r::math::AABB aabb(-100, 0, -100, 100, 100, 100); aabb.Set(&aabb, &mtx); if (fn_801BB750(&aabb, 10000)) { diff --git a/src/REL/d/t/d_t_noeffect_area.cpp b/src/REL/d/t/d_t_noeffect_area.cpp index 35230f7e..dce92248 100644 --- a/src/REL/d/t/d_t_noeffect_area.cpp +++ b/src/REL/d/t/d_t_noeffect_area.cpp @@ -9,9 +9,9 @@ const f32 dTgNoEffectArea_c::sFloat2 = 100.0f; int dTgNoEffectArea_c::create() { mScale *= 0.01f; - PSMTXTrans(mMtx, mPosition.x, mPosition.y, mPosition.z); + MTXTrans(mMtx, mPosition.x, mPosition.y, mPosition.z); mMtx.YrotM(mRotation.y); - PSMTXInverse(mMtx, mMtx); + MTXInverse(mMtx, mMtx); addToList(sList); return SUCCEEDED; } diff --git a/src/REL/d/t/d_t_sound_area.cpp b/src/REL/d/t/d_t_sound_area.cpp index d1bd6161..59bf2db0 100644 --- a/src/REL/d/t/d_t_sound_area.cpp +++ b/src/REL/d/t/d_t_sound_area.cpp @@ -23,9 +23,9 @@ int dTgSndAr_c::create() { switch (getTypeFromParams()) { case 0: - PSMTXTrans(mtx.m, mPosition.x, mPosition.y, mPosition.z); + MTXTrans(mtx.m, mPosition.x, mPosition.y, mPosition.z); mtx.YrotM(mRotation.y); - PSMTXInverse(mtx.m, mtx.m); + MTXInverse(mtx.m, mtx.m); break; case 3: mRail.initWithPathIndex(mParams >> 8 & 0xFF, mRoomID, 0); break; } @@ -83,7 +83,7 @@ inline bool inRange(f32 val, f32 tolerance) { // Box bool dTgSndAr_c::checkAlg0(const mVec3_c &pos) { mVec3_c c2 = pos; - PSMTXMultVec(mtx.m, c2, c2); + MTXMultVec(mtx.m, c2, c2); f32 sxLower = -50.0f * mScale.x; f32 sxUpper = 50.0f * mScale.x; f32 syLower = 0.0f; @@ -102,7 +102,7 @@ bool dTgSndAr_c::checkAlg0(const mVec3_c &pos) { bool dTgSndAr_c::checkAlg1(const mVec3_c &pos) { f32 tgtDist = mScale.x * 100.0f; f32 tgtDist2 = tgtDist * tgtDist; - return PSVECSquareDistance(mPosition, pos) < tgtDist2; + return VECSquareDistance(mPosition, pos) < tgtDist2; } // Cylinder @@ -152,11 +152,11 @@ bool dTgSndAr_c::checkAlg3(const mVec3_c &pos) { return d < radius; } else { // Otherwise check if we are within the spheres around the endpoints - f32 distSq = PSVECSquareDistance(unk.GetStart(), pos); + f32 distSq = VECSquareDistance(unk.GetStart(), pos); if (distSq < radius) { return true; } else { - distSq = PSVECSquareDistance(unk.GetEnd(), pos); + distSq = VECSquareDistance(unk.GetEnd(), pos); return distSq < radius; } } diff --git a/src/d/a/d_a_base.cpp b/src/d/a/d_a_base.cpp index f5588812..8619d9b2 100644 --- a/src/d/a/d_a_base.cpp +++ b/src/d/a/d_a_base.cpp @@ -391,7 +391,7 @@ bool dAcBase_c::getDistanceToActor(dAcBase_c *actor, f32 distThresh, f32 *outDis bool isWithinThreshhold = false; if (actor != nullptr) { - distSquared = PSVECSquareDistance(mPosition, actor->mPosition); + distSquared = VECSquareDistance(mPosition, actor->mPosition); if (distSquared <= distThresh * distThresh) { isWithinThreshhold = true; @@ -414,7 +414,7 @@ bool dAcBase_c::getDistanceAndAngleToActor( mAng angleToActorY(0), angleToActorX(0); if (actor != nullptr) { - distSquared = PSVECSquareDistance(mPosition, actor->mPosition); + distSquared = VECSquareDistance(mPosition, actor->mPosition); angleToActorY.set(cLib::targetAngleY(mPosition, actor->mPosition)); angleToActorX.set(cLib::targetAngleX(mPosition, actor->mPosition)); @@ -453,11 +453,11 @@ bool dAcBase_c::getDistanceAndAngleToPlayer( } f32 dAcBase_c::getDistToPlayer() { - return EGG::Math::sqrt(PSVECSquareDistance(mPosition, dAcPy_c::LINK->mPosition)); + return EGG::Math::sqrt(VECSquareDistance(mPosition, dAcPy_c::LINK->mPosition)); } f32 dAcBase_c::getSquareDistToPlayer() { - return PSVECSquareDistance(mPosition, dAcPy_c::LINK->mPosition); + return VECSquareDistance(mPosition, dAcPy_c::LINK->mPosition); } // Some weirdness with the float registers being used diff --git a/src/d/a/obj/d_a_obj_switch.cpp b/src/d/a/obj/d_a_obj_switch.cpp index 9f75909b..6ffba7c8 100644 --- a/src/d/a/obj/d_a_obj_switch.cpp +++ b/src/d/a/obj/d_a_obj_switch.cpp @@ -26,8 +26,8 @@ void dAcOswMdlCallback_c::timingB(u32 nodeId, nw4r::g3d::WorldMtxManip *manip, n mMtx_c mtx1; mMtx_c mtx2; manip->GetMtx(mtx1); - PSMTXTrans(mtx2, mElevation, 0.0f, 0.0f); - PSMTXConcat(mtx1, mtx2, mtx1); + MTXTrans(mtx2, mElevation, 0.0f, 0.0f); + MTXConcat(mtx1, mtx2, mtx1); manip->SetMtx(mtx1); } } @@ -189,8 +189,8 @@ int dAcOsw_c::actorExecute() { updateMatrix(); field_0x5B8.copyFrom(mWorldMtx); mMtx_c tmp; - PSMTXTrans(tmp, 0.0f, mButtonCtrl.mElevation, 0.0f); - PSMTXConcat(field_0x5B8, tmp, field_0x5B8); + MTXTrans(tmp, 0.0f, mButtonCtrl.mElevation, 0.0f); + MTXConcat(field_0x5B8, tmp, field_0x5B8); mModel.setScale(mScale); mModel.setLocalMtx(mWorldMtx); mModel.calc(false); diff --git a/src/d/a/obj/d_a_obj_tbox.cpp b/src/d/a/obj/d_a_obj_tbox.cpp index 07264a7d..931dc459 100644 --- a/src/d/a/obj/d_a_obj_tbox.cpp +++ b/src/d/a/obj/d_a_obj_tbox.cpp @@ -2418,7 +2418,7 @@ void dAcTbox_c::fn_8026DAC0(mAng &ang) { } void dAcTbox_c::fn_8026DAD0(const mVec3_c *a, mVec3_c *b) const { - PSMTXMultVec(mWorldMtx, *a, *b); + MTXMultVec(mWorldMtx, *a, *b); } void dAcTbox_c::getCylParams(mVec3_c *c, f32 *r, f32 *h) const { @@ -2529,7 +2529,7 @@ void dAcTbox_c::getCylParams(mVec3_c *c, f32 *r, f32 *h) const { break; } if (c != nullptr) { - PSMTXMultVec(mWorldMtx, *c, *c); + MTXMultVec(mWorldMtx, *c, *c); } } @@ -2631,7 +2631,7 @@ bool dAcTbox_c::checkForLinkBonk() { } mVec3_c linkPos; - PSMTXMultVec(mCcD3.mInvMtx, link->mPosition, linkPos); + MTXMultVec(mCcD3.mInvMtx, link->mPosition, linkPos); mVec3_c ccLo, ccHi; getCCBounds(&ccLo, &ccHi); // Math performed in local coordinate space diff --git a/src/d/col/bg/d_bg_s.cpp b/src/d/col/bg/d_bg_s.cpp index 17dd3b29..5252f964 100644 --- a/src/d/col/bg/d_bg_s.cpp +++ b/src/d/col/bg/d_bg_s.cpp @@ -886,10 +886,10 @@ void dBgS_MoveBGProc_Typical( mMtx_c a; if (i_bgw->GetOldInvMtx(&a) != NULL) { mVec3_c moveOld; - PSMTXMultVec(a, *i_pos, moveOld); + MTXMultVec(a, *i_pos, moveOld); mVec3_c movePos; - PSMTXMultVec(i_bgw->mInvMtx, moveOld, movePos); + MTXMultVec(i_bgw->mInvMtx, moveOld, movePos); *i_pos = movePos; } } diff --git a/src/d/col/bg/d_bg_w.cpp b/src/d/col/bg/d_bg_w.cpp index fc8256ac..bfe905ea 100644 --- a/src/d/col/bg/d_bg_w.cpp +++ b/src/d/col/bg/d_bg_w.cpp @@ -31,9 +31,9 @@ cBgW::cBgW() mpGrp(nullptr), mpNodeTree(nullptr), mNeedsFullTransform(true) { - PSMTXIdentity(mInvMtx); - PSMTXIdentity(mMtx); - PSMTXIdentity(mMtxUnk); + MTXIdentity(mInvMtx); + MTXIdentity(mMtx); + MTXIdentity(mMtxUnk); } cBgW::~cBgW() { @@ -65,24 +65,24 @@ void cBgW::FreeArea() { } u32 cBgW::GetOldInvMtx(mMtx_c *m) { - return PSMTXInverse(mMtx, *m); + return MTXInverse(mMtx, *m); } void cBgW::UpdateMtx() { if (!mpMdlMtx) { - PSMTXIdentity(mInvMtx); - PSMTXIdentity(mMtx); - PSMTXIdentity(mMtxUnk); + MTXIdentity(mInvMtx); + MTXIdentity(mMtx); + MTXIdentity(mMtxUnk); } else { - PSMTXCopy(*mpMdlMtx, mInvMtx); + MTXCopy(*mpMdlMtx, mInvMtx); if (mpScale) { mMtx_c scale; - PSMTXScale(scale, mpScale->x, mpScale->y, mpScale->z); - PSMTXConcat(mInvMtx, scale, mInvMtx); + MTXScale(scale, mpScale->x, mpScale->y, mpScale->z); + MTXConcat(mInvMtx, scale, mInvMtx); } - PSMTXCopy(mInvMtx, mMtx); - PSMTXCopy(mInvMtx, mMtxUnk); + MTXCopy(mInvMtx, mMtx); + MTXCopy(mInvMtx, mMtxUnk); } } @@ -99,7 +99,7 @@ void cBgW::GlobalVtx() { } else { int i = 0; do { - PSMTXMultVec(mInvMtx, mpBgd->mVtxTbl[i], mpVtxTbl[i]); + MTXMultVec(mInvMtx, mpBgd->mVtxTbl[i], mpVtxTbl[i]); i++; } while (i < mpBgd->mVtxNum); } diff --git a/src/d/col/bg/d_bg_w_kcol.cpp b/src/d/col/bg/d_bg_w_kcol.cpp index ce27c650..e6bcc6d1 100644 --- a/src/d/col/bg/d_bg_w_kcol.cpp +++ b/src/d/col/bg/d_bg_w_kcol.cpp @@ -146,7 +146,7 @@ void dBgWKCol::vt_0x3C() { bool dBgWKCol::LineCheck(cBgS_LinChk *pLine) { mVec3_c diff; VEC3Sub(diff, pLine->mLin.GetStartP(), pLine->mLin.GetEndP()); - f32 mag = PSVECMag(diff); + f32 mag = VECMag(diff); if (mag < 500.0f) { int tmp0 = (int)(mag * 0.002f) + 1; f32 tmp1 = mag / (tmp0 + 1); diff --git a/src/d/col/bg/d_bg_w_time.cpp b/src/d/col/bg/d_bg_w_time.cpp index 7360bd4d..48737219 100644 --- a/src/d/col/bg/d_bg_w_time.cpp +++ b/src/d/col/bg/d_bg_w_time.cpp @@ -49,9 +49,9 @@ bool dBgWTime::GetTriPnt(cBgS_PolyInfo const &info, mVec3_c *pA, mVec3_c *pB, mV pB->set(1.f, 0.f, -1.f); pC->set(-1.f, 0.f, -1.f); - PSMTXMultVec(mtx, *pA, *pA); - PSMTXMultVec(mtx, *pB, *pB); - PSMTXMultVec(mtx, *pC, *pC); + MTXMultVec(mtx, *pA, *pA); + MTXMultVec(mtx, *pB, *pB); + MTXMultVec(mtx, *pC, *pC); *pA += info.GetField0x20(); *pB += info.GetField0x20(); diff --git a/src/d/col/c/c_cc_d.cpp b/src/d/col/c/c_cc_d.cpp index ab5c6247..bdabbceb 100644 --- a/src/d/col/c/c_cc_d.cpp +++ b/src/d/col/c/c_cc_d.cpp @@ -19,7 +19,7 @@ #include "rvl/MTX.h" // IWYU pragma: export static inline void MtxTransMinusXYZ(mMtx_c &mtx, f32 x, f32 y, f32 z) { - PSMTXTrans(mtx, -x, -y, -z); + MTXTrans(mtx, -x, -y, -z); } mVec3_c cCcD_ShapeAttr::sVirtualCenter = mVec3_c::Zero; @@ -692,7 +692,7 @@ bool cCcD_TriAttr::GetNVec(const mVec3_c &pnt, mVec3_c *pOut) const { *pOut = GetN(); } else { *pOut = GetN(); - PSVECScale(*pOut, *pOut, -1.0f); + VECScale(*pOut, *pOut, -1.0f); } return true; } @@ -728,8 +728,8 @@ cCcD_UnkAttr::~cCcD_UnkAttr() {} bool cCcD_UnkAttr::Calc(const mVec3_c &start, const mVec3_c &end, mVec3_c *pOut) { mVec3_c tmp0, tmp1; const mMtx_c &inv = mInvMtx; - PSMTXMultVec(inv, start, tmp0); - PSMTXMultVec(inv, end, tmp1); + MTXMultVec(inv, start, tmp0); + MTXMultVec(inv, end, tmp1); for (int i = 0; i < 3; i++) { bool tmp0Min = tmp0(i) < mMin(i); bool tmp0Max = tmp0(i) > mMax(i); @@ -761,7 +761,7 @@ bool cCcD_UnkAttr::Calc(const mVec3_c &start, const mVec3_c &end, mVec3_c *pOut) (*pOut)(i) = (tmp0(i) + tmp1(i)) * 0.5f; } } - PSMTXMultVec(mMtx, *pOut, *pOut); + MTXMultVec(mMtx, *pOut, *pOut); return true; } @@ -827,23 +827,23 @@ void cCcD_UnkAttr::CalcAabBox() { mVec3_c a; a = start; - PSMTXMultVec(mtx, a, a); + MTXMultVec(mtx, a, a); mAab.SetMinMax(a); a = end; - PSMTXMultVec(mtx, a, a); + MTXMultVec(mtx, a, a); mAab.SetMinMax(a); a.x = start.x; a.y = start.y; a.z = end.z; - PSMTXMultVec(mtx, a, a); + MTXMultVec(mtx, a, a); mAab.SetMinMax(a); a.x = end.x; a.y = end.y; a.z = start.z; - PSMTXMultVec(mtx, a, a); + MTXMultVec(mtx, a, a); mAab.SetMinMax(a); } @@ -988,18 +988,18 @@ bool cCcD_CpsAttr::Calc(const mVec3_c &start, const mVec3_c &end, mVec3_c *pOut) } bInverse = false; } else { - PSMTXTrans(mtx0, startRef.x, startRef.y, startRef.z); + MTXTrans(mtx0, startRef.x, startRef.y, startRef.z); mtx0.XrotM(mAng::atan2s(-dist, tmp0.y)); mtx0.YrotM(mAng::atan2s(-tmp0.x, tmp0.z)); mMtx_c mtx1; MtxTransMinusXYZ(mtx1, startRef.x, startRef.y, startRef.z); - PSMTXConcat(mtx0, mtx1, mtx0); - PSMTXMultVec(mtx0, start, tmp1); - PSMTXMultVec(mtx0, end, tmp2); + MTXConcat(mtx0, mtx1, mtx0); + MTXMultVec(mtx0, start, tmp1); + MTXMultVec(mtx0, end, tmp2); tmp3 = GetStart(); - PSMTXMultVec(mtx0, GetEnd(), tmp4); + MTXMultVec(mtx0, GetEnd(), tmp4); bInverse = true; } tmp3.y -= GetR() * 0.5f; @@ -1007,8 +1007,8 @@ bool cCcD_CpsAttr::Calc(const mVec3_c &start, const mVec3_c &end, mVec3_c *pOut) cyl.SetC(tmp3, GetR(), tmp4.y - tmp3.y); CalcCyl(cyl, tmp1, tmp2, pOut); if (bInverse) { - PSMTXInverse(mtx0, mtx0); - PSMTXMultVec(mtx0, *pOut, *pOut); + MTXInverse(mtx0, mtx0); + MTXMultVec(mtx0, *pOut, *pOut); } return true; } @@ -1111,31 +1111,31 @@ void cCcD_CpsAttr::CalcAabBox() { bool cCcD_CpsAttr::GetNVec(const mVec3_c ¶m0, mVec3_c *pOut) const { mVec3_c tmp1; - PSVECSubtract(GetEnd(), GetStart(), tmp1); - f32 sqMag = PSVECDotProduct(tmp1, tmp1); + VECSubtract(GetEnd(), GetStart(), tmp1); + f32 sqMag = VECDotProduct(tmp1, tmp1); if (cM3d_IsZero(sqMag)) { return false; } mVec3_c tmp2; - PSVECSubtract(param0, GetStart(), tmp2); - f32 sqDist = PSVECDotProduct(tmp2, tmp1) / sqMag; + VECSubtract(param0, GetStart(), tmp2); + f32 sqDist = VECDotProduct(tmp2, tmp1) / sqMag; mVec3_c tmp3; if (sqDist < 0.f) { tmp3 = GetStart(); } else if (sqDist > 1.f) { tmp3 = GetEnd(); } else { - PSVECScale(tmp1, tmp1, sqDist); - PSVECAdd(tmp1, GetStart(), tmp3); + VECScale(tmp1, tmp1, sqDist); + VECAdd(tmp1, GetStart(), tmp3); } - PSVECSubtract(param0, tmp3, *pOut); - if (cM3d_IsZero(PSVECMag(*pOut))) { + VECSubtract(param0, tmp3, *pOut); + if (cM3d_IsZero(VECMag(*pOut))) { pOut->set(0.f, 0.f, 0.f); return false; } else { - PSVECNormalize(*pOut, *pOut); + VECNormalize(*pOut, *pOut); return true; } } @@ -1266,12 +1266,12 @@ bool cCcD_CylAttr::GetNVec(const mVec3_c ¶m0, mVec3_c *pOut) const { vec = GetC(); vec.y = param0.y; } - PSVECSubtract(param0, vec, *pOut); - if (cM3d_IsZero(PSVECMag(*pOut))) { + VECSubtract(param0, vec, *pOut); + if (cM3d_IsZero(VECMag(*pOut))) { pOut->set(0.f, 0.f, 0.f); return false; } else { - PSVECNormalize(*pOut, *pOut); + VECNormalize(*pOut, *pOut); return true; } } @@ -1393,11 +1393,11 @@ bool cCcD_SphAttr::GetNVec(const mVec3_c ¶m0, mVec3_c *param1) const { param1->x = param0.x - GetC().x; param1->y = param0.y - GetC().y; param1->z = param0.z - GetC().z; - if (cM3d_IsZero(PSVECMag(*param1))) { + if (cM3d_IsZero(VECMag(*param1))) { param1->set(0.0f, 0.0f, 0.0f); return false; } else { - PSVECNormalize(*param1, *param1); + VECNormalize(*param1, *param1); return true; } } diff --git a/src/d/col/c/c_m3d.cpp b/src/d/col/c/c_m3d.cpp index ca55d2da..f69a11a7 100644 --- a/src/d/col/c/c_m3d.cpp +++ b/src/d/col/c/c_m3d.cpp @@ -169,8 +169,8 @@ bool cM3d_Cross_SphSph(const cM3dGSph &, const cM3dGSph &, VEC3 *) { void cM3d_CalcSphVsTriCrossPoint(const cM3dGSph &pSph, const cM3dGTri &pTri, VEC3 *pPnt) { VEC3 scale, add; - PSVECAdd(pTri.mA, pTri.mB, add); - PSVECScale(add, scale, 0.5f); + VECAdd(pTri.mA, pTri.mB, add); + VECScale(add, scale, 0.5f); const f32 mag = VEC3DistSq(&scale, &pSph.GetC()); if (cM3d_IsZero(mag)) { *pPnt = pSph.GetC(); @@ -245,7 +245,7 @@ f32 cM3d_lineVsPosSuisenCross(const VEC3 &, const VEC3 &, const VEC3 &, VEC3 *) } bool cM3d_Normalize(nw4r::math::VEC3 *pPnt) { - f32 mag = PSVECMag(*pPnt); + f32 mag = VECMag(*pPnt); if (cM3d_IsZero(mag)) { return true; } diff --git a/src/d/col/c/c_m3d_g_aab.cpp b/src/d/col/c/c_m3d_g_aab.cpp index a0b9a78a..18788741 100644 --- a/src/d/col/c/c_m3d_g_aab.cpp +++ b/src/d/col/c/c_m3d_g_aab.cpp @@ -27,8 +27,8 @@ void cM3dGAab::SetMax(const mVec3_c &max) { } void cM3dGAab::CalcCenter(mVec3_c ¢er) const { - PSVECAdd(mMin, mMax, center); - PSVECScale(center, center, 0.5f); + VECAdd(mMin, mMax, center); + VECScale(center, center, 0.5f); } void cM3dGAab::PlusR(f32 r) { diff --git a/src/d/col/c/c_m3d_g_cps.cpp b/src/d/col/c/c_m3d_g_cps.cpp index 6fbcfc3d..fd1028ac 100644 --- a/src/d/col/c/c_m3d_g_cps.cpp +++ b/src/d/col/c/c_m3d_g_cps.cpp @@ -34,10 +34,10 @@ bool cM3dGCps::Cross(cM3dGUnk &unk, mVec3_c *vec) { bool cM3dGCps::fn_80337f40(const mVec3_c &v) const { f32 r2 = mRadius * mRadius; - if (!(mFlags & 1) && PSVECSquareDistance(mStart, v) <= r2) { + if (!(mFlags & 1) && VECSquareDistance(mStart, v) <= r2) { return true; } - if (!(mFlags & 2) && PSVECSquareDistance(mEnd, v) <= r2) { + if (!(mFlags & 2) && VECSquareDistance(mEnd, v) <= r2) { return true; } f32 tmp; diff --git a/src/d/col/c/c_m3d_g_lin.cpp b/src/d/col/c/c_m3d_g_lin.cpp index e602ba11..5266f26d 100644 --- a/src/d/col/c/c_m3d_g_lin.cpp +++ b/src/d/col/c/c_m3d_g_lin.cpp @@ -11,9 +11,9 @@ void cM3dGLin::SetStartEnd(const mVec3_c *start, const mVec3_c *end) { void cM3dGLin::CalcPos(mVec3_c *out, f32 scale) const { mVec3_c tmp; - PSVECSubtract(mEnd, mStart, tmp); - PSVECScale(tmp, tmp, scale); - PSVECAdd(tmp, mStart, *out); + VECSubtract(mEnd, mStart, tmp); + VECScale(tmp, tmp, scale); + VECAdd(tmp, mStart, *out); } void cM3dGLin::SetStart(const mVec3_c &start) { diff --git a/src/d/col/c/c_m3d_g_unk.cpp b/src/d/col/c/c_m3d_g_unk.cpp index 01f30de6..570af068 100644 --- a/src/d/col/c/c_m3d_g_unk.cpp +++ b/src/d/col/c/c_m3d_g_unk.cpp @@ -16,8 +16,8 @@ cM3dGUnk::cM3dGUnk() { field_0xB4 = 0; mVirtCenter.set(0.0f, 0.0f, 0.0f); field_0xC4 = 0.0f; - PSMTXIdentity(mMtx); - PSMTXIdentity(mInvMtx); + MTXIdentity(mMtx); + MTXIdentity(mInvMtx); } void cM3dGUnk::Set(const mVec3_c &vA, const mVec3_c &vB) { @@ -34,13 +34,13 @@ void cM3dGUnk::Set(const mVec3_c &vA, const mVec3_c &vB) { void cM3dGUnk::Update() { mVec3_c a, b; - PSMTXMultVec(mMtx, mMin, a); - PSMTXMultVec(mMtx, mMax, b); + MTXMultVec(mMtx, mMin, a); + MTXMultVec(mMtx, mMax, b); mLin.GetStart().x = (a.x + b.x) * 0.5f; mLin.GetStart().y = (a.y + b.y) * 0.5f; mLin.GetStart().z = (a.z + b.z) * 0.5f; - if (!PSMTXInverse(mMtx, mInvMtx)) { - PSMTXIdentity(mInvMtx); + if (!MTXInverse(mMtx, mInvMtx)) { + MTXIdentity(mInvMtx); } } @@ -89,7 +89,7 @@ void cM3dGUnk::Set(const mMtx_c &mtx) { void cM3dGUnk::Set(const mVec3_c &vec, const mAng &ang) { mMtx_c mtx; - PSMTXIdentity(mtx); + MTXIdentity(mtx); mtx.YrotS(ang); mtx.setTranslation(vec); Set(mtx); @@ -97,7 +97,7 @@ void cM3dGUnk::Set(const mVec3_c &vec, const mAng &ang) { bool cM3dGUnk::Cross(const mVec3_c &vec) { mVec3_c tmp; - PSMTXMultVec(mInvMtx, vec, tmp); + MTXMultVec(mInvMtx, vec, tmp); if ((tmp.x < mMin.x)) { return false; } @@ -121,11 +121,11 @@ bool cM3dGUnk::Cross(const mVec3_c &vec) { void cM3dGUnk::Clamp(const mVec3_c &in, mVec3_c &out) { mVec3_c tmp1, tmp2; - PSMTXMultVec(mInvMtx, in, tmp1); + MTXMultVec(mInvMtx, in, tmp1); cM3dGAab aab; aab.Set(mMin, mMax); aab.Clamp(tmp1, tmp2); - PSMTXMultVec(mMtx, tmp2, out); + MTXMultVec(mMtx, tmp2, out); } void cM3dGUnk::fn_80338f30(f32 f0, f32 f1) { diff --git a/src/d/col/cc/d_cc_d.cpp b/src/d/col/cc/d_cc_d.cpp index ce7e720f..4c4188b9 100644 --- a/src/d/col/cc/d_cc_d.cpp +++ b/src/d/col/cc/d_cc_d.cpp @@ -16,7 +16,7 @@ cCcD_ShapeAttr *dCcD_Cps::GetShapeAttr() { } void dCcD_Cps::unknownCalc() { - PSVECSubtract(mEnd, mStart, mAt.mVec); + VECSubtract(mEnd, mStart, mAt.mVec); } dCcD_Tri::dCcD_Tri() {} diff --git a/src/d/col/cc/d_cc_mass_s.cpp b/src/d/col/cc/d_cc_mass_s.cpp index 7472d2a3..01120aac 100644 --- a/src/d/col/cc/d_cc_mass_s.cpp +++ b/src/d/col/cc/d_cc_mass_s.cpp @@ -176,13 +176,13 @@ u32 dCcMassS_Mng::Chk(mVec3_c *p_xyz, dAcObjBase_c **p_actor, dCcMassS_HitInf *p if (field_0x3A8 & 0x10) { mVec3_c vec; - PSVECSubtract((*p_actor)->getPosition(), *p_xyz, vec); + VECSubtract((*p_actor)->getPosition(), *p_xyz, vec); vec.y = 0; - f32 vecMag = PSVECMag(vec); + f32 vecMag = VECMag(vec); if (cM3d_IsZero(vecMag)) { vec.x = 1; } else { - PSVECScale(vec, vec, f / vecMag); + VECScale(vec, vec, f / vecMag); } obj->GetStts()->PlusCcMove(vec.x, vec.y, vec.z); } @@ -208,7 +208,7 @@ u32 dCcMassS_Mng::Chk(mVec3_c *p_xyz, dAcObjBase_c **p_actor, dCcMassS_HitInf *p tmpVec.z = p_xyz->z; if (mCamTopPos.y < (20.0f + plusH)) { - f32 newCamTopDist = PSVECSquareDistance(&tmpVec, *mCpsAttr.GetStartP()); + f32 newCamTopDist = VECSquareDistance(&tmpVec, *mCpsAttr.GetStartP()); if (mCamTopDist > newCamTopDist) { mCamTopDist = newCamTopDist; mCamTopPos = tmpVec; @@ -216,7 +216,7 @@ u32 dCcMassS_Mng::Chk(mVec3_c *p_xyz, dAcObjBase_c **p_actor, dCcMassS_HitInf *p } if (mCamBottomPos.y < (20.0f + plusH)) { - f32 newCamBottomDist = PSVECSquareDistance(&tmpVec, *mCpsAttr.GetEndP()); + f32 newCamBottomDist = VECSquareDistance(&tmpVec, *mCpsAttr.GetEndP()); if (mCamBottomDist > newCamBottomDist) { mCamBottomDist = newCamBottomDist; mCamBottomPos = tmpVec; diff --git a/src/d/col/cc/d_cc_s.cpp b/src/d/col/cc/d_cc_s.cpp index e5789bcd..fca2d6a0 100644 --- a/src/d/col/cc/d_cc_s.cpp +++ b/src/d/col/cc/d_cc_s.cpp @@ -159,7 +159,7 @@ void dCcS::SetArea(mMtx_c *pMtx) { // non-match: Huh mAreas[mAreaCount].mInv = mAreas[mAreaCount].mMtx = *pMtx; - PSMTXInverse(mAreas[mAreaCount].mInv, mAreas[mAreaCount].mInv); + MTXInverse(mAreas[mAreaCount].mInv, mAreas[mAreaCount].mInv); mAreaCount++; } diff --git a/src/d/lyt/d_screen_fader.cpp b/src/d/lyt/d_screen_fader.cpp index 1ea4a5d7..8d8d7c30 100644 --- a/src/d/lyt/d_screen_fader.cpp +++ b/src/d/lyt/d_screen_fader.cpp @@ -45,14 +45,14 @@ void dScreenFader_c::draw() { f32 scaleY = EGG::Screen::GetSizeYMax(); mMtx_c mtx; - PSMTXScale(mtx, scaleX, mProgress, 1.0f); - PSMTXTransApply(mtx, mtx, -scaleX * 0.5f, scaleY * 0.5f - mProgress, 0.0f); + MTXScale(mtx, scaleX, mProgress, 1.0f); + MTXTransApply(mtx, mtx, -scaleX * 0.5f, scaleY * 0.5f - mProgress, 0.0f); GXColor a = EGG::DrawGX::BLACK; EGG::DrawGX::DrawDL(EGG::DrawGX::DL_17, mtx, a); - PSMTXScale(mtx, scaleX, mProgress, 1.0f); - PSMTXTransApply(mtx, mtx, -scaleX * 0.5f, -scaleY * 0.5f, 0.0f); + MTXScale(mtx, scaleX, mProgress, 1.0f); + MTXTransApply(mtx, mtx, -scaleX * 0.5f, -scaleY * 0.5f, 0.0f); EGG::DrawGX::DrawDL(EGG::DrawGX::DL_17, mtx, a); } diff --git a/src/egg/core/eggColorFader.cpp b/src/egg/core/eggColorFader.cpp index 6707734a..531a5731 100644 --- a/src/egg/core/eggColorFader.cpp +++ b/src/egg/core/eggColorFader.cpp @@ -103,7 +103,7 @@ void EGG::ColorFader::draw() { GXSetScissor(mStartX, mStartY, getWidth(), getHeight()); Mtx posMtx; - PSMTXIdentity(posMtx); + MTXIdentity(posMtx); GXLoadPosMtxImm(posMtx, 0); GXSetCurrentMtx(0); diff --git a/src/egg/gfx/eggCpuTexture.cpp b/src/egg/gfx/eggCpuTexture.cpp index c0d9cd8e..c422b17d 100644 --- a/src/egg/gfx/eggCpuTexture.cpp +++ b/src/egg/gfx/eggCpuTexture.cpp @@ -188,7 +188,7 @@ void CpuTexture::fillNormalMapSphere(f32 f1, f32 f2) { // TODO: std::sqrtf? vec(2) = fz < Math::zero() ? Math::zero() : (f32)sqrt(fz); - PSVECNormalize(vec, vec); + VECNormalize(vec, vec); GXUtility::getNormalColor(c, vec); c.r = c.a; setColor(x, y, c); diff --git a/src/egg/gfx/eggDrawGX.cpp b/src/egg/gfx/eggDrawGX.cpp index 8ab23ff1..b0ddc2e5 100644 --- a/src/egg/gfx/eggDrawGX.cpp +++ b/src/egg/gfx/eggDrawGX.cpp @@ -72,8 +72,8 @@ static void DrawCircleYPolygonFan(const nw4r::math::MTX34 &mtx, f32 f, u16 numSe int seg = numSegments + 1; - PSMTXMultVec(mtx, v1, v1); - PSMTXMultVec(mtx, v2, v2); + MTXMultVec(mtx, v1, v1); + MTXMultVec(mtx, v2, v2); GXBegin(GX_TRIANGLEFAN, GX_VTXFMT0, seg + 1); @@ -86,7 +86,7 @@ static void DrawCircleYPolygonFan(const nw4r::math::MTX34 &mtx, f32 f, u16 numSe nw4r::math::VEC3 v3( 0.5f * nw4r::math::SinRad(signedStepSize * i), 0.0f, 0.5f * nw4r::math::CosRad(signedStepSize * i) ); - PSMTXMultVec(mtx, v3, v3); + MTXMultVec(mtx, v3, v3); GXPosition3f32(v3.x, v3.y, v3.z); nw4r::math::VEC3 v4( @@ -98,15 +98,15 @@ static void DrawCircleYPolygonFan(const nw4r::math::MTX34 &mtx, f32 f, u16 numSe 0.5f * nw4r::math::CosRad(signedStepSize * (i + 1)) ); - PSMTXMultVec(mtx, v4, v4); - PSMTXMultVec(mtx, v5, v5); + MTXMultVec(mtx, v4, v4); + MTXMultVec(mtx, v5, v5); nw4r::math::VEC3Sub(&v4, &v4, &v2); nw4r::math::VEC3Sub(&v5, &v5, &v2); nw4r::math::VEC3 v6; - PSVECCrossProduct(v5, v4, v6); - PSVECNormalize(v6, v6); + VECCrossProduct(v5, v4, v6); + VECNormalize(v6, v6); GXPosition3f32(v6.x, v6.y, v6.z); } @@ -145,7 +145,7 @@ void DrawGX::Initialize(Heap *pHeap_) { GXInitTexObj(&CLEAR_Z_TEX_OBJ, s_clear_z_TX, 4, 4, GX_TF_Z24X8, GX_REPEAT, GX_REPEAT, false); GXInitTexObjLOD(&CLEAR_Z_TEX_OBJ, GX_NEAR, GX_NEAR, 0.0, 0.0, 0.0, 0, 0, GX_ANISO_1); - PSMTXIdentity(s_cameraMtx.m); + MTXIdentity(s_cameraMtx.m); CreateDisplayList(pHeap); } @@ -591,29 +591,29 @@ void DrawGX::CreateDisplayList(EGG::Heap *pHeap) { GXPosition3f32(2.0f * x, 0.0f, 2.0f * z); } nw4r::math::MTX34 mtx; - PSMTXTrans(mtx, 0.0f, 0.5f, 0.0f); + MTXTrans(mtx, 0.0f, 0.5f, 0.0f); DrawCircleYPolygonFan(mtx, 0.0f, POS_NUM[i - DL_9]); - PSMTXIdentity(mtx); - PSMTXRotRad(mtx, M_PI, 0x7A); - PSMTXTransApply(mtx, mtx, 0.0f, -0.5f, 0.0f); + MTXIdentity(mtx); + MTXRotRad(mtx, M_PI, 0x7A); + MTXTransApply(mtx, mtx, 0.0f, -0.5f, 0.0f); DrawCircleYPolygonFan(mtx, 0.0f, POS_NUM[i - DL_9]); break; } case DL_11: case DL_12: { nw4r::math::MTX34 mtx; - PSMTXIdentity(mtx); + MTXIdentity(mtx); DrawCircleYPolygonFan(mtx, 1.0f, POS_NUM[i - DL_11]); - PSMTXRotRad(mtx, M_PI, 0x7A); + MTXRotRad(mtx, M_PI, 0x7A); DrawCircleYPolygonFan(mtx, 0.0f, POS_NUM[i - DL_11]); break; } case DL_7: case DL_8: { nw4r::math::MTX34 mtx; - PSMTXIdentity(mtx); - PSMTXRotRad(mtx, M_PI / 2.0f, 0x78); + MTXIdentity(mtx); + MTXRotRad(mtx, M_PI / 2.0f, 0x78); DrawCircleYPolygonFan(mtx, 0.0f, POS_NUM[i - DL_7]); break; } @@ -725,7 +725,7 @@ void DrawGX::SetBlendMode(enum Blend mode) { void DrawGX::DrawDLWorld(DL dl, const EGG::Matrix34f &mtx, GXColor color) { nw4r::math::MTX34 resMtx; - PSMTXConcat(s_cameraMtx.m, mtx.m, resMtx.m); + MTXConcat(s_cameraMtx.m, mtx.m, resMtx.m); DrawDL(dl, resMtx, color); } diff --git a/src/egg/gfx/eggDrawPathLightMap.cpp b/src/egg/gfx/eggDrawPathLightMap.cpp index 21a0ad6c..da217979 100644 --- a/src/egg/gfx/eggDrawPathLightMap.cpp +++ b/src/egg/gfx/eggDrawPathLightMap.cpp @@ -78,7 +78,7 @@ void DrawPathLightMap::internalDraw(u16 idx) { PostEffectBase::setProjection(GetScreen()); - PSMTXScale(forDL, GetScreen().GetWidth(), GetScreen().GetHeight(), 1.0f); + MTXScale(forDL, GetScreen().GetWidth(), GetScreen().GetHeight(), 1.0f); mpTextureBuffer_0x30->load(GX_TEXMAP0); DrawGX::BeginDrawScreen(true, true, false); @@ -113,7 +113,7 @@ void DrawPathLightMap::internalDraw(u16 idx) { nw4r::math::MTX34 forDL; PostEffectBase::setProjection(GetScreen()); - PSMTXScale(forDL, GetScreen().GetWidth(), GetScreen().GetHeight(), 1.0f); + MTXScale(forDL, GetScreen().GetWidth(), GetScreen().GetHeight(), 1.0f); GXColor tevColor = {0xFF, 0xFF, 0xFF, mAlpha}; diff --git a/src/egg/gfx/eggG3DUtility.cpp b/src/egg/gfx/eggG3DUtility.cpp index a61cefc6..dd3a7ed1 100644 --- a/src/egg/gfx/eggG3DUtility.cpp +++ b/src/egg/gfx/eggG3DUtility.cpp @@ -66,7 +66,7 @@ void G3DUtility::create(u32 size, Heap *pHeap) { void G3DUtility::defaultTexMtxFunc(nw4r::math::MTX34 *pMtx, s8 camRef, s8 lightRef) { const nw4r::math::MTX34 *mtxPtr = nw4r::g3d::G3DState::GetInvCameraMtxPtr(); - PSMTXCopy(mtxPtr->m, pMtx->m); + MTXCopy(mtxPtr->m, pMtx->m); } bool G3DUtility::setUpLightSet(nw4r::g3d::LightSetting &lightSet, nw4r::g3d::ResAnmScn scn, int refNumber) { diff --git a/src/egg/gfx/eggGlobalDrawState.cpp b/src/egg/gfx/eggGlobalDrawState.cpp index bb1f3df3..06e2b383 100644 --- a/src/egg/gfx/eggGlobalDrawState.cpp +++ b/src/egg/gfx/eggGlobalDrawState.cpp @@ -19,7 +19,7 @@ GlobalDrawState sState; void GlobalDrawState::beginDrawView(u16 cameraId, const nw4r::math::MTX34 &mtx, const Screen &screen) { spScreen = &screen; sCameraId = cameraId; - PSMTXCopy(mtx, sMtx); + MTXCopy(mtx, sMtx); StateEfb::Clean(); } diff --git a/src/egg/gfx/eggIScnProc.cpp b/src/egg/gfx/eggIScnProc.cpp index 25e3dafa..cb9ae243 100644 --- a/src/egg/gfx/eggIScnProc.cpp +++ b/src/egg/gfx/eggIScnProc.cpp @@ -27,7 +27,7 @@ void IScnProc::createScnProc(u16 procNum, MEMAllocator *pAllocator) { mNumScnProc = procNum; mpDataSet = new ProcData[mNumScnProc]; nw4r::math::MTX34 mtx; - PSMTXIdentity(mtx); + MTXIdentity(mtx); for (u16 i = 0; i < getNumScnProc(); i++) { u32 sp8; diff --git a/src/egg/gfx/eggLightManager.cpp b/src/egg/gfx/eggLightManager.cpp index 003b8703..a8c72d7c 100644 --- a/src/egg/gfx/eggLightManager.cpp +++ b/src/egg/gfx/eggLightManager.cpp @@ -117,7 +117,7 @@ void LightManager::CalcView(const nw4r::math::MTX34 &viewMtx, u8 lightObjOffset, DCFlushRange(gxObj, CheckedNumLightObjs(mCounts.mNumEggLightObjects) * sizeof(GXLightObj)); if (root != nullptr) { nw4r::math::MTX34 tmp; - PSMTXInverse(viewMtx, tmp); + MTXInverse(viewMtx, tmp); CopyToG3D_View(root, tmp); } } diff --git a/src/egg/gfx/eggLightObject.cpp b/src/egg/gfx/eggLightObject.cpp index 5bf0b97b..f58493d5 100644 --- a/src/egg/gfx/eggLightObject.cpp +++ b/src/egg/gfx/eggLightObject.cpp @@ -114,18 +114,18 @@ void LightObject::CalcView(nw4r::math::MTX34 const &viewMtx) { } else { if (getField0x3C() == 1) { nw4r::math::VEC3 tmp(-viewMtx._20, -viewMtx._21, -viewMtx._22); - if (PSVECMag(tmp) > 0.0f) { + if (VECMag(tmp) > 0.0f) { nw4r::math::VEC3 angle; C_VECHalfAngle(mDir, tmp, angle); nw4r::math::VEC3Scale(&field_0x6C, &angle, -1.0f); - PSVECNormalize(field_0x6C, field_0x6C); + VECNormalize(field_0x6C, field_0x6C); } else { field_0x6C.x = field_0x6C.y = 0.0f; field_0x6C.z = 1.0f; } } - PSMTXMultVec(viewMtx, mPos, mViewPos); - PSMTXMultVec(viewMtx, mAt, mViewAt); + MTXMultVec(viewMtx, mPos, mViewPos); + MTXMultVec(viewMtx, mAt, mViewAt); nw4r::math::VEC3TransformNormal(&field_0x94, &viewMtx, &field_0x6C); } } @@ -238,12 +238,12 @@ void LightObject::CopyToG3D_View(nw4r::g3d::LightObj &g3dObj, const nw4r::math:: break; } case 0: { - PSMTXMultVec(viewMtx, mViewPos, pos); + MTXMultVec(viewMtx, mViewPos, pos); dir.x = dir.y = dir.z = 0.0f; break; } case 2: { - PSMTXMultVec(viewMtx, mViewPos, pos); + MTXMultVec(viewMtx, mViewPos, pos); nw4r::math::VEC3TransformNormal(&dir, &viewMtx, &field_0x94); break; } diff --git a/src/egg/gfx/eggLightTexture.cpp b/src/egg/gfx/eggLightTexture.cpp index 3452484b..fbc9e640 100644 --- a/src/egg/gfx/eggLightTexture.cpp +++ b/src/egg/gfx/eggLightTexture.cpp @@ -519,7 +519,7 @@ void LightTexture::debugDraw(int i) { fn_804AC0A0(i, &u1, &u2); load(GX_TEXMAP0); nw4r::math::MTX34 mtx; - PSMTXScale(mtx, sTexWidth, sTexHeight, 1.0f); + MTXScale(mtx, sTexWidth, sTexHeight, 1.0f); mtx._03 = u1; mtx._13 = sDrawHeight - (u2 + sTexHeight); diff --git a/src/egg/gfx/eggLightTextureMgr.cpp b/src/egg/gfx/eggLightTextureMgr.cpp index 09de2e1e..8ae966c0 100644 --- a/src/egg/gfx/eggLightTextureMgr.cpp +++ b/src/egg/gfx/eggLightTextureMgr.cpp @@ -247,7 +247,7 @@ void LightTextureManager::drawAndCaptureTexture(f32 ox, f32 oy, f32 sx, f32 sy) StateGX::GXSetScissor_(x1, y1, x2, y2); StateGX::GXSetScissorBoxOffset_(0, 0); nw4r::math::MTX34 identity; - PSMTXIdentity(identity); + MTXIdentity(identity); DrawGX::BeginDrawScreen(1, 1, 0); DrawGX::SetBlendMode(DrawGX::BLEND_14); diff --git a/src/egg/gfx/eggModelEx.cpp b/src/egg/gfx/eggModelEx.cpp index 14c10293..c38a3aed 100644 --- a/src/egg/gfx/eggModelEx.cpp +++ b/src/egg/gfx/eggModelEx.cpp @@ -66,7 +66,7 @@ void ModelEx::getShapeMinMax(u16 shapeIndex, math::VEC3 *pMin, math::VEC3 *pMax, math::MTX34 *pMtxArr = reinterpret_cast(G3DUtility::BumpAlloc(info.GetNumPosNrmMtx() * sizeof(math::MTX34), 1)); if (doCalcWorld) { - PSMTXIdentity(tmpMtx); + MTXIdentity(tmpMtx); calcWorld(pMtxArr, &tmpMtx); } @@ -86,7 +86,7 @@ void ModelEx::getShapeMinMax(u16 shapeIndex, math::VEC3 *pMin, math::VEC3 *pMax, mtxIdx = defaultMatrixIdx; } nw4r::math::VEC3 tmpVec; - PSMTXMultVec(pMtxArr[mtxIdx], &analyze.getVtxResult().field_0x08, tmpVec); + MTXMultVec(pMtxArr[mtxIdx], &analyze.getVtxResult().field_0x08, tmpVec); if (firstIteration) { firstIteration = false; *pMin = *pMax = tmpVec; diff --git a/src/egg/gfx/eggPostEffectBase.cpp b/src/egg/gfx/eggPostEffectBase.cpp index e7dbd1cb..4627caad 100644 --- a/src/egg/gfx/eggPostEffectBase.cpp +++ b/src/egg/gfx/eggPostEffectBase.cpp @@ -43,7 +43,7 @@ void PostEffectBase::setVtxState() { void PostEffectBase::drawScreenInternal(f32 offsetX, f32 offsetY, f32 width, f32 height) { nw4r::math::MTX34 mtx; - PSMTXScale(mtx, width, height, 1.0f); + MTXScale(mtx, width, height, 1.0f); mtx._03 = offsetX; mtx._13 = offsetY; mtx._23 = 0.0f; diff --git a/src/egg/gfx/eggPostEffectBlur.cpp b/src/egg/gfx/eggPostEffectBlur.cpp index 934ee0d3..fb302821 100644 --- a/src/egg/gfx/eggPostEffectBlur.cpp +++ b/src/egg/gfx/eggPostEffectBlur.cpp @@ -76,7 +76,7 @@ void PostEffectBlur::setMaterialMulti(u8 kernelIdx, u8 p2, f32 f1, f32 f2) { 0.0f, 0.0f, 0.0f, 0.0f // clang-format on ); - PSMTXConcat(m, mtx, m); + MTXConcat(m, mtx, m); GXLoadTexMtxImm(m, texMtxId, GX_MTX2x4); unk_00_scale++; } diff --git a/src/egg/gfx/eggPostEffectMaskDOF.cpp b/src/egg/gfx/eggPostEffectMaskDOF.cpp index b340038b..987d36c1 100644 --- a/src/egg/gfx/eggPostEffectMaskDOF.cpp +++ b/src/egg/gfx/eggPostEffectMaskDOF.cpp @@ -101,8 +101,8 @@ void PostEffectMaskDOF::draw(f32 width, f32 height) { GXSetVtxAttrFmt(GX_VTXFMT0, GX_VA_TEX1, GX_TEX_ST, GX_F32, 0); GXSetVtxDesc(GX_VA_TEX1, GX_DIRECT); nw4r::math::MTX34 mtx; - PSMTXScale(mtx, width * mScaleX, height * mScaleY, 1.f); - PSMTXTransApply(mtx, mtx, mOffsetX, mOffsetY, 0.f); + MTXScale(mtx, width * mScaleX, height * mScaleY, 1.f); + MTXTransApply(mtx, mtx, mOffsetX, mOffsetY, 0.f); GXLoadPosMtxImm(mtx, GX_PNMTX0); GXBegin(GX_QUADS, GX_VTXFMT0, 4); GXPosition2u8(0, 0); diff --git a/src/egg/gfx/eggPostEffectUnk2.cpp b/src/egg/gfx/eggPostEffectUnk2.cpp index 8156ba5d..e2194b01 100644 --- a/src/egg/gfx/eggPostEffectUnk2.cpp +++ b/src/egg/gfx/eggPostEffectUnk2.cpp @@ -61,8 +61,8 @@ void PostEffectUnk2::draw(f32 width, f32 height) { GXSetVtxDesc(GX_VA_TEX1, GX_DIRECT); nw4r::math::MTX34 mtx; - PSMTXScale(mtx, width * mScaleX, height * mScaleY, 1.0f); - PSMTXTransApply(mtx, mtx, mOffsetX, mOffsetY, 0.0f); + MTXScale(mtx, width * mScaleX, height * mScaleY, 1.0f); + MTXTransApply(mtx, mtx, mOffsetX, mOffsetY, 0.0f); GXLoadPosMtxImm(mtx, 0); static const f32 floats1[2][2] = { diff --git a/src/egg/gfx/eggScreen.cpp b/src/egg/gfx/eggScreen.cpp index 9a9d58cb..e65b3436 100644 --- a/src/egg/gfx/eggScreen.cpp +++ b/src/egg/gfx/eggScreen.cpp @@ -264,7 +264,7 @@ bool Screen::IsChangeEfb() const { } void Screen::CalcMatrixForDrawQuad(math::MTX34 *mtx, f32 x, f32 y, f32 sx, f32 sy) const { - PSMTXScale(*mtx, sx, sy, 1.0f); + MTXScale(*mtx, sx, sy, 1.0f); mtx->m[0][3] = x; mtx->m[1][3] = mCanvasMode == CANVASMODE_0 ? y - sy : y; diff --git a/src/egg/gfx/eggScreenEffectBlur.cpp b/src/egg/gfx/eggScreenEffectBlur.cpp index afe15f76..164221a6 100644 --- a/src/egg/gfx/eggScreenEffectBlur.cpp +++ b/src/egg/gfx/eggScreenEffectBlur.cpp @@ -96,7 +96,7 @@ void ScreenEffectBlur::fn_804B32B0() { if (field_0x0C & 1) { nw4r::math::MTX34 m; - PSMTXScale(m, sizeY, sizeY, 1.f); + MTXScale(m, sizeY, sizeY, 1.f); pTex0->load(GX_TEXMAP0); DrawGX::BeginDrawScreen(true, true, false); DrawGX::SetBlendMode(DrawGX::BLEND_14); @@ -114,7 +114,7 @@ void ScreenEffectBlur::fn_804B3710() { // Have to perform a float -> u16 -> float round trip here... u16 sizeY = sScreen.GetSize().y; u16 sizeX = sScreen.GetSize().x; - PSMTXScale(mtx, sizeX, sizeY, 0.0f); + MTXScale(mtx, sizeX, sizeY, 0.0f); mpCpuTexture->load(GX_TEXMAP0); DrawGX::BeginDrawScreen(true, true, true); GXSetTevKColor(GX_KCOLOR0, field_0x28); diff --git a/src/egg/gfx/eggStateEfb.cpp b/src/egg/gfx/eggStateEfb.cpp index e2a11581..8ca5992d 100644 --- a/src/egg/gfx/eggStateEfb.cpp +++ b/src/egg/gfx/eggStateEfb.cpp @@ -184,7 +184,7 @@ void StateEfb::popWorkBuffer(bool b, u32 userData) { StateGX::GXSetScissorBoxOffset_(0, 0); nw4r::math::MTX34 mtx; - PSMTXScale(mtx, parentScreen.GetSize().x, parentScreen.GetSize().y, 1.0f); + MTXScale(mtx, parentScreen.GetSize().x, parentScreen.GetSize().y, 1.0f); DrawGX::BeginDrawScreen(true, isEnableDirtyBufferMode(), false); DrawGX::SetBlendMode(DrawGX::BLEND_14); diff --git a/src/egg/math/eggMatrix.cpp b/src/egg/math/eggMatrix.cpp index 93108411..260505a4 100644 --- a/src/egg/math/eggMatrix.cpp +++ b/src/egg/math/eggMatrix.cpp @@ -6,11 +6,11 @@ namespace EGG { void Matrix34f::inverseTo(Matrix34f &to) const { - PSMTXInverse(m, to.m); + MTXInverse(m, to.m); } void Matrix34f::inverseTransposeTo(Matrix34f &to) const { - PSMTXInvXpose(m, to.m); + MTXInvXpose(m, to.m); } void Matrix34f::makeIdentity() { @@ -357,7 +357,7 @@ void Matrix34f::loadPosMtx(u32 posMtxId) { } void Matrix34f::multiplyTo(const Matrix34f &m2, Matrix34f &to) const { - PSMTXConcat(m, m2.m, to.m); + MTXConcat(m, m2.m, to.m); } void Matrix34f::dump() {} diff --git a/src/m/m2d.cpp b/src/m/m2d.cpp index 1d980058..1aaaefff 100644 --- a/src/m/m2d.cpp +++ b/src/m/m2d.cpp @@ -268,10 +268,10 @@ Simple_c::Simple_c() : Base_c(0x80), mLayout(), mDrawInfo(), mpResAcc(nullptr), void Simple_c::calc() { calcBefore(); nw4r::math::MTX34 mtx; - PSMTXIdentity(mtx.m); + MTXIdentity(mtx.m); // Probably inlines mVec3_c v = mVec; - PSMTXTransApply(mtx.m, mtx.m, v.x, v.y, v.z); + MTXTransApply(mtx.m, mtx.m, v.x, v.y, v.z); mDrawInfo.SetViewMtx(mtx); calcAfter(); } diff --git a/src/m/m3d/m_bline.cpp b/src/m/m3d/m_bline.cpp index 19f506fd..355c73d0 100644 --- a/src/m/m3d/m_bline.cpp +++ b/src/m/m3d/m_bline.cpp @@ -59,8 +59,8 @@ void blineMat_c::update() { mVec3_c vec; getCurrentCamera().GetCameraMtx(&camMtx); - PSMTXInverse(camMtx, camMtx); - PSMTXMultVec(camMtx, mVec3_c::Zero, vec); + MTXInverse(camMtx, camMtx); + MTXMultVec(camMtx, mVec3_c::Zero, vec); for (bline_c *line = (bline_c *)nw4r::ut::List_GetNext(&mLines, 0); line != nullptr; line = (bline_c *)nw4r::ut::List_GetNext(&mLines, line)) { diff --git a/src/m/m3d/m_bmdl.cpp b/src/m/m3d/m_bmdl.cpp index 2515e856..32fa0fc9 100644 --- a/src/m/m3d/m_bmdl.cpp +++ b/src/m/m3d/m_bmdl.cpp @@ -44,7 +44,7 @@ bool bmdl_c::getNodeWorldMtxMultVec(u32 p1, const nw4r::math::VEC3 &in, nw4r::ma if (!getNodeWorldMtx(p1, &mtx)) { return false; } else { - PSMTXMultVec(mtx, in, out); + MTXMultVec(mtx, in, out); return true; } } diff --git a/src/m/m3d/m_mdl.cpp b/src/m/m3d/m_mdl.cpp index 4d04e84c..15daf8e7 100644 --- a/src/m/m3d/m_mdl.cpp +++ b/src/m/m3d/m_mdl.cpp @@ -57,7 +57,7 @@ void mdl_c::mdlCallback_c::ExecCallbackA( tmp.x = result->rt._03; tmp.y = result->rt._13; tmp.z = result->rt._23; - PSMTXQuat(result->rt, q1); + MTXQuat(result->rt, q1); result->rt._03 = tmp.x; result->rt._13 = tmp.y; result->rt._23 = tmp.z; @@ -121,7 +121,7 @@ bool mdl_c::mdlCallback_c::create(nw4r::g3d::ResMdl mdl, mAllocator_c *alloc, u3 node->s.x = 1.0f; node->s.y = 1.0f; node->s.z = 1.0f; - PSMTXIdentity(node->rt); + MTXIdentity(node->rt); node++; } diff --git a/src/m/m3d/m_shadow.cpp b/src/m/m3d/m_shadow.cpp index 668a6669..2cb88080 100644 --- a/src/m/m3d/m_shadow.cpp +++ b/src/m/m3d/m_shadow.cpp @@ -504,7 +504,7 @@ bool mShadowChild_c::addMdl(scnLeaf_c &mdl, const mQuat_c &quat) { bool mShadowChild_c::setGeom(const GXTexObj *texObj, const mMtx_c &mtx, const mQuat_c &quat) { mQuat = quat; - PSMTXMultVec(mtx.m, mQuat.v, mQuat.v); + MTXMultVec(mtx.m, mQuat.v, mQuat.v); if (texObj == nullptr) { mTexObj = *mShadow_c::sTexObj; } else { @@ -591,7 +591,7 @@ void mShadowChild_c::draw() { GXSetTevColor(GX_TEVREG0, mShadowColor); Mtx mtx; C_MTXLightOrtho(mtx, field_0x13C, -field_0x13C, -field_0x13C, field_0x13C, 0.5f, -0.5f, 0.5f, 0.5f); - PSMTXConcat(mtx, mFrustum.mView.m, mtx); + MTXConcat(mtx, mFrustum.mView.m, mtx); GXLoadTexMtxImm(mtx, GX_TEXMTX0, GX_MTX3x4); mShadow_c::GetInstance()->draw(mFrustum.mView, field_0x154); GXSetTevSwapModeTable(GX_TEV_SWAP0, GX_CH_RED, GX_CH_GREEN, GX_CH_BLUE, GX_CH_ALPHA); @@ -628,14 +628,14 @@ void mCustomShadow_c::calc(mMtx_c mtx, mMtx_c &mtx2) const { mVec3_c trans; mtx2.copyFrom(mMtx); mVec3_c offset(0.0f, field_0x48, 0.0f); - PSMTXMultVec(mtx2, offset, trans); - PSMTXMultVec(mtx, trans, trans); + MTXMultVec(mtx2, offset, trans); + MTXMultVec(mtx, trans, trans); - PSMTXTrans(mtx2, trans.x, trans.y, trans.z); + MTXTrans(mtx2, trans.x, trans.y, trans.z); mMtx_c scaleMtx; - PSMTXScale(scaleMtx, field_0x4C, field_0x4C, field_0x4C); - PSMTXConcat(mtx2, scaleMtx, mtx2); + MTXScale(scaleMtx, field_0x4C, field_0x4C, field_0x4C); + MTXConcat(mtx2, scaleMtx, mtx2); } } // namespace m3d diff --git a/src/m/m_color_fader.cpp b/src/m/m_color_fader.cpp index ed36ceae..50b865ef 100644 --- a/src/m/m_color_fader.cpp +++ b/src/m/m_color_fader.cpp @@ -54,7 +54,7 @@ void mColorFader_c::draw() { GXSetProjection(projMtx, GX_ORTHOGRAPHIC); Mtx posMtx; - PSMTXIdentity(posMtx); + MTXIdentity(posMtx); GXLoadPosMtxImm(posMtx, 0); GXSetCurrentMtx(0); diff --git a/src/nw4r/g3d/res/g3d_resnode.cpp b/src/nw4r/g3d/res/g3d_resnode.cpp index 7788c86b..fe950682 100644 --- a/src/nw4r/g3d/res/g3d_resnode.cpp +++ b/src/nw4r/g3d/res/g3d_resnode.cpp @@ -99,7 +99,7 @@ void ResNode::CalcChrAnmResult(ChrAnmResult *pResult) const { } if (r.flags & ResNodeData::FLAG_ROT_ZERO) { - PSMTXIdentity(pResult->rt); + MTXIdentity(pResult->rt); flags |= ChrAnmResult::FLAG_ROT_ZERO; } else { pResult->rawR = math::VEC3(r.rot); diff --git a/src/nw4r/lyt/lyt_drawInfo.cpp b/src/nw4r/lyt/lyt_drawInfo.cpp index fb999a71..15ff814a 100644 --- a/src/nw4r/lyt/lyt_drawInfo.cpp +++ b/src/nw4r/lyt/lyt_drawInfo.cpp @@ -9,7 +9,7 @@ namespace lyt { // __ct__Q34nw4r3lyt8DrawInfoFv DrawInfo::DrawInfo() : mViewRect(), mScale(1.0f, 1.0f), mGlobalAlpha(1.0f) { memset(&mFlags, 0, 1); - PSMTXIdentity(mViewMtx); + MTXIdentity(mViewMtx); } // __dt__Q34nw4r3lyt8DrawInfoFv diff --git a/src/nw4r/lyt/lyt_pane.cpp b/src/nw4r/lyt/lyt_pane.cpp index 91888914..ef297901 100644 --- a/src/nw4r/lyt/lyt_pane.cpp +++ b/src/nw4r/lyt/lyt_pane.cpp @@ -277,12 +277,12 @@ void Pane::CalculateMtx(const DrawInfo &drawInfo) { this->mMtx._13 = this->mTranslate.y; this->mMtx._23 = this->mTranslate.z; if (this->mpParent) { - PSMTXConcat(this->mpParent->mGlbMtx, this->mMtx, this->mGlbMtx); + MTXConcat(this->mpParent->mGlbMtx, this->mMtx, this->mGlbMtx); } else { if (drawInfo.IsMultipleViewMtxOnDraw()) { this->mGlbMtx = this->mMtx; } else { - PSMTXConcat(drawInfo.GetViewMtx(), this->mMtx, this->mGlbMtx); + MTXConcat(drawInfo.GetViewMtx(), this->mMtx, this->mGlbMtx); } } @@ -446,7 +446,7 @@ void Pane::LoadMtx(const DrawInfo &drawInfo) { math::MTX34 mtx; math::MTX34 *mtxPtr; if (drawInfo.IsMultipleViewMtxOnDraw()) { - PSMTXConcat(drawInfo.GetViewMtx(), this->mGlbMtx, mtx); + MTXConcat(drawInfo.GetViewMtx(), this->mGlbMtx, mtx); mtxPtr = &mtx; } else { mtxPtr = &this->mGlbMtx; diff --git a/src/nw4r/lyt/lyt_textBox.cpp b/src/nw4r/lyt/lyt_textBox.cpp index 4eeb8ff9..e32801cb 100644 --- a/src/nw4r/lyt/lyt_textBox.cpp +++ b/src/nw4r/lyt/lyt_textBox.cpp @@ -434,9 +434,9 @@ void TextBox::SetFont(const ut::Font *pFont) { void TextBox::LoadMtx(const DrawInfo &drawInfo) { math::MTX34 mtx; if (drawInfo.IsMultipleViewMtxOnDraw()) { - PSMTXConcat(drawInfo.GetViewMtx(), mGlbMtx, mtx); + MTXConcat(drawInfo.GetViewMtx(), mGlbMtx, mtx); } else { - PSMTXCopy(mGlbMtx, mtx); + MTXCopy(mGlbMtx, mtx); } ReverseYAxis(&mtx); diff --git a/src/nw4r/lyt/lyt_util.cpp b/src/nw4r/lyt/lyt_util.cpp index 7db782e9..ef86f45b 100644 --- a/src/nw4r/lyt/lyt_util.cpp +++ b/src/nw4r/lyt/lyt_util.cpp @@ -43,9 +43,9 @@ void SetAnimationEnable(Group *pGroup, nw4r::lyt::AnimTransform *pAnimTrans, boo // IsContain__Q24nw4r3lytFPQ34nw4r3lyt4PaneRCQ34nw4r4math4VEC2 bool IsContain(Pane *pPane, const math::VEC2 &pos) { math::MTX34 invGlbMtx; - PSMTXInverse(pPane->GetGlobalMtx(), invGlbMtx); + MTXInverse(pPane->GetGlobalMtx(), invGlbMtx); math::VEC3 lclPos; - PSMTXMultVec(invGlbMtx, math::VEC3(pos.x, pos.y, 0.0f), lclPos); + MTXMultVec(invGlbMtx, math::VEC3(pos.x, pos.y, 0.0f), lclPos); return Contains(pPane->GetPaneRect(), math::VEC2(lclPos.x, lclPos.y)); } diff --git a/src/toBeSorted/attention.cpp b/src/toBeSorted/attention.cpp index 28f5290a..da5a253a 100644 --- a/src/toBeSorted/attention.cpp +++ b/src/toBeSorted/attention.cpp @@ -250,7 +250,7 @@ bool AttentionManager::playTargetAnim(s32 idx) { dAcObjBase_c *actor = pool->getActor(mModels.mCurrentTargetInfoIdx); mMtx_c mtx; mVec3_c v = pool->mInfos[mModels.mCurrentTargetInfoIdx].field_0x08; - PSMTXTrans(mtx, v.x, v.y, v.z); + MTXTrans(mtx, v.x, v.y, v.z); mModels.mMdls->mMdl.setLocalMtx(mtx); mModels.mMdls->mMdl.setScale(sHio.field_0x14, sHio.field_0x14, sHio.field_0x14); diff --git a/src/toBeSorted/d_emitter.cpp b/src/toBeSorted/d_emitter.cpp index 10e25851..1562a595 100644 --- a/src/toBeSorted/d_emitter.cpp +++ b/src/toBeSorted/d_emitter.cpp @@ -117,7 +117,6 @@ dEmitterBase_c::~dEmitterBase_c() { } JPABaseEmitter *dEmitterBase_c::GetNextEmitter(JPABaseEmitter *head) { - // Portability hazard: u32->pointer cast return reinterpret_cast(head->getUserWork()); } @@ -134,8 +133,7 @@ bool dEmitterBase_c::createEmitters( ); if (last != nullptr) { if (head != nullptr) { - // Portability hazard: pointer->u32 cast - head->setUserWork(reinterpret_cast(last)); + head->setUserWork(reinterpret_cast(last)); } else { mpEmitterHead = last; } diff --git a/src/toBeSorted/dowsing_target.cpp b/src/toBeSorted/dowsing_target.cpp index 35311efb..fa71ee12 100644 --- a/src/toBeSorted/dowsing_target.cpp +++ b/src/toBeSorted/dowsing_target.cpp @@ -50,11 +50,11 @@ void DowsingTarget::reinitialize(DowsingSlot type) { void DowsingTarget::getPosition(mVec3_c &position) { mMtx_c mtx; mMtx_c mtx2; - PSMTXTrans(mtx.m, mpActor->mPosition.x, mpActor->mPosition.y, mpActor->mPosition.z); + MTXTrans(mtx.m, mpActor->mPosition.x, mpActor->mPosition.y, mpActor->mPosition.z); mtx.YrotM(mpActor->mRotation.y); - PSMTXScale(mtx2.m, mpActor->mScale.x, mpActor->mScale.y, mpActor->mScale.z); - PSMTXConcat(mtx.m, mtx2.m, mtx.m); - PSMTXMultVec(mtx.m, mOffset, position); + MTXScale(mtx2.m, mpActor->mScale.x, mpActor->mScale.y, mpActor->mScale.z); + MTXConcat(mtx.m, mtx2.m, mtx.m); + MTXMultVec(mtx.m, mOffset, position); } bool DowsingTarget::hasZeldaDowsing() {