Merge pull request #313 from robojumper/vec-mtx-cleanup

Cleanup

105 files changed, 1096 insertions, 1512 deletions

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); }
-
-    GXBool getZEnable() const { return (GXBool)(mpData->mZModeCfg & 0x01); }
-    GXCompare getZCmp() const { return st_c[(mpData->mZModeCfg >> 1) & 0x07]; }
-    GXBool getZUpd() const { return (GXBool)((mpData->mZModeCfg >> 4) & 0x01); }
-
-    GXCompare getAlphaCmp0() const { return st_c[mpData->mAlphaCompareCfg & 0x07]; }
-    u8 getAlphaRef0() const { return mpData->mAlphaRef0; }
-    GXAlphaOp getAlphaOp() const { return st_ao[(mpData->mAlphaCompareCfg >> 3) & 0x03]; }
-    GXCompare getAlphaCmp1() const { return st_c[(mpData->mAlphaCompareCfg >> 5) & 0x07]; }
-    u8 getAlphaRef1() const { return mpData->mAlphaRef1; }
-
-    const GXTevColorArg* getTevColorArg() const { return st_ca[(mpData->mFlags >> 0x0F) & 0x07]; }
-    const JPABaseShapeAlphaArg* getTevAlphaArg() const { return &st_aa[(mpData->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
-
-    BOOL isPrmAnm() const { return mpData->mClrFlg & 0x02; }
-    BOOL isEnvAnm() const { return mpData->mClrFlg & 0x08; }
-    u8 getClrAnmType() const { return (mpData->mClrFlg >> 4) & 0x07; }
-    s16 getClrAnmMaxFrm() const { return mpData->mClrAnmFrmMax; }
-    void getPrmClr(GXColor* dst) { *dst = mpData->mClrPrm; }
-    void getPrmClr(s16 idx, GXColor* dst) { *dst = mpPrmClrAnmTbl[idx]; }
-    void getEnvClr(GXColor* dst) { *dst = mpData->mClrEnv; }
-    void getEnvClr(s16 idx, GXColor* dst) { *dst = mpEnvClrAnmTbl[idx]; }
-
-    BOOL isTexAnm() const { return mpData->mTexFlg & 0x01; }
-    u8 getTexAnmType() const { return (mpData->mTexFlg >> 2) & 0x07; }
-    u32 getTexIdx() const { return mpData->mTexIdx; }
+    GXBlendMode getBlendMode() const { return st_bm[pBsd->mBlendModeCfg & 0x03]; }
+    GXBlendFactor getBlendSrc() const { return st_bf[(pBsd->mBlendModeCfg >> 2) & 0x0F]; }
+    GXBlendFactor getBlendDst() const { return st_bf[(pBsd->mBlendModeCfg >> 6) & 0x0F]; }
+    GXLogicOp getLogicOp() const { return st_lo[(pBsd->mBlendModeCfg >> 10) & 0x0F]; }
+    GXBool getZCompLoc() const { return (GXBool)((pBsd->mZModeCfg >> 5) & 0x01); }
+
+    GXBool getZEnable() const { return (GXBool)(pBsd->mZModeCfg & 0x01); }
+    GXCompare getZCmp() const { return st_c[(pBsd->mZModeCfg >> 1) & 0x07]; }
+    GXBool getZUpd() const { return (GXBool)((pBsd->mZModeCfg >> 4) & 0x01); }
+
+    GXCompare getAlphaCmp0() const { return st_c[pBsd->mAlphaCompareCfg & 0x07]; }
+    u8 getAlphaRef0() const { return pBsd->mAlphaRef0; }
+    GXAlphaOp getAlphaOp() const { return st_ao[(pBsd->mAlphaCompareCfg >> 3) & 0x03]; }
+    GXCompare getAlphaCmp1() const { return st_c[(pBsd->mAlphaCompareCfg >> 5) & 0x07]; }
+    u8 getAlphaRef1() const { return pBsd->mAlphaRef1; }
+
+    const GXTevColorArg* getTevColorArg() const { return st_ca[(pBsd->mFlags >> 0x0F) & 0x07]; }
+    const JPABaseShapeAlphaArg* getTevAlphaArg() const { return &st_aa[(pBsd->mFlags >> 0x12) & 0x07]; }
+
+    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 pBsd->mClrFlg & 0x02; }
+    BOOL isEnvAnm() const { return pBsd->mClrFlg & 0x08; }
+    u32 getClrAnmType() const { return (pBsd->mClrFlg >> 4) & 0x07; }
+    s16 getClrAnmMaxFrm() const { return pBsd->mClrAnmFrmMax; }
+    void getPrmClr(GXColor* dst) const { *dst = pBsd->mClrPrm; }
+    void getPrmClr(s16 idx, GXColor* dst) const { *dst = mpPrmClrAnmTbl[idx]; }
+    void getEnvClr(GXColor* dst) const { *dst = pBsd->mClrEnv; }
+    void getEnvClr(s16 idx, GXColor* dst) const { *dst = mpEnvClrAnmTbl[idx]; }
+
+    BOOL isTexAnm() const { return pBsd->mTexFlg & 0x01; }
+    u32 getTexAnmType() const { return (pBsd->mTexFlg >> 2) & 0x07; }
+    u8 getTexIdx() const { return pBsd->mTexIdx; }
     u8 getTexIdx(u8 idx) const { return mpTexIdxAnimTbl[idx]; }
 
-    f32 getBaseSizeX() const { return mpData->mBaseSizeX; }
-    f32 getBaseSizeY() const { return mpData->mBaseSizeY; }
-    u8 getClrLoopOfstMask() const { return mpData->mClrAnmRndmMask; }
-    u32 getClrLoopOfst(u32 param_1) const { return getClrLoopOfstMask() & param_1; }
-    u8 getTexLoopOfstMask() const { return mpData->mTexAnmRndmMask; }
-    u32 getTexLoopOfst(u8 param_1) const { return getTexLoopOfstMask() & param_1; }
-    u8 getLoopOfstValue() const { return mpData->mAnmRndm; }
+    f32 getBaseSizeX() const { return pBsd->mBaseSizeX; }
+    f32 getBaseSizeY() const { return pBsd->mBaseSizeY; }
+    u8 getClrLoopOfstMask() const { return pBsd->mClrAnmRndmMask; }
+    s32 getClrLoopOfst(u8 param_1) const { return getClrLoopOfstMask() & param_1; }
+    u8 getTexLoopOfstMask() const { return pBsd->mTexAnmRndmMask; }
+    s32 getTexLoopOfst(u8 param_1) const { return getTexLoopOfstMask() & param_1; }
+    u8 getLoopOfstValue() const { return pBsd->mAnmRndm; }
 
     f32 getIncTransX() const { return ((f32*)mpTexCrdMtxAnmTbl)[5]; }
     f32 getInitTransX() const { return ((f32*)mpTexCrdMtxAnmTbl)[0]; }
@@ -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<JPABaseParticle> mAlivePtclChld;
     /* 0xE0 */ JPAList<JPABaseParticle>* mpPtclPool;
     /* 0xE4 */ JPAEmitterManager* mpEmtrMgr;
-    /* 0xE8 */ JPAResource* mpRes;
+    /* 0xE8 */ JPAResource* pRes;
     /* 0xEC */ JPAEmitterCallBack* mpEmtrCallBack;
     /* 0xF0 */ JPAParticleCallBack* mpPtclCallBack;
     /* 0xF4 */ u32 mStatus;
diff --git a/include/JSystem/JParticle/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<JPABaseEmitter>* 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<T>* getPrev() { return mpPrev; }
-    JPANode<T>* getNext() { return mpNext; }
+    JPANode<T>* getPrev() const { return mpPrev; }
+    JPANode<T>* getNext() const { return mpNext; }
     T* getObject() { return &mData; }
 
     /* 0x00 */ JPANode<T>* mpPrev;
@@ -48,8 +48,7 @@ struct JPAList {
         } else {
             mpLast = node;
             mpFirst = node;
-            node->mpPrev = NULL;
-            node->mpNext = NULL;
+            node->mpNext = node->mpPrev = NULL;
         }
 
         mNum++;
@@ -75,8 +74,7 @@ struct JPAList {
 
         if (mNum == 1) {
             ret = mpFirst;
-            mpLast = NULL;
-            mpFirst = NULL;
+            mpFirst = mpLast = NULL;
             mNum--;
         } else if (mNum) {
             ret = mpFirst;
@@ -93,8 +91,7 @@ struct JPAList {
 
         if (mNum == 1) {
             ret = mpLast;
-            mpLast = NULL;
-            mpFirst = NULL;
+            mpFirst = mpLast = NULL;
             mNum--;
         } else if (mNum) {
             ret = mpLast;
@@ -120,8 +117,7 @@ struct JPAList {
             mpLast = node->mpPrev;
             mNum--;
         } else {
-            mpLast = NULL;
-            mpFirst = NULL;
+            mpFirst = mpLast = NULL;
             mNum--;
         }
         return node;
diff --git a/include/JSystem/JParticle/JPAParticle.h b/include/JSystem/JParticle/JPAParticle.h
index 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<f32>::sqrt(PSVECSquareDistance(*this, to));
+        return EGG::Math<f32>::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<f> */
 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<f> */
 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<f> */
 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<f> */
 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<f> */
 void dirTypePrevPtcl(JPAEmitterWorkData const* work, JPABaseParticle const* param_1,
                     EGG::Vector3f* param_2) {
     EGG::Vector3f aTStack_24;
-    param_1->getGlobalPosition(aTStack_24);
-    JPANode<JPABaseParticle>* end = work->mpAlivePtcl->getEnd();
-    JPANode<JPABaseParticle>* prev = work->mpCurNode->getPrev();
-    
-    if (end != prev) {
-        JPABaseParticle* particle = work->mpCurNode->getPrev()->getObject();
-        particle->getGlobalPosition(*param_2);
+    param_1->getGlobalPosition(&aTStack_24);
+
+    if (work->mpCurNode->getPrev() != work->mpAlivePtcl->getEnd()) {
+        work->mpCurNode->getPrev()->getObject()->getGlobalPosition(param_2);
     } else {
         work->mpEmtr->calcEmitterGlobalPosition(param_2);
     }
     *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));
-            }
-        }
+    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));
 }
 
-/* 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));
-            }
-        }
+    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));
 }
 
-/* 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));
-        }
+    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));
 }
 
-/* 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));
+    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));
 }
 
-/* 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 (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<JPABaseParticle>* getNext(JPANode<JPABaseParticle>* param_0) {
     return param_0->getNext();
 }
 
-/* 8027936C-80279374 273CAC 0008+00 2/2 0/0 0/0 .text getPrev__FP26JPANode<15JPABaseParticle> */
 JPANode<JPABaseParticle>* getPrev(JPANode<JPABaseParticle>* 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<JPABaseParticle>* startNode;
+    JPANode<JPABaseParticle>* 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<JPABaseParticle>* startNode;
-    getNodeFunc node_func;
+    JPANode<JPABaseParticle>* 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<JPABaseParticle>* node = mpPtclPool->pop_front();
         mAlivePtclBase.push_front(node);
-        mpRes->getDyn()->calc(mpEmtrMgr->pWd);
-        node->mData.init_p(mpEmtrMgr->pWd);
-        return &node->mData;
+        pRes->getDyn()->calc(mpEmtrMgr->pWd);
+        node->getObject()->init_p(mpEmtrMgr->pWd);
+        return node->getObject();
+    } else {
+        JUT_WARN(128, "%s", "JPA : Can NOT create particle more\n");
     }
 
     return NULL;
 }
 
-/* 8027EB60-8027EC60 2794A0 0100+00 0/0 1/1 0/0 .text
- * createChild__14JPABaseEmitterFP15JPABaseParticle             */
 JPABaseParticle* JPABaseEmitter::createChild(JPABaseParticle* parent) {
     if (mpPtclPool->getNum() != 0) {
         JPANode<JPABaseParticle>* node = mpPtclPool->pop_front();
         mAlivePtclChld.push_front(node);
-        node->mData.init_c(mpEmtrMgr->pWd, parent);
-        return &node->mData;
+        node->getObject()->init_c(mpEmtrMgr->pWd, parent);
+        return node->getObject();
+    } else {
+        JUT_WARN(151, "%s", "JPA : Can NOT create child particle more\n")
     }
 
     return NULL;
 }
 
-/* 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<f> */
 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__17JPAEmitterManagerFRCQ29JGeometry8TVec3<f>UsUcUcP18JPAEmitterCallBackP19JPAParticleCallBack
- */
 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<JPABaseEmitter>* 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<const float*>(&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__FRCQ29JGeometry8TVec3<f>PA4_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<f>    */
-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_fPQ29JGeometry8TVec3<f>PQ29JGeometry8TVec3<f> */
-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<JPABaseParticle>* node = emtr->mAlivePtclBase.getFirst();
-        JPANode<JPABaseParticle>* next;
-        while (node != emtr->mAlivePtclBase.getEnd()) {
+        JPANode<JPABaseParticle>* next = NULL;
+        for (JPANode<JPABaseParticle>* node = emtr->mAlivePtclBase.getFirst(); node != emtr->mAlivePtclBase.getEnd(); node = next) {
             next = node->getNext();
             if (node->getObject()->calc_p(work)) {
                 emtr->mpPtclPool->push_front(emtr->mAlivePtclBase.erase(node));
             }
-            node = next;
         }
 
-        node = emtr->mAlivePtclChld.getFirst();
-        while (node != emtr->mAlivePtclChld.getEnd()) {
+        for (JPANode<JPABaseParticle>* node = emtr->mAlivePtclChld.getFirst(); node != emtr->mAlivePtclChld.getEnd(); node = next) {
             next = node->getNext();
             if (node->getObject()->calc_c(work)) {
                 emtr->mpPtclPool->push_front(emtr->mAlivePtclChld.erase(node));
             }
-            node = next;
         }
 
         emtr->mTick++;
@@ -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<JPABaseParticle>* 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<JPABaseParticle>* 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 <cstring>
 
 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<dAcItem_c *>(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<f32>::sqrt(PSVECSquareDistance(mPosition, dAcPy_c::LINK->mPosition));
+    return EGG::Math<f32>::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 &param0, 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 &param0, 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 &param0, 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 &center) 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<f32>::zero() ? Math<f32>::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<math::MTX34 *>(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<JPABaseEmitter *>(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<u32>(last));
+                head->setUserWork(reinterpret_cast<uintptr_t>(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() {