JParticle

10 files changed, 1068 insertions, 467 deletions

diff --git a/configure.py b/configure.py
index 9be2d776..3135b07f 100644
--- a/configure.py
+++ b/configure.py
@@ -576,7 +576,7 @@ config.libs = [
             Object(NonMatching, "JSystem/JParticle/JPAEmitterManager.cpp"),
             Object(NonMatching, "JSystem/JParticle/JPADrawVisitor.cpp"),
             Object(NonMatching, "JSystem/JParticle/JPADraw.cpp"),
-            Object(NonMatching, "JSystem/JParticle/JPADrawSetupTev.cpp"),
+            Object(Matching,    "JSystem/JParticle/JPADrawSetupTev.cpp"),
         ],
     ),
     JSystemLib(
diff --git a/include/JSystem/JParticle/JPABaseShape.h b/include/JSystem/JParticle/JPABaseShape.h
index 4683e2d0..738c2cfc 100644
--- a/include/JSystem/JParticle/JPABaseShape.h
+++ b/include/JSystem/JParticle/JPABaseShape.h
@@ -52,12 +52,12 @@ public:
     virtual GXAlphaOp getAlphaCmpOp() = 0;
     virtual u8 getAlphaCmpRef0() = 0;
     virtual u8 getAlphaCmpRef1() = 0;
-    virtual BOOL isEnableAnmTone() = 0;
-    virtual BOOL isEnableProjection() = 0;
+    virtual u32 isEnableAnmTone() = 0;
+    virtual u32 isEnableProjection() = 0;
     virtual BOOL isClipOn() = 0;
     virtual BOOL isEnableTextureAnm() = 0;
     virtual BOOL textureIsEmpty() = 0;
-    virtual u32 getTextureAnmType() = 0;
+    virtual u8 getTextureAnmType() = 0;
     virtual u8 getTextureAnmKeyNum() = 0;
     virtual u8 getTextureIndex() = 0;
     virtual u8 getTextureIndex(u8 idx) = 0;
@@ -69,9 +69,9 @@ public:
     virtual GXColor getEnvColor() = 0;
     virtual GXColor getPrmColor(s16) = 0;
     virtual GXColor getEnvColor(s16) = 0;
-    virtual u32 getColorRegAnmType() = 0;
+    virtual u8 getColorRegAnmType() = 0;
     virtual u32 getColorRegAnmMaxFrm() = 0;
-    virtual BOOL isEnableTexScrollAnm() = 0;
+    virtual u32 isEnableTexScrollAnm() = 0;
     virtual f32 getTilingX() = 0;
     virtual f32 getTilingY() = 0;
     virtual f32 getTexStaticTransX() = 0;
@@ -160,12 +160,12 @@ public:
     virtual GXAlphaOp getAlphaCmpOp() { return stAlphaOp[(pBsd->mAlphaFlags >> 3) & 0x03]; }
     virtual u8 getAlphaCmpRef0() { return pBsd->mAlphaCmpRef0; }
     virtual u8 getAlphaCmpRef1() { return pBsd->mAlphaCmpRef1; }
-    virtual BOOL isEnableAnmTone() { return pBsd->mFlags & 0x80000; }
-    virtual BOOL isEnableProjection() { return pBsd->mFlags & 0x100000; }
+    virtual u32 isEnableAnmTone() { return pBsd->mFlags & 0x80000; }
+    virtual u32 isEnableProjection() { return pBsd->mFlags & 0x100000; }
     virtual BOOL isClipOn() { return pBsd->mFlags & 0x800000; }
     virtual BOOL isEnableTextureAnm() { return pBsd->mTextureFlags & 0x01; }
     virtual BOOL textureIsEmpty() { return !(pBsd->mTextureFlags & 0x02); }
-    virtual u32 getTextureAnmType() { return (pBsd->mTextureFlags >> 2) & 0x07; }
+    virtual u8 getTextureAnmType() { return (pBsd->mTextureFlags >> 2) & 0x07; }
     virtual u8 getTextureAnmKeyNum() { return pBsd->mTextureAnmKeyNum; }
     virtual u8 getTextureIndex() { return pBsd->mTextureIndex; }
     virtual u8 getTextureIndex(u8 idx) { return mpTexAnmIdxArr[idx]; }
@@ -177,9 +177,9 @@ public:
     virtual GXColor getEnvColor() { return pBsd->mEnvColor; }
     virtual GXColor getPrmColor(s16 idx) { return mpPrmColorArr[idx]; }
     virtual GXColor getEnvColor(s16 idx) { return mpEnvColorArr[idx]; }
-    virtual u32 getColorRegAnmType() { return (pBsd->mColorFlags >> 4) & 0x07; }
+    virtual u8 getColorRegAnmType() { return (pBsd->mColorFlags >> 4) & 0x07; }
     virtual u32 getColorRegAnmMaxFrm() { return pBsd->mColorRegAnmMaxFrm; }
-    virtual BOOL isEnableTexScrollAnm() { return pBsd->mFlags & 0x1000000; }
+    virtual u32 isEnableTexScrollAnm() { return pBsd->mFlags & 0x1000000; }
     virtual f32 getTilingX() { return pBsd->mTilingX; }
     virtual f32 getTilingY() { return pBsd->mTilingY; }
     virtual f32 getTexStaticTransX() { return pBsd->mTexStaticTransX; }
diff --git a/include/JSystem/JParticle/JPADraw.h b/include/JSystem/JParticle/JPADraw.h
index aa3e4956..267de7a6 100644
--- a/include/JSystem/JParticle/JPADraw.h
+++ b/include/JSystem/JParticle/JPADraw.h
@@ -1,50 +1,54 @@
 #ifndef JPADRAW_H
 #define JPADRAW_H
 
-#include "dolphin/types.h"
+#include "JSystem/JGeometry.h"
+#include "JSystem/JParticle/JPADrawVisitor.h"
+#include "JSystem/JParticle/JPADrawSetupTev.h"
 #include "dolphin/gx/GXStruct.h"
 #include "dolphin/gx/GXEnum.h"
 #include "dolphin/mtx/mtx.h"
+#include "global.h"
 
-class JPABaseShape;
-class JPAExtraShape;
-class JPASweepShape;
-class JPAExTexShape;
-class JPATextureResource;
-class JPABaseEmitter;
-class JPABaseParticle;
-struct JSUPtrList;
-
-class JPADraw;
-class JPADrawExecEmitterVisitor;
-class JPADrawExecParticleVisitor;
-class JPADrawClipBoard;
-class JPADrawVisitorContainer;
-
-class JPADrawContext {
+class JPADrawClipBoard {
 public:
-    /* 0x00 */ JPABaseEmitter* pbe;
-    /* 0x04 */ JPABaseShape* pbsp;
-    /* 0x08 */ JPAExtraShape* pesp;
-    /* 0x0C */ JPASweepShape* pssp;
-    /* 0x10 */ JPAExTexShape* petx;
-    /* 0x14 */ JPADraw* mpDraw;
-    /* 0x18 */ JSUPtrList* mpActiveParticles;
-    /* 0x1C */ JPATextureResource* mpTextureResource;
-    /* 0x20 */ u16* pTexIdx;
+    JPADrawClipBoard() {}
+    ~JPADrawClipBoard() {}
 
-    static JPADrawClipBoard* pcb;
+    JPADrawSetupTev field_0x0;
+    f32 field_0x4;
+    f32 field_0x8;
+    f32 field_0xc;
+    f32 field_0x10;
+    JGeometry::TVec2<f32> field_0x14[4];
+    MtxP field_0x34;
+    f32 field_0x38;
+    f32 field_0x3c;
+    f32 field_0x40;
+    f32 field_0x44;
+    f32 field_0x48;
+    f32 field_0x4c;
+    f32 field_0x50;
+    f32 field_0x54;
+    f32 field_0x58;
+    f32 field_0x5c;
+    f32 field_0x60;
+    f32 field_0x64;
+    Mtx field_0x68;
+    GXColor field_0x98;
+    GXColor field_0x9c;
+    void* field_0xa0;
+    u8 field_0xa4[0xb4 - 0xa4];
 };
 
 class JPADraw {
 public:
     struct JPADrawVisitorDefFlags {
-        /* 0x00 */ u32 mbIsEnableDrawParent;
-        /* 0x04 */ u32 mbHasPrmAnm;
-        /* 0x08 */ u32 mbHasEnvAnm;
-        /* 0x0C */ u32 mbIsStripe;
-        /* 0x10 */ u32 mbIsPointOrLine;
-        /* 0x04 */ u32 mbIsEnableAlpha;
+        /* 0x00 */ BOOL mbIsEnableDrawParent;
+        /* 0x04 */ BOOL mbHasPrmAnm;
+        /* 0x08 */ BOOL mbHasEnvAnm;
+        /* 0x0C */ BOOL mbIsStripe;
+        /* 0x10 */ BOOL mbIsPointOrLine;
+        /* 0x14 */ BOOL mbIsEnableAlpha;
     };
 
     bool initialize(JPABaseEmitter*, JPATextureResource*);
@@ -73,11 +77,11 @@ public:
     /* 0x00 */ JPADrawExecEmitterVisitor* mpExecEmtrVis[1];
     /* 0x04 */ JPADrawExecEmitterVisitor* mpExecEmtrPVis[5];
     /* 0x18 */ JPADrawExecEmitterVisitor* mpExecEmtrCVis[3];
-    /* 0x24 */ JPADrawExecParticleVisitor* mpCalcEmtrVis[4];
+    /* 0x24 */ JPADrawCalcEmitterVisitor* mpCalcEmtrVis[4];
     /* 0x34 */ JPADrawExecParticleVisitor* mpExecPtclVis[5];
-    /* 0x48 */ JPADrawExecParticleVisitor* mpCalcPtclVis[10];
+    /* 0x48 */ JPADrawCalcParticleVisitor* mpCalcPtclVis[10];
     /* 0x70 */ JPADrawExecParticleVisitor* mpExecChldVis[4];
-    /* 0x80 */ JPADrawExecParticleVisitor* mpCalcChldVis[2];
+    /* 0x80 */ JPADrawCalcParticleVisitor* mpCalcChldVis[2];
     /* 0x88 */ u8 execEmtrVisNum;
     /* 0x89 */ u8 execEmtrPVisNum;
     /* 0x8A */ u8 execEmtrCVisNum;
diff --git a/include/JSystem/JParticle/JPADrawSetupTev.h b/include/JSystem/JParticle/JPADrawSetupTev.h
new file mode 100644
index 00000000..0294ce26
--- /dev/null
+++ b/include/JSystem/JParticle/JPADrawSetupTev.h
@@ -0,0 +1,18 @@
+#ifndef JPADRAWSETUPTEV_H
+#define JPADRAWSETUPTEV_H
+
+#include "dolphin/types.h"
+
+class JPABaseShape;
+class JPAExTexShape;
+
+class JPADrawSetupTev {
+public:
+    void setupTev(JPABaseShape* param_1, JPAExTexShape* param_2);
+
+    u8 field_0x0;
+    u8 field_0x1;
+    u8 field_0x2;
+};
+
+#endif /* JPADRAWSETUPTEV_H */
diff --git a/include/JSystem/JParticle/JPADrawVisitor.h b/include/JSystem/JParticle/JPADrawVisitor.h
new file mode 100644
index 00000000..dcb4b044
--- /dev/null
+++ b/include/JSystem/JParticle/JPADrawVisitor.h
@@ -0,0 +1,523 @@
+#ifndef JPADRAWVISITOR_H
+#define JPADRAWVISITOR_H
+
+#include "JSystem/JSupport/JSUList.h"
+#include "dolphin/types.h"
+
+class JPABaseEmitter;
+class JPABaseParticle;
+class JPABaseShape;
+class JPAExTexShape;
+class JPAExtraShape;
+class JPASweepShape;
+class JPADraw;
+class JPADrawClipBoard;
+class JPATextureResource;
+
+class JPADrawContext {
+public:
+    /* 0x00 */ JPABaseEmitter* pbe;
+    /* 0x04 */ JPABaseShape* pbsp;
+    /* 0x08 */ JPAExtraShape* pesp;
+    /* 0x0C */ JPASweepShape* pssp;
+    /* 0x10 */ JPAExTexShape* petx;
+    /* 0x14 */ JPADraw* mpDraw;
+    /* 0x18 */ JSUList<JPABaseParticle>* mpActiveParticles;
+    /* 0x1C */ JPATextureResource* mpTextureResource;
+    /* 0x20 */ u16* pTexIdx;
+
+    static JPADrawClipBoard* pcb;
+};
+
+class JPADrawExecEmitterVisitor {
+public:
+    virtual ~JPADrawExecEmitterVisitor() {}
+    virtual void exec(const JPADrawContext* pDC) = 0;
+};
+
+class JPADrawExecParticleVisitor {
+public:
+    virtual ~JPADrawExecParticleVisitor() {}
+    virtual void exec(const JPADrawContext* pDC, JPABaseParticle* param_2) = 0;
+};
+
+class JPADrawExecGenPrjMtx : public JPADrawExecEmitterVisitor {
+public:
+    virtual ~JPADrawExecGenPrjMtx() {}
+    virtual void exec(const JPADrawContext* pDC);
+};
+
+class JPADrawExecGenPrjTexMtx : public JPADrawExecEmitterVisitor {
+public:
+    virtual ~JPADrawExecGenPrjTexMtx() {}
+    virtual void exec(const JPADrawContext* pDC);
+};
+
+class JPADrawExecGenTexMtx0 : public JPADrawExecEmitterVisitor {
+public:
+    virtual ~JPADrawExecGenTexMtx0() {}
+    virtual void exec(const JPADrawContext* pDC);
+};
+
+class JPADrawExecGenIdtMtx : public JPADrawExecEmitterVisitor {
+public:
+    virtual ~JPADrawExecGenIdtMtx() {}
+    virtual void exec(const JPADrawContext* pDC);
+};
+
+class JPADrawExecSetTexMtx : public JPADrawExecEmitterVisitor, public JPADrawExecParticleVisitor {
+public:
+    virtual ~JPADrawExecSetTexMtx() {}
+    virtual void exec(const JPADrawContext* pDC, JPABaseParticle* param_2);
+    virtual void exec(const JPADrawContext* pDC);
+};
+
+class JPADrawExecSetPointSize : public JPADrawExecParticleVisitor {
+public:
+    virtual ~JPADrawExecSetPointSize() {}
+    virtual void exec(const JPADrawContext* pDC, JPABaseParticle* param_2);
+};
+
+class JPADrawExecSetLineWidth : public JPADrawExecParticleVisitor {
+public:
+    virtual ~JPADrawExecSetLineWidth() {}
+    virtual void exec(const JPADrawContext* pDC, JPABaseParticle* param_2);
+};
+
+class JPADrawExecRegisterColorEmitterPE : public JPADrawExecEmitterVisitor {
+public:
+    virtual ~JPADrawExecRegisterColorEmitterPE() {}
+    virtual void exec(const JPADrawContext* pDC);
+};
+
+class JPADrawExecRegisterColorEmitterP : public JPADrawExecEmitterVisitor {
+public:
+    virtual ~JPADrawExecRegisterColorEmitterP() {}
+    virtual void exec(const JPADrawContext* pDC);
+};
+
+class JPADrawExecRegisterColorEmitterE : public JPADrawExecEmitterVisitor {
+public:
+    virtual ~JPADrawExecRegisterColorEmitterE() {}
+    virtual void exec(const JPADrawContext* pDC);
+};
+
+class JPADrawExecRegisterColorChildPE : public JPADrawExecEmitterVisitor {
+public:
+    virtual ~JPADrawExecRegisterColorChildPE() {}
+    virtual void exec(const JPADrawContext* pDC);
+};
+
+class JPADrawExecRegisterPrmColorAnm : public JPADrawExecParticleVisitor {
+public:
+    virtual ~JPADrawExecRegisterPrmColorAnm() {}
+    virtual void exec(const JPADrawContext* pDC, JPABaseParticle* param_2);
+};
+
+class JPADrawExecRegisterPrmAlphaAnm : public JPADrawExecParticleVisitor {
+public:
+    virtual ~JPADrawExecRegisterPrmAlphaAnm() {}
+    virtual void exec(const JPADrawContext* pDC, JPABaseParticle* param_2);
+};
+
+class JPADrawExecRegisterEnvColorAnm : public JPADrawExecParticleVisitor {
+public:
+    virtual ~JPADrawExecRegisterEnvColorAnm() {}
+    virtual void exec(const JPADrawContext* pDC, JPABaseParticle* param_2);
+};
+
+class JPADrawExecRegisterPrmCEnv : public JPADrawExecParticleVisitor {
+public:
+    virtual ~JPADrawExecRegisterPrmCEnv() {}
+    virtual void exec(const JPADrawContext* pDC, JPABaseParticle* param_2);
+};
+
+class JPADrawExecRegisterPrmAEnv : public JPADrawExecParticleVisitor {
+public:
+    virtual ~JPADrawExecRegisterPrmAEnv() {}
+    virtual void exec(const JPADrawContext* pDC, JPABaseParticle* param_2);
+};
+
+class JPADrawExecLoadDefaultTexture : public JPADrawExecEmitterVisitor {
+public:
+    virtual ~JPADrawExecLoadDefaultTexture() {}
+    virtual void exec(const JPADrawContext* pDC);
+};
+
+class JPADrawExecLoadTexture : public JPADrawExecEmitterVisitor, public JPADrawExecParticleVisitor {
+public:
+    virtual ~JPADrawExecLoadTexture() {}
+    virtual void exec(const JPADrawContext* pDC, JPABaseParticle* param_2);
+    virtual void exec(const JPADrawContext* pDC);
+};
+
+class JPADrawExecLoadExTex : public JPADrawExecEmitterVisitor {
+public:
+    virtual ~JPADrawExecLoadExTex() {}
+    virtual void exec(const JPADrawContext* pDC);
+};
+
+class JPADrawExecBillBoard : public JPADrawExecParticleVisitor {
+public:
+    virtual ~JPADrawExecBillBoard() {}
+    virtual void exec(const JPADrawContext* pDC, JPABaseParticle* param_2);
+};
+
+class JPADrawExecRotBillBoard : public JPADrawExecParticleVisitor {
+public:
+    virtual ~JPADrawExecRotBillBoard() {}
+    virtual void exec(const JPADrawContext* pDC, JPABaseParticle* param_2);
+};
+
+class JPADrawExecYBillBoard : public JPADrawExecParticleVisitor {
+public:
+    virtual ~JPADrawExecYBillBoard() {}
+    virtual void exec(const JPADrawContext* pDC, JPABaseParticle* param_2);
+};
+
+class JPADrawExecRotYBillBoard : public JPADrawExecParticleVisitor {
+public:
+    virtual ~JPADrawExecRotYBillBoard() {}
+    virtual void exec(const JPADrawContext* pDC, JPABaseParticle* param_2);
+};
+
+class JPADrawExecDirectional : public JPADrawExecParticleVisitor {
+public:
+    virtual ~JPADrawExecDirectional() {}
+    virtual void exec(const JPADrawContext* pDC, JPABaseParticle* param_2);
+};
+
+class JPADrawExecRotDirectional : public JPADrawExecParticleVisitor {
+public:
+    virtual ~JPADrawExecRotDirectional() {}
+    virtual void exec(const JPADrawContext* pDC, JPABaseParticle* param_2);
+};
+
+class JPADrawExecDirectionalCross : public JPADrawExecParticleVisitor {
+public:
+    virtual ~JPADrawExecDirectionalCross() {}
+    virtual void exec(const JPADrawContext* pDC, JPABaseParticle* param_2);
+};
+
+class JPADrawExecRotDirectionalCross : public JPADrawExecParticleVisitor {
+public:
+    virtual ~JPADrawExecRotDirectionalCross() {}
+    virtual void exec(const JPADrawContext* pDC, JPABaseParticle* param_2);
+};
+
+class JPADrawExecDirBillBoard : public JPADrawExecParticleVisitor {
+public:
+    virtual ~JPADrawExecDirBillBoard() {}
+    virtual void exec(const JPADrawContext* pDC, JPABaseParticle* param_2);
+};
+
+class JPADrawExecRotation : public JPADrawExecParticleVisitor {
+public:
+    virtual ~JPADrawExecRotation() {}
+    virtual void exec(const JPADrawContext* pDC, JPABaseParticle* param_2);
+};
+
+class JPADrawExecRotationCross : public JPADrawExecParticleVisitor {
+public:
+    virtual ~JPADrawExecRotationCross() {}
+    virtual void exec(const JPADrawContext* pDC, JPABaseParticle* param_2);
+};
+
+class JPADrawExecPoint : public JPADrawExecParticleVisitor {
+public:
+    virtual ~JPADrawExecPoint() {}
+    virtual void exec(const JPADrawContext* pDC, JPABaseParticle* param_2);
+};
+
+class JPADrawExecLine : public JPADrawExecParticleVisitor {
+public:
+    virtual ~JPADrawExecLine() {}
+    virtual void exec(const JPADrawContext* pDC, JPABaseParticle* param_2);
+};
+
+class JPADrawExecStripe : public JPADrawExecEmitterVisitor {
+public:
+    virtual ~JPADrawExecStripe() {}
+    virtual void exec(const JPADrawContext* pDC);
+};
+
+class JPADrawExecStripeCross : public JPADrawExecEmitterVisitor {
+public:
+    virtual ~JPADrawExecStripeCross() {}
+    virtual void exec(const JPADrawContext* pDC);
+};
+
+class JPADrawExecCallBack : public JPADrawExecEmitterVisitor, public JPADrawExecParticleVisitor {
+public:
+    virtual ~JPADrawExecCallBack() {}
+    virtual void exec(const JPADrawContext* pDC, JPABaseParticle* param_2);
+    virtual void exec(const JPADrawContext* pDC);
+};
+
+class JPADrawCalcEmitterVisitor {
+public:
+    virtual ~JPADrawCalcEmitterVisitor() {}
+    virtual void calc(const JPADrawContext* pDC) = 0;
+};
+
+class JPADrawCalcParticleVisitor {
+public:
+    virtual ~JPADrawCalcParticleVisitor() {}
+    virtual void calc(const JPADrawContext* pDC, JPABaseParticle* param_2) = 0;
+};
+
+class JPADrawCalcScaleX : public JPADrawCalcParticleVisitor {
+public:
+    virtual ~JPADrawCalcScaleX() {}
+    virtual void calc(const JPADrawContext* pDC, JPABaseParticle* param_2);
+};
+
+class JPADrawCalcScaleXBySpeed : public JPADrawCalcParticleVisitor {
+public:
+    virtual ~JPADrawCalcScaleXBySpeed() {}
+    virtual void calc(const JPADrawContext* pDC, JPABaseParticle* param_2);
+};
+
+class JPADrawCalcScaleY : public JPADrawCalcParticleVisitor {
+public:
+    virtual ~JPADrawCalcScaleY() {}
+    virtual void calc(const JPADrawContext* pDC, JPABaseParticle* param_2);
+};
+
+class JPADrawCalcScaleYBySpeed : public JPADrawCalcParticleVisitor {
+public:
+    virtual ~JPADrawCalcScaleYBySpeed() {}
+    virtual void calc(const JPADrawContext* pDC, JPABaseParticle* param_2);
+};
+
+class JPADrawCalcScaleCopyX2Y : public JPADrawCalcParticleVisitor {
+public:
+    virtual ~JPADrawCalcScaleCopyX2Y() {}
+    virtual void calc(const JPADrawContext* pDC, JPABaseParticle* param_2);
+};
+
+class JPADrawCalcScaleAnmTimingNormal : public JPADrawCalcParticleVisitor {
+public:
+    virtual ~JPADrawCalcScaleAnmTimingNormal() {}
+    virtual void calc(const JPADrawContext* pDC, JPABaseParticle* param_2);
+};
+
+class JPADrawCalcScaleAnmTimingRepeatX : public JPADrawCalcParticleVisitor {
+public:
+    virtual ~JPADrawCalcScaleAnmTimingRepeatX() {}
+    virtual void calc(const JPADrawContext* pDC, JPABaseParticle* param_2);
+};
+
+class JPADrawCalcScaleAnmTimingRepeatY : public JPADrawCalcParticleVisitor {
+public:
+    virtual ~JPADrawCalcScaleAnmTimingRepeatY() {}
+    virtual void calc(const JPADrawContext* pDC, JPABaseParticle* param_2);
+};
+
+class JPADrawCalcScaleAnmTimingReverseX : public JPADrawCalcParticleVisitor {
+public:
+    virtual ~JPADrawCalcScaleAnmTimingReverseX() {}
+    virtual void calc(const JPADrawContext* pDC, JPABaseParticle* param_2);
+};
+
+class JPADrawCalcScaleAnmTimingReverseY : public JPADrawCalcParticleVisitor {
+public:
+    virtual ~JPADrawCalcScaleAnmTimingReverseY() {}
+    virtual void calc(const JPADrawContext* pDC, JPABaseParticle* param_2);
+};
+
+class JPADrawCalcColorPrm : public JPADrawCalcEmitterVisitor, public JPADrawCalcParticleVisitor {
+public:
+    virtual ~JPADrawCalcColorPrm() {}
+    virtual void calc(const JPADrawContext* pDC, JPABaseParticle* param_2);
+    virtual void calc(const JPADrawContext* pDC);
+};
+
+class JPADrawCalcColorEnv : public JPADrawCalcEmitterVisitor, public JPADrawCalcParticleVisitor {
+public:
+    virtual ~JPADrawCalcColorEnv() {}
+    virtual void calc(const JPADrawContext* pDC, JPABaseParticle* param_2);
+    virtual void calc(const JPADrawContext* pDC);
+};
+
+class JPADrawCalcColorCopyFromEmitter : public JPADrawCalcParticleVisitor {
+public:
+    virtual ~JPADrawCalcColorCopyFromEmitter() {}
+    virtual void calc(const JPADrawContext* pDC, JPABaseParticle* param_2);
+};
+
+class JPADrawCalcColorAnmFrameNormal : public JPADrawCalcEmitterVisitor, public JPADrawCalcParticleVisitor {
+public:
+    virtual ~JPADrawCalcColorAnmFrameNormal() {}
+    virtual void calc(const JPADrawContext* pDC, JPABaseParticle* param_2);
+    virtual void calc(const JPADrawContext* pDC);
+};
+
+class JPADrawCalcColorAnmFrameRepeat : public JPADrawCalcEmitterVisitor, public JPADrawCalcParticleVisitor {
+public:
+    virtual ~JPADrawCalcColorAnmFrameRepeat() {}
+    virtual void calc(const JPADrawContext* pDC, JPABaseParticle* param_2);
+    virtual void calc(const JPADrawContext* pDC);
+};
+
+class JPADrawCalcColorAnmFrameReverse : public JPADrawCalcEmitterVisitor, public JPADrawCalcParticleVisitor {
+public:
+    virtual ~JPADrawCalcColorAnmFrameReverse() {}
+    virtual void calc(const JPADrawContext* pDC, JPABaseParticle* param_2);
+    virtual void calc(const JPADrawContext* pDC);
+};
+
+class JPADrawCalcColorAnmFrameMerge : public JPADrawCalcEmitterVisitor, public JPADrawCalcParticleVisitor {
+public:
+    virtual ~JPADrawCalcColorAnmFrameMerge() {}
+    virtual void calc(const JPADrawContext* pDC, JPABaseParticle* param_2);
+    virtual void calc(const JPADrawContext* pDC);
+};
+
+class JPADrawCalcColorAnmFrameRandom : public JPADrawCalcEmitterVisitor, public JPADrawCalcParticleVisitor {
+public:
+    virtual ~JPADrawCalcColorAnmFrameRandom() {}
+    virtual void calc(const JPADrawContext* pDC, JPABaseParticle* param_2);
+    virtual void calc(const JPADrawContext* pDC);
+};
+
+class JPADrawCalcAlpha : public JPADrawCalcParticleVisitor {
+public:
+    virtual ~JPADrawCalcAlpha() {}
+    virtual void calc(const JPADrawContext* pDC, JPABaseParticle* param_2);
+};
+
+class JPADrawCalcAlphaFlickNrmSin : public JPADrawCalcParticleVisitor {
+public:
+    virtual ~JPADrawCalcAlphaFlickNrmSin() {}
+    virtual void calc(const JPADrawContext* pDC, JPABaseParticle* param_2);
+};
+
+class JPADrawCalcAlphaFlickAddSin : public JPADrawCalcParticleVisitor {
+public:
+    virtual ~JPADrawCalcAlphaFlickAddSin() {}
+    virtual void calc(const JPADrawContext* pDC, JPABaseParticle* param_2);
+};
+
+class JPADrawCalcAlphaFlickMultSin : public JPADrawCalcParticleVisitor {
+public:
+    virtual ~JPADrawCalcAlphaFlickMultSin() {}
+    virtual void calc(const JPADrawContext* pDC, JPABaseParticle* param_2);
+};
+
+class JPADrawCalcTextureAnmIndexNormal : public JPADrawCalcEmitterVisitor, public JPADrawCalcParticleVisitor {
+public:
+    virtual ~JPADrawCalcTextureAnmIndexNormal() {}
+    virtual void calc(const JPADrawContext* pDC, JPABaseParticle* param_2);
+    virtual void calc(const JPADrawContext* pDC);
+};
+
+class JPADrawCalcTextureAnmIndexRepeat : public JPADrawCalcEmitterVisitor, public JPADrawCalcParticleVisitor {
+public:
+    virtual ~JPADrawCalcTextureAnmIndexRepeat() {}
+    virtual void calc(const JPADrawContext* pDC, JPABaseParticle* param_2);
+    virtual void calc(const JPADrawContext* pDC);
+};
+
+class JPADrawCalcTextureAnmIndexReverse : public JPADrawCalcEmitterVisitor, public JPADrawCalcParticleVisitor {
+public:
+    virtual ~JPADrawCalcTextureAnmIndexReverse() {}
+    virtual void calc(const JPADrawContext* pDC, JPABaseParticle* param_2);
+    virtual void calc(const JPADrawContext* pDC);
+};
+
+class JPADrawCalcTextureAnmIndexMerge : public JPADrawCalcEmitterVisitor, public JPADrawCalcParticleVisitor {
+public:
+    virtual ~JPADrawCalcTextureAnmIndexMerge() {}
+    virtual void calc(const JPADrawContext* pDC, JPABaseParticle* param_2);
+    virtual void calc(const JPADrawContext* pDC);
+};
+
+class JPADrawCalcTextureAnmIndexRandom : public JPADrawCalcEmitterVisitor, public JPADrawCalcParticleVisitor {
+public:
+    virtual ~JPADrawCalcTextureAnmIndexRandom() {}
+    virtual void calc(const JPADrawContext* pDC, JPABaseParticle* param_2);
+    virtual void calc(const JPADrawContext* pDC);
+};
+
+class JPADrawCalcChildAlphaOut : public JPADrawCalcParticleVisitor {
+public:
+    virtual ~JPADrawCalcChildAlphaOut() {}
+    virtual void calc(const JPADrawContext* pDC, JPABaseParticle* param_2);
+};
+
+class JPADrawCalcChildScaleOut : public JPADrawCalcParticleVisitor {
+public:
+    virtual ~JPADrawCalcChildScaleOut() {}
+    virtual void calc(const JPADrawContext* pDC, JPABaseParticle* param_2);
+};
+
+class JPADrawVisitorContainer {
+public:
+    JPADrawExecGenPrjMtx field_0x0;
+    JPADrawExecGenPrjTexMtx field_0x4;
+    JPADrawExecGenTexMtx0 field_0x8;
+    JPADrawExecGenIdtMtx field_0xc;
+    JPADrawExecSetTexMtx field_0x10;
+    JPADrawExecSetPointSize field_0x18;
+    JPADrawExecSetLineWidth field_0x1c;
+    JPADrawExecRegisterColorEmitterPE field_0x20;
+    JPADrawExecRegisterColorEmitterP field_0x24;
+    JPADrawExecRegisterColorEmitterE field_0x28;
+    JPADrawExecRegisterColorChildPE field_0x2c;
+    JPADrawExecRegisterPrmColorAnm field_0x30;
+    JPADrawExecRegisterPrmAlphaAnm field_0x34;
+    JPADrawExecRegisterEnvColorAnm field_0x38;
+    JPADrawExecRegisterPrmCEnv field_0x3c;
+    JPADrawExecRegisterPrmAEnv field_0x40;
+    JPADrawExecLoadDefaultTexture field_0x44;
+    JPADrawExecLoadTexture field_0x48;
+    JPADrawExecLoadExTex field_0x50;
+    JPADrawExecBillBoard field_0x54;
+    JPADrawExecRotBillBoard field_0x58;
+    JPADrawExecYBillBoard field_0x5c;
+    JPADrawExecRotYBillBoard field_0x60;
+    JPADrawExecDirectional field_0x64;
+    JPADrawExecRotDirectional field_0x68;
+    JPADrawExecDirectionalCross field_0x6c;
+    JPADrawExecRotDirectionalCross field_0x70;
+    JPADrawExecDirBillBoard field_0x74;
+    JPADrawExecRotation field_0x78;
+    JPADrawExecRotationCross field_0x7c;
+    JPADrawExecPoint field_0x80;
+    JPADrawExecLine field_0x84;
+    JPADrawExecStripe field_0x88;
+    JPADrawExecStripeCross field_0x8c;
+    JPADrawExecCallBack field_0x90;
+    JPADrawCalcScaleX field_0x98;
+    JPADrawCalcScaleXBySpeed field_0x9c;
+    JPADrawCalcScaleY field_0xa0;
+    JPADrawCalcScaleYBySpeed field_0xa4;
+    JPADrawCalcScaleCopyX2Y field_0xa8;
+    JPADrawCalcScaleAnmTimingNormal field_0xac;
+    JPADrawCalcScaleAnmTimingRepeatX field_0xb0;
+    JPADrawCalcScaleAnmTimingRepeatY field_0xb4;
+    JPADrawCalcScaleAnmTimingReverseX field_0xb8;
+    JPADrawCalcScaleAnmTimingReverseY field_0xbc;
+    JPADrawCalcColorPrm field_0xc0;
+    JPADrawCalcColorEnv field_0xc8;
+    JPADrawCalcColorCopyFromEmitter field_0xd0;
+    JPADrawCalcColorAnmFrameNormal field_0xd4;
+    JPADrawCalcColorAnmFrameRepeat field_0xdc;
+    JPADrawCalcColorAnmFrameReverse field_0xe4;
+    JPADrawCalcColorAnmFrameMerge field_0xec;
+    JPADrawCalcColorAnmFrameRandom field_0xf4;
+    JPADrawCalcAlpha field_0xfc;
+    JPADrawCalcAlphaFlickNrmSin field_0x100;
+    JPADrawCalcAlphaFlickAddSin field_0x104;
+    JPADrawCalcAlphaFlickMultSin field_0x108;
+    JPADrawCalcTextureAnmIndexNormal field_0x10c;
+    JPADrawCalcTextureAnmIndexRepeat field_0x114;
+    JPADrawCalcTextureAnmIndexReverse field_0x11c;
+    JPADrawCalcTextureAnmIndexMerge field_0x124;
+    JPADrawCalcTextureAnmIndexRandom field_0x12c;
+    JPADrawCalcChildAlphaOut field_0x134;
+    JPADrawCalcChildScaleOut field_0x138;
+};
+
+#endif /* JPADRAWVISITOR_H */
diff --git a/include/JSystem/JParticle/JPAExtraShape.h b/include/JSystem/JParticle/JPAExtraShape.h
index 66887233..093a97c7 100644
--- a/include/JSystem/JParticle/JPAExtraShape.h
+++ b/include/JSystem/JParticle/JPAExtraShape.h
@@ -44,8 +44,8 @@ public:
     virtual f32 getScaleOutTiming() = 0;
     virtual f32 getScaleInValueX() = 0;
     virtual f32 getScaleInValueY() = 0;
-    virtual u32 getAnmTypeX() = 0;
-    virtual u32 getAnmTypeY() = 0;
+    virtual u8 getAnmTypeX() = 0;
+    virtual u8 getAnmTypeY() = 0;
     virtual u32 getAnmCycleX() = 0;
     virtual u32 getAnmCycleY() = 0;
     virtual f32 getIncreaseRateX() = 0;
@@ -61,7 +61,7 @@ public:
     virtual f32 getAlphaOutTiming() = 0;
     virtual f32 getAlphaInValue() = 0;
     virtual f32 getAlphaBaseValue() = 0;
-    virtual u32 getAlphaWaveType() = 0;
+    virtual u8 getAlphaWaveType() = 0;
     virtual f32 getAlphaWaveParam1() = 0;
     virtual f32 getAlphaWaveParam2() = 0;
     virtual f32 getAlphaWaveParam3() = 0;
@@ -90,8 +90,8 @@ public:
     virtual f32 getScaleOutTiming() { return mpData->mScaleOutTiming; }
     virtual f32 getScaleInValueX() { return mpData->mScaleInValueX; }
     virtual f32 getScaleInValueY() { return mpData->mScaleInValueY; }
-    virtual u32 getAnmTypeX() { return (mpData->mFlag >> 18) & 0x01; }
-    virtual u32 getAnmTypeY() { return (mpData->mFlag >> 19) & 0x01; }
+    virtual u8 getAnmTypeX() { return (mpData->mFlag >> 18) & 0x01; }
+    virtual u8 getAnmTypeY() { return (mpData->mFlag >> 19) & 0x01; }
     virtual u32 getAnmCycleX() { return mpData->mAnmCycleX; }
     virtual u32 getAnmCycleY() { return mpData->mAnmCycleY; }
     virtual f32 getIncreaseRateX() { return mIncreaseRateX; }
@@ -107,7 +107,7 @@ public:
     virtual f32 getAlphaOutTiming() { return mpData->mAlphaOutTiming; }
     virtual f32 getAlphaInValue() { return mpData->mAlphaInValue; }
     virtual f32 getAlphaBaseValue() { return mpData->mAlphaBaseValue; }
-    virtual u32 getAlphaWaveType() { return (mpData->mFlag >> 2) & 0x03; }
+    virtual u8 getAlphaWaveType() { return (mpData->mFlag >> 2) & 0x03; }
     virtual f32 getAlphaWaveParam1() { return mpData->mAlphaWaveParam1; }
     virtual f32 getAlphaWaveParam2() { return mpData->mAlphaWaveParam2; }
     virtual f32 getAlphaWaveParam3() { return mpData->mAlphaWaveParam3; }
diff --git a/include/JSystem/JParticle/JPASweepShape.h b/include/JSystem/JParticle/JPASweepShape.h
index fe5291f2..05ccc8b5 100644
--- a/include/JSystem/JParticle/JPASweepShape.h
+++ b/include/JSystem/JParticle/JPASweepShape.h
@@ -29,7 +29,7 @@ struct JPASweepShapeData {
 class JPASweepShape {
 public:
     virtual ~JPASweepShape() {};
-    virtual u32 getType() = 0;
+    virtual u8 getType() = 0;
     virtual u32 getDirType() = 0;
     virtual u32 getRotType() = 0;
     virtual u32 getBasePlaneType() = 0;
@@ -68,7 +68,7 @@ class JPASweepShapeArc : public JPASweepShape {
 public:
     JPASweepShapeArc(const u8*);
     virtual ~JPASweepShapeArc() {};
-    virtual u32 getType() { return (mpData->mFlag >> 0) & 0x0F; }
+    virtual u8 getType() { return (mpData->mFlag >> 0) & 0x0F; }
     virtual u32 getDirType() { return (mpData->mFlag >> 4) & 0x07; }
     virtual u32 getRotType() { return (mpData->mFlag >> 7) & 0x07; }
     virtual u32 getBasePlaneType() { return (mpData->mFlag >> 10) & 0x01; }
diff --git a/src/JSystem/JParticle/JPADraw.cpp b/src/JSystem/JParticle/JPADraw.cpp
index 28b5f2e6..da41b52e 100644
--- a/src/JSystem/JParticle/JPADraw.cpp
+++ b/src/JSystem/JParticle/JPADraw.cpp
@@ -11,23 +11,11 @@
 #include "JSystem/JUtility/JUTAssert.h"
 #include "dolphin/types.h"
 
-class JPADrawClipBoard {
-public:
-    ~JPADrawClipBoard();
-};
-
-class JPADrawVisitorContainer {
-public:
-    JPADrawVisitorContainer();
-    ~JPADrawVisitorContainer();
-};
-
 JPADrawVisitorContainer JPADraw::vc;
 JPADrawClipBoard JPADraw::cb;
 
 /* 80267F40-80268634       .text initialize__7JPADrawFP14JPABaseEmitterP18JPATextureResource */
 bool JPADraw::initialize(JPABaseEmitter* emtr, JPATextureResource* texRes) {
-    /* Nonmatching */
     JPADrawContext::pcb = &cb;
     dc.pbe = emtr;
     dc.pbsp = dc.pbe->getEmitterDataBlockInfoPtr()->getBaseShape();
@@ -85,7 +73,7 @@ bool JPADraw::initialize(JPABaseEmitter* emtr, JPATextureResource* texRes) {
         mpCalcChldVis[i] = NULL;
 
     JPADrawVisitorDefFlags flags;
-    flags.mbIsEnableDrawParent = dc.pssp != NULL && dc.pssp->isEnableDrawParent();
+    flags.mbIsEnableDrawParent = dc.pssp == NULL || dc.pssp->isEnableDrawParent();
     flags.mbHasPrmAnm = dc.pbsp->isEnablePrm() && dc.pbsp->isEnablePrmAnm();
     flags.mbHasEnvAnm = dc.pbsp->isEnableEnv() && dc.pbsp->isEnableEnvAnm();
     flags.mbIsStripe = dc.pbsp->getType() == JPABaseShape::JPAType_Stripe || dc.pbsp->getType() == JPABaseShape::JPAType_StripeCross;
@@ -94,8 +82,10 @@ bool JPADraw::initialize(JPABaseEmitter* emtr, JPATextureResource* texRes) {
 
     setDrawExecVisitorsBeforeCB(flags);
 
-    // TODO: setup visitor container
-    // mpExecEmtrPVis[execEmtrVisNum++] = vc.something;
+    mpExecEmtrPVis[execEmtrPVisNum++] = &vc.field_0x90;
+    mpExecEmtrCVis[execEmtrCVisNum++] = &vc.field_0x90;
+    mpExecPtclVis[execPtclVisNum++] = &vc.field_0x90;
+    mpExecChldVis[execChldVisNum++] = &vc.field_0x90;
 
     setDrawExecVisitorsAfterCB(flags);
     setDrawCalcVisitors(flags);
@@ -112,8 +102,41 @@ bool JPADraw::initialize(JPABaseEmitter* emtr, JPATextureResource* texRes) {
 }
 
 /* 80268634-802688D4       .text draw__7JPADrawFPA4_f */
-void JPADraw::draw(float(*)[4]) {
-    /* Nonmatching */
+void JPADraw::draw(MtxP param_1) {
+    GXClearVtxDesc();
+    GXSetVtxDesc(GX_VA_POS, GX_DIRECT);
+    GXSetVtxDesc(GX_VA_TEX0, GX_DIRECT);
+    GXSetVtxAttrFmt(GX_VTXFMT0, GX_VA_POS, GX_POS_XYZ, GX_F32, 0);
+    GXSetVtxAttrFmt(GX_VTXFMT0, GX_VA_TEX0, GX_TEX_ST, GX_F32, 0);
+    GXSetCurrentMtx(0);
+    GXSetNumChans(0);
+    GXSetTevDirect(GX_TEVSTAGE0);
+    GXSetTevDirect(GX_TEVSTAGE1);
+    GXSetTevDirect(GX_TEVSTAGE2);
+    GXSetCoPlanar(GX_DISABLE);
+    GXSetChanCtrl(GX_COLOR0A0, GX_DISABLE, GX_SRC_REG, GX_SRC_REG, 0, GX_DF_NONE, GX_AF_NONE);
+    GXSetChanCtrl(GX_COLOR1A1, GX_DISABLE, GX_SRC_REG, GX_SRC_REG, 0, GX_DF_NONE, GX_AF_NONE);
+    GXSetBlendMode(dc.pbsp->getBlendMode1(), dc.pbsp->getSrcBlendFactor1(),
+                   dc.pbsp->getDstBlendFactor1(), dc.pbsp->getBlendOp1());
+    cb.field_0x98 = dc.pbe->mGlobalPrmColor;
+    cb.field_0x9c = dc.pbe->mGlobalEnvColor;
+    cb.field_0x34 = param_1;
+    cb.field_0x0.setupTev(dc.pbsp, dc.petx);
+    for (int i = 0; i < execEmtrVisNum; i++) {
+        mpExecEmtrVis[i]->exec(&dc);
+    }
+    if (dc.pbsp->isEnableAnmTone()) {
+        zDraw();
+    }
+    field_0xc2 &= 0xfe;
+    if (dc.pbsp->getChildOrder() && dc.pssp) {
+        drawChild();
+    }
+    drawParticle();
+    if (!dc.pbsp->getChildOrder() && dc.pssp) {
+        drawChild();
+    }
+    GXSetAlphaCompare(GX_ALWAYS, 0, GX_AOP_AND, GX_ALWAYS, 0);
 }
 
 /* 802688D4-80268940       .text calc__7JPADrawFv */
@@ -150,18 +173,381 @@ bool JPADraw::loadTexture(u8 tex_no, GXTexMapID texMap) {
 }
 
 /* 80269358-80269C08       .text setDrawExecVisitorsBeforeCB__7JPADrawFRCQ27JPADraw22JPADrawVisitorDefFlags */
-void JPADraw::setDrawExecVisitorsBeforeCB(const JPADraw::JPADrawVisitorDefFlags&) {
+void JPADraw::setDrawExecVisitorsBeforeCB(const JPADraw::JPADrawVisitorDefFlags& param_1) {
     /* Nonmatching */
+        if (dc.petx) {
+        mpExecEmtrVis[execEmtrVisNum++] = &vc.field_0x50;
+    }
+    if (param_1.mbIsPointOrLine) {
+        mpExecEmtrPVis[execEmtrPVisNum++] = &vc.field_0xc;
+    } else if (dc.pbsp->isEnableProjection()) {
+        if (dc.pbsp->isEnableTexScrollAnm()) {
+            mpExecEmtrPVis[execEmtrPVisNum++] = &vc.field_0x4;
+        } else {
+            mpExecEmtrPVis[execEmtrPVisNum++] = &vc.field_0x0;
+        }
+    } else if (dc.pbsp->isEnableTexScrollAnm()) {
+        if (param_1.mbIsStripe) {
+            mpExecEmtrPVis[execEmtrPVisNum++] = &vc.field_0x10;
+        } else {
+            mpExecEmtrPVis[execEmtrPVisNum++] = &vc.field_0x8;
+        }
+    } else {
+        mpExecEmtrPVis[execEmtrPVisNum++] = &vc.field_0xc;
+    }
+
+    if (dc.pbsp->isEnableGlobalColAnm()) {
+        if (param_1.mbIsStripe || param_1.mbIsEnableAlpha == 0) {
+            mpExecEmtrPVis[execEmtrPVisNum++] = &vc.field_0x20;
+        } else if (param_1.mbIsEnableAlpha) {
+            mpExecEmtrPVis[execEmtrPVisNum++] = &vc.field_0x28;
+        }
+    } else if ((!dc.pbsp->isEnablePrm() || !dc.pbsp->isEnablePrmAnm()) && param_1.mbIsEnableAlpha == 0) {
+        if (!dc.pbsp->isEnableEnv() || !dc.pbsp->isEnableEnvAnm()) {
+            mpExecEmtrPVis[execEmtrPVisNum++] = &vc.field_0x20;
+        } else {
+            mpExecEmtrPVis[execEmtrPVisNum++] = &vc.field_0x24;
+        }
+    } else if (!dc.pbsp->isEnableEnv() || !dc.pbsp->isEnableEnvAnm()) {
+        mpExecEmtrPVis[execEmtrPVisNum++] = &vc.field_0x28;
+    }
+    if (!dc.pbsp->textureIsEmpty() && (!dc.pbsp->isEnableTextureAnm() || dc.pbsp->isEnableGlobalTexAnm())) {
+        mpExecEmtrPVis[execEmtrPVisNum++] = &vc.field_0x48;
+    } else if (dc.pbsp->textureIsEmpty()) {
+        mpExecEmtrPVis[execEmtrPVisNum++] = &vc.field_0x44;
+    }
+    if (dc.pssp && !dc.pssp->isEnableAlphaOut() && !dc.pssp->isInheritedAlpha() && !dc.pssp->isInheritedRGB()) {
+        mpExecEmtrCVis[execEmtrCVisNum++] = &vc.field_0x2c;
+    }
+    if (!dc.pbsp->isEnableGlobalColAnm()) {
+        if (param_1.mbHasPrmAnm) {
+            if (param_1.mbHasEnvAnm) {
+                mpExecPtclVis[execPtclVisNum++] = &vc.field_0x3c;
+            } else {
+                mpExecPtclVis[execPtclVisNum++] = &vc.field_0x30;
+            }
+        } else if (param_1.mbIsEnableAlpha) {
+            if (param_1.mbHasEnvAnm) {
+                mpExecPtclVis[execPtclVisNum++] = &vc.field_0x40;
+            } else {
+                mpExecPtclVis[execPtclVisNum++] = &vc.field_0x34;
+            }
+        } else if (param_1.mbHasEnvAnm) {
+            mpExecPtclVis[execPtclVisNum++] = &vc.field_0x38;
+        }
+
+    } else if (param_1.mbIsEnableAlpha && !param_1.mbIsStripe) {
+        mpExecPtclVis[execPtclVisNum++] = &vc.field_0x34;
+    }
+    if (!dc.pbsp->textureIsEmpty() && dc.pbsp->isEnableTextureAnm() && !dc.pbsp->isEnableGlobalTexAnm()) {
+        mpExecPtclVis[execPtclVisNum++] = &vc.field_0x48;
+    }
+    switch (dc.pbsp->getType()) {
+    case 0:
+        if (dc.pesp && dc.pesp->isEnableScale()) {
+            mpExecPtclVis[execPtclVisNum++] = &vc.field_0x18;
+        }
+        break;
+    case 1:
+        if (dc.pesp && dc.pesp->isEnableScale()) {
+            mpExecPtclVis[execPtclVisNum++] = &vc.field_0x1c;
+        }
+        break;
+    case 5:
+    case 6:
+        break;
+    case 7:
+    case 8:
+    case 9:
+    case 10:
+        if (dc.pbsp->isEnableTexScrollAnm() && !dc.pbsp->isEnableProjection()) {
+            mpExecPtclVis[execPtclVisNum++] = &vc.field_0x10;
+        }
+        break;
+    }
+    if (dc.pssp) {
+        if (dc.pssp->isEnableAlphaOut() || dc.pssp->isInheritedAlpha() || dc.pssp->isInheritedRGB()) {
+            mpExecChldVis[execChldVisNum++] = &vc.field_0x3c;
+        }
+        switch (dc.pssp->getType()) {
+        case 0:
+            mpExecChldVis[execChldVisNum++] = &vc.field_0x18;
+            break;
+        case 1:
+            mpExecChldVis[execChldVisNum++] = &vc.field_0x1c;
+            break;
+        }
+    }
 }
 
 /* 80269C08-8026A2EC       .text setDrawExecVisitorsAfterCB__7JPADrawFRCQ27JPADraw22JPADrawVisitorDefFlags */
-void JPADraw::setDrawExecVisitorsAfterCB(const JPADraw::JPADrawVisitorDefFlags&) {
-    /* Nonmatching */
+void JPADraw::setDrawExecVisitorsAfterCB(const JPADraw::JPADrawVisitorDefFlags& param_1) {
+    if (param_1.mbIsEnableDrawParent) {
+        switch (dc.pbsp->getType()) {
+        case 0:
+            mpExecPtclVis[execPtclVisNum++] = &vc.field_0x80;
+            break;
+        case 1:
+            mpExecPtclVis[execPtclVisNum++] = &vc.field_0x84;
+            break;
+        case 2:
+            if (dc.pesp && dc.pesp->isEnableRotate()) {
+                mpExecPtclVis[execPtclVisNum++] = &vc.field_0x58;
+            } else {
+                mpExecPtclVis[execPtclVisNum++] = &vc.field_0x54;
+            }
+            break;
+        case 3:
+            if (dc.pesp && dc.pesp->isEnableRotate()) {
+                mpExecPtclVis[execPtclVisNum++] = &vc.field_0x68;
+            } else {
+                mpExecPtclVis[execPtclVisNum++] = &vc.field_0x64;
+            }
+            break;
+        case 4:
+            if (dc.pesp && dc.pesp->isEnableRotate()) {
+                mpExecPtclVis[execPtclVisNum++] = &vc.field_0x70;
+            } else {
+                mpExecPtclVis[execPtclVisNum++] = &vc.field_0x6c;
+            }
+            break;
+        case 10:
+            if (dc.pesp && dc.pesp->isEnableRotate()) {
+                mpExecPtclVis[execPtclVisNum++] = &vc.field_0x60;
+            } else {
+                mpExecPtclVis[execPtclVisNum++] = &vc.field_0x5c;
+            }
+            break;
+        case 7:
+            mpExecPtclVis[execPtclVisNum++] = &vc.field_0x78;
+            break;
+        case 8:
+            mpExecPtclVis[execPtclVisNum++] = &vc.field_0x7c;
+            break;
+        case 9:
+            mpExecPtclVis[execPtclVisNum++] = &vc.field_0x74;
+            break;
+        case 5:
+            mpExecEmtrPVis[execEmtrPVisNum++] = &vc.field_0x88;
+            break;
+        case 6:
+            mpExecEmtrPVis[execEmtrPVisNum++] = &vc.field_0x8c;
+            break;
+        }
+    }
+    if (dc.pssp) {
+        switch (dc.pssp->getType()) {
+        case 0:
+            mpExecChldVis[execChldVisNum++] = &vc.field_0x80;
+            break;
+        case 1:
+            mpExecChldVis[execChldVisNum++] = &vc.field_0x84;
+            break;
+        case 2:
+            if ((dc.pesp && dc.pesp->isEnableRotate()) || dc.pssp->isEnableRotate()) {
+                mpExecChldVis[execChldVisNum++] = &vc.field_0x58;
+            } else {
+                mpExecChldVis[execChldVisNum++] = &vc.field_0x54;
+            }
+            break;
+        case 3:
+            if ((dc.pesp && dc.pesp->isEnableRotate()) || dc.pssp->isEnableRotate()) {
+                mpExecChldVis[execChldVisNum++] = &vc.field_0x68;
+            } else {
+                mpExecChldVis[execChldVisNum++] = &vc.field_0x64;
+            }
+            break;
+        case 4:
+            if ((dc.pesp && dc.pesp->isEnableRotate()) || dc.pssp->isEnableRotate()) {
+                mpExecChldVis[execChldVisNum++] = &vc.field_0x70;
+            } else {
+                mpExecChldVis[execChldVisNum++] = &vc.field_0x6c;
+            }
+            break;
+        case 10:
+            if ((dc.pesp && dc.pesp->isEnableRotate()) || dc.pssp->isEnableRotate()) {
+                mpExecChldVis[execChldVisNum++] = &vc.field_0x60;
+            } else {
+                mpExecChldVis[execChldVisNum++] = &vc.field_0x5c;
+            }
+            break;
+        case 7:
+            mpExecChldVis[execChldVisNum++] = &vc.field_0x78;
+            break;
+        case 8:
+            mpExecChldVis[execChldVisNum++] = &vc.field_0x7c;
+            break;
+        case 9:
+            mpExecChldVis[execChldVisNum++] = &vc.field_0x74;
+            break;
+        case 5:
+            mpExecEmtrCVis[execEmtrCVisNum++] = &vc.field_0x88;
+            break;
+        case 6:
+            mpExecEmtrCVis[execEmtrCVisNum++] = &vc.field_0x8c;
+            break;
+        }
+    }
 }
 
 /* 8026A2EC-8026ADB0       .text setDrawCalcVisitors__7JPADrawFRCQ27JPADraw22JPADrawVisitorDefFlags */
-void JPADraw::setDrawCalcVisitors(const JPADraw::JPADrawVisitorDefFlags&) {
-    /* Nonmatching */
+void JPADraw::setDrawCalcVisitors(const JPADraw::JPADrawVisitorDefFlags& param_1) {
+    if (dc.pbsp->isEnableGlobalColAnm() && (param_1.mbHasPrmAnm || param_1.mbHasEnvAnm)) {
+        switch (dc.pbsp->getColorRegAnmType()) {
+        case 0:
+            mpCalcEmtrVis[calcEmtrVisNum++] = &vc.field_0xd4;
+            break;
+        case 1:
+            mpCalcEmtrVis[calcEmtrVisNum++] = &vc.field_0xdc;
+            break;
+        case 2:
+            mpCalcEmtrVis[calcEmtrVisNum++] = &vc.field_0xe4;
+            break;
+        case 3:
+            mpCalcEmtrVis[calcEmtrVisNum++] = &vc.field_0xec;
+            break;
+        case 4:
+            mpCalcEmtrVis[calcEmtrVisNum++] = &vc.field_0xf4;
+            break;
+        }
+        if (param_1.mbHasPrmAnm) {
+            mpCalcEmtrVis[calcEmtrVisNum++] = &vc.field_0xc0;
+        }
+        if (param_1.mbHasEnvAnm) {
+            mpCalcEmtrVis[calcEmtrVisNum++] = &vc.field_0xc8;
+        }
+    }
+    if (!dc.pbsp->textureIsEmpty() && dc.pbsp->isEnableTextureAnm() &&
+        dc.pbsp->isEnableGlobalTexAnm())
+    {
+        switch (dc.pbsp->getTextureAnmType()) {
+        case 0:
+            mpCalcEmtrVis[calcEmtrVisNum++] = &vc.field_0x10c;
+            break;
+        case 1:
+            mpCalcEmtrVis[calcEmtrVisNum++] = &vc.field_0x114;
+            break;
+        case 2:
+            mpCalcEmtrVis[calcEmtrVisNum++] = &vc.field_0x11c;
+            break;
+        case 3:
+            mpCalcEmtrVis[calcEmtrVisNum++] = &vc.field_0x124;
+            break;
+        case 4:
+            mpCalcEmtrVis[calcEmtrVisNum++] = &vc.field_0x12c;
+            break;
+        }
+    }
+    if (dc.pesp && dc.pesp->isEnableScale()) {
+        if (dc.pesp->isEnableScaleAnmX()) {
+            if (dc.pesp->getAnmTypeX()) {
+                mpCalcPtclVis[calcPtclVisNum++] = &vc.field_0xb8;
+            } else {
+                mpCalcPtclVis[calcPtclVisNum++] = &vc.field_0xb0;
+            }
+        } else {
+            mpCalcPtclVis[calcPtclVisNum++] = &vc.field_0xac;
+        }
+        if (dc.pesp->isEnableScaleBySpeedX() && dc.pbsp->getType() != 1) {
+            mpCalcPtclVis[calcPtclVisNum++] = &vc.field_0x9c;
+        } else {
+            mpCalcPtclVis[calcPtclVisNum++] = &vc.field_0x98;
+        }
+        if (dc.pbsp->getType() != 0) {
+            if (!dc.pesp->isDiffXY()) {
+                mpCalcPtclVis[calcPtclVisNum++] = &vc.field_0xa8;
+            } else {
+                if (dc.pesp->isEnableScaleAnmY()) {
+                    if (dc.pesp->getAnmTypeY()) {
+                        mpCalcPtclVis[calcPtclVisNum++] = &vc.field_0xbc;
+                    } else {
+                        mpCalcPtclVis[calcPtclVisNum++] = &vc.field_0xb4;
+                    }
+                } else if (dc.pesp->isEnableScaleAnmX()) {
+                    mpCalcPtclVis[calcPtclVisNum++] = &vc.field_0xac;
+                }
+                if (dc.pesp->isEnableScaleBySpeedY()) {
+                    mpCalcPtclVis[calcPtclVisNum++] = &vc.field_0xa4;
+                } else {
+                    mpCalcPtclVis[calcPtclVisNum++] = &vc.field_0xa0;
+                }
+            }
+        }
+    }
+    if (!dc.pbsp->isEnableGlobalColAnm()) {
+        if (param_1.mbHasPrmAnm || param_1.mbHasEnvAnm) {
+            switch (dc.pbsp->getColorRegAnmType()) {
+            case 0:
+                mpCalcPtclVis[calcPtclVisNum++] = &vc.field_0xd4;
+                break;
+            case 1:
+                mpCalcPtclVis[calcPtclVisNum++] = &vc.field_0xdc;
+                break;
+            case 2:
+                mpCalcPtclVis[calcPtclVisNum++] = &vc.field_0xe4;
+                break;
+            case 3:
+                mpCalcPtclVis[calcPtclVisNum++] = &vc.field_0xec;
+                break;
+            case 4:
+                mpCalcPtclVis[calcPtclVisNum++] = &vc.field_0xf4;
+                break;
+            }
+            if (param_1.mbHasPrmAnm) {
+                mpCalcPtclVis[calcPtclVisNum++] = &vc.field_0xc0;
+            }
+            if (param_1.mbHasEnvAnm) {
+                mpCalcPtclVis[calcPtclVisNum++] = &vc.field_0xc8;
+            }
+        }
+    } else {
+        mpCalcPtclVis[calcPtclVisNum++] = &vc.field_0xd0;
+    }
+    if (param_1.mbIsEnableAlpha && !param_1.mbIsStripe) {
+        mpCalcPtclVis[calcPtclVisNum++] = &vc.field_0xfc;
+        if (dc.pesp->isEnableSinWave()) {
+            switch (dc.pesp->getAlphaWaveType()) {
+            case 0:
+                mpCalcPtclVis[calcPtclVisNum++] = &vc.field_0x100;
+                break;
+            case 1:
+                mpCalcPtclVis[calcPtclVisNum++] = &vc.field_0x104;
+                break;
+            case 2:
+                mpCalcPtclVis[calcPtclVisNum++] = &vc.field_0x108;
+                break;
+            }
+        }
+    }
+    if (!dc.pbsp->textureIsEmpty() && dc.pbsp->isEnableTextureAnm() &&
+        !dc.pbsp->isEnableGlobalTexAnm())
+    {
+        switch (dc.pbsp->getTextureAnmType()) {
+        case 0:
+            mpCalcPtclVis[calcPtclVisNum++] = &vc.field_0x10c;
+            break;
+        case 1:
+            mpCalcPtclVis[calcPtclVisNum++] = &vc.field_0x114;
+            break;
+        case 2:
+            mpCalcPtclVis[calcPtclVisNum++] = &vc.field_0x11c;
+            break;
+        case 3:
+            mpCalcPtclVis[calcPtclVisNum++] = &vc.field_0x124;
+            break;
+        case 4:
+            mpCalcPtclVis[calcPtclVisNum++] = &vc.field_0x12c;
+            break;
+        }
+    }
+    if (dc.pssp) {
+        if (dc.pssp->isEnableAlphaOut()) {
+            mpCalcChldVis[calcChldVisNum++] = &vc.field_0x134;
+        }
+        if (dc.pssp->isEnableScaleOut()) {
+            mpCalcChldVis[calcChldVisNum++] = &vc.field_0x138;
+        }
+    }
 }
 
 /* 8026ADB0-8026B3DC       .text setParticleClipBoard__7JPADrawFv */
@@ -186,7 +572,6 @@ void JPADraw::drawChild() {
 
 /* 8026BF88-8026C024       .text zDraw__7JPADrawFv */
 void JPADraw::zDraw() {
-    /* Nonmatching */
     field_0xc2 |= 0x01;
     if (dc.pbsp->getChildOrder() && dc.pssp != NULL)
         zDrawChild();
@@ -209,18 +594,3 @@ void JPADraw::zDrawChild() {
 void JPADraw::loadYBBMtx(float(*)[4]) {
     /* Nonmatching */
 }
-
-/* 8026C6C0-8026C6FC       .text __dt__16JPADrawClipBoardFv */
-JPADrawClipBoard::~JPADrawClipBoard() {
-    /* Nonmatching */
-}
-
-/* 8026C700-8026D2E0       .text __dt__23JPADrawVisitorContainerFv */
-JPADrawVisitorContainer::~JPADrawVisitorContainer() {
-    /* Nonmatching */
-}
-
-/* 8026D2E0-8026D7B8       .text __ct__23JPADrawVisitorContainerFv */
-JPADrawVisitorContainer::JPADrawVisitorContainer() {
-    /* Nonmatching */
-}
diff --git a/src/JSystem/JParticle/JPADrawSetupTev.cpp b/src/JSystem/JParticle/JPADrawSetupTev.cpp
index 25ae2c23..393a24d6 100644
--- a/src/JSystem/JParticle/JPADrawSetupTev.cpp
+++ b/src/JSystem/JParticle/JPADrawSetupTev.cpp
@@ -4,9 +4,63 @@
 //
 
 #include "JSystem/JParticle/JPADrawSetupTev.h"
-#include "dolphin/types.h"
+#include "JSystem/JParticle/JPABaseShape.h"
+#include "JSystem/JParticle/JPAExTexShape.h"
+#include "dolphin/gx/GX.h"
 
 /* 8026D7B8-8026DBBC       .text setupTev__15JPADrawSetupTevFP12JPABaseShapeP13JPAExTexShape */
-void JPADrawSetupTev::setupTev(JPABaseShape*, JPAExTexShape*) {
-    /* Nonmatching */
+void JPADrawSetupTev::setupTev(JPABaseShape* param_1, JPAExTexShape* param_2) {
+    field_0x1 = 1;
+    field_0x0 = 1;
+    field_0x2 = 0;
+    GXTevColorArg* tevColorArg = param_1->getTevColorArg();
+    GXTevAlphaArg* tevAlphaArg = param_1->getTevAlphaArg();
+    GXSetTevColorIn(GX_TEVSTAGE0, tevColorArg[0], tevColorArg[1], tevColorArg[2], tevColorArg[3]);
+    GXSetTevAlphaIn(GX_TEVSTAGE0, tevAlphaArg[0], tevAlphaArg[1], tevAlphaArg[2], tevAlphaArg[3]);
+    GXSetTevColorOp(GX_TEVSTAGE0, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_TRUE, GX_TEVPREV);
+    GXSetTevAlphaOp(GX_TEVSTAGE0, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_TRUE, GX_TEVPREV);
+    GXSetTevOrder(GX_TEVSTAGE0, GX_TEXCOORD0, GX_TEXMAP0, GX_COLOR_NULL);
+    if (param_2) {
+        GXTevStageID stage = GX_TEVSTAGE1;
+        GXTexCoordID coord = GX_TEXCOORD1;
+        switch (param_2->getIndTexMode()) {
+        case 1:
+            GXSetIndTexOrder(GX_INDTEXSTAGE0, GX_TEXCOORD1, GX_TEXMAP5);
+            GXSetIndTexCoordScale(GX_INDTEXSTAGE0, GX_ITS_1, GX_ITS_1);
+            GXSetIndTexMtx(GX_ITM_0, (f32*)param_2->getIndTexMtx(), param_2->getExpScale());
+            GXSetTevIndirect(GX_TEVSTAGE0, GX_INDTEXSTAGE0, GX_ITF_8, GX_ITB_STU, param_2->getIndTexMtxID(), GX_ITW_OFF, GX_ITW_OFF, GX_FALSE, GX_FALSE, GX_ITBA_OFF);
+            field_0x2++;
+            field_0x1++;
+            coord = GX_TEXCOORD2;
+            break;
+        case 2:
+            GXSetIndTexOrder(GX_INDTEXSTAGE0, GX_TEXCOORD1, GX_TEXMAP5);
+            GXSetIndTexCoordScale(GX_INDTEXSTAGE0, GX_ITS_1, GX_ITS_1);
+            GXSetIndTexMtx(GX_ITM_0, (f32*)param_2->getIndTexMtx(), param_2->getExpScale());
+            GXSetTevIndirect(GX_TEVSTAGE1, GX_INDTEXSTAGE0, GX_ITF_8, GX_ITB_STU, param_2->getIndTexMtxID(), GX_ITW_OFF, GX_ITW_OFF, GX_FALSE, GX_FALSE, GX_ITBA_OFF);
+            GXSetTevOrder(GX_TEVSTAGE1, GX_TEXCOORD2, GX_TEXMAP6, GX_COLOR_NULL);
+            GXSetTevColorIn(GX_TEVSTAGE1, GX_CC_ZERO, GX_CC_TEXC, GX_CC_CPREV, GX_CC_TEXA);
+            GXSetTevAlphaIn(GX_TEVSTAGE1, GX_CA_ZERO, GX_CA_ZERO, GX_CA_ZERO, GX_CA_APREV);
+            GXSetTevColorOp(GX_TEVSTAGE1, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_TRUE, GX_TEVPREV);
+            GXSetTevAlphaOp(GX_TEVSTAGE1, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_TRUE, GX_TEVPREV);
+            field_0x0++;
+            field_0x1 += 2;
+            field_0x2++;
+            stage = GX_TEVSTAGE2;
+            coord = GX_TEXCOORD3;
+            break;
+        }
+        if (param_2->isEnableSecondTex()) {
+            GXSetTevOrder(stage, coord, GX_TEXMAP7, GX_COLOR_NULL);
+            GXSetTevColorIn(stage, GX_CC_ZERO, GX_CC_TEXC, GX_CC_CPREV, GX_CC_ZERO);
+            GXSetTevAlphaIn(stage, GX_CA_ZERO, GX_CA_TEXA, GX_CA_APREV, GX_CA_ZERO);
+            GXSetTevColorOp(stage, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_TRUE, GX_TEVPREV);
+            GXSetTevAlphaOp(stage, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_TRUE, GX_TEVPREV);
+            field_0x0++;
+            field_0x1++;
+        }
+    }
+    GXSetNumTexGens(field_0x1);
+    GXSetNumTevStages(field_0x0);
+    GXSetNumIndStages(field_0x2);
 }
diff --git a/src/JSystem/JParticle/JPADrawVisitor.cpp b/src/JSystem/JParticle/JPADrawVisitor.cpp
index ca5c0c56..6c379304 100644
--- a/src/JSystem/JParticle/JPADrawVisitor.cpp
+++ b/src/JSystem/JParticle/JPADrawVisitor.cpp
@@ -4,7 +4,9 @@
 //
 
 #include "JSystem/JParticle/JPADrawVisitor.h"
-#include "dolphin/types.h"
+#include "JSystem/JGeometry.h"
+
+JPADrawClipBoard* JPADrawContext::pcb;
 
 /* 8025F960-8025FBE4       .text exec__20JPADrawExecLoadExTexFPC14JPADrawContext */
 void JPADrawExecLoadExTex::exec(const JPADrawContext*) {
@@ -470,373 +472,3 @@ void JPADrawCalcChildAlphaOut::calc(const JPADrawContext*, JPABaseParticle*) {
 void JPADrawCalcChildScaleOut::calc(const JPADrawContext*, JPABaseParticle*) {
     /* Nonmatching */
 }
-
-/* 80266450-802664AC       .text __dt__24JPADrawCalcChildScaleOutFv */
-JPADrawCalcChildScaleOut::~JPADrawCalcChildScaleOut() {
-    /* Nonmatching */
-}
-
-/* 802664AC-802664F4       .text __dt__26JPADrawCalcParticleVisitorFv */
-JPADrawCalcParticleVisitor::~JPADrawCalcParticleVisitor() {
-    /* Nonmatching */
-}
-
-/* 802664F4-80266550       .text __dt__24JPADrawCalcChildAlphaOutFv */
-JPADrawCalcChildAlphaOut::~JPADrawCalcChildAlphaOut() {
-    /* Nonmatching */
-}
-
-/* 80266550-802665AC       .text __dt__28JPADrawCalcAlphaFlickMultSinFv */
-JPADrawCalcAlphaFlickMultSin::~JPADrawCalcAlphaFlickMultSin() {
-    /* Nonmatching */
-}
-
-/* 802665AC-80266608       .text __dt__27JPADrawCalcAlphaFlickAddSinFv */
-JPADrawCalcAlphaFlickAddSin::~JPADrawCalcAlphaFlickAddSin() {
-    /* Nonmatching */
-}
-
-/* 80266608-80266664       .text __dt__27JPADrawCalcAlphaFlickNrmSinFv */
-JPADrawCalcAlphaFlickNrmSin::~JPADrawCalcAlphaFlickNrmSin() {
-    /* Nonmatching */
-}
-
-/* 80266664-802666C0       .text __dt__16JPADrawCalcAlphaFv */
-JPADrawCalcAlpha::~JPADrawCalcAlpha() {
-    /* Nonmatching */
-}
-
-/* 802666C0-8026671C       .text __dt__31JPADrawCalcColorCopyFromEmitterFv */
-JPADrawCalcColorCopyFromEmitter::~JPADrawCalcColorCopyFromEmitter() {
-    /* Nonmatching */
-}
-
-/* 8026671C-80266778       .text __dt__33JPADrawCalcScaleAnmTimingReverseYFv */
-JPADrawCalcScaleAnmTimingReverseY::~JPADrawCalcScaleAnmTimingReverseY() {
-    /* Nonmatching */
-}
-
-/* 80266778-802667D4       .text __dt__33JPADrawCalcScaleAnmTimingReverseXFv */
-JPADrawCalcScaleAnmTimingReverseX::~JPADrawCalcScaleAnmTimingReverseX() {
-    /* Nonmatching */
-}
-
-/* 802667D4-80266830       .text __dt__32JPADrawCalcScaleAnmTimingRepeatYFv */
-JPADrawCalcScaleAnmTimingRepeatY::~JPADrawCalcScaleAnmTimingRepeatY() {
-    /* Nonmatching */
-}
-
-/* 80266830-8026688C       .text __dt__32JPADrawCalcScaleAnmTimingRepeatXFv */
-JPADrawCalcScaleAnmTimingRepeatX::~JPADrawCalcScaleAnmTimingRepeatX() {
-    /* Nonmatching */
-}
-
-/* 8026688C-802668E8       .text __dt__31JPADrawCalcScaleAnmTimingNormalFv */
-JPADrawCalcScaleAnmTimingNormal::~JPADrawCalcScaleAnmTimingNormal() {
-    /* Nonmatching */
-}
-
-/* 802668E8-80266944       .text __dt__23JPADrawCalcScaleCopyX2YFv */
-JPADrawCalcScaleCopyX2Y::~JPADrawCalcScaleCopyX2Y() {
-    /* Nonmatching */
-}
-
-/* 80266944-802669A0       .text __dt__24JPADrawCalcScaleYBySpeedFv */
-JPADrawCalcScaleYBySpeed::~JPADrawCalcScaleYBySpeed() {
-    /* Nonmatching */
-}
-
-/* 802669A0-802669FC       .text __dt__24JPADrawCalcScaleXBySpeedFv */
-JPADrawCalcScaleXBySpeed::~JPADrawCalcScaleXBySpeed() {
-    /* Nonmatching */
-}
-
-/* 802669FC-80266A58       .text __dt__17JPADrawCalcScaleYFv */
-JPADrawCalcScaleY::~JPADrawCalcScaleY() {
-    /* Nonmatching */
-}
-
-/* 80266A58-80266AB4       .text __dt__17JPADrawCalcScaleXFv */
-JPADrawCalcScaleX::~JPADrawCalcScaleX() {
-    /* Nonmatching */
-}
-
-/* 80266AB4-80266B30       .text __dt__19JPADrawExecCallBackFv */
-JPADrawExecCallBack::~JPADrawExecCallBack() {
-    /* Nonmatching */
-}
-
-/* 80266B30-80266B78       .text __dt__25JPADrawExecEmitterVisitorFv */
-JPADrawExecEmitterVisitor::~JPADrawExecEmitterVisitor() {
-    /* Nonmatching */
-}
-
-/* 80266B78-80266BC0       .text __dt__26JPADrawExecParticleVisitorFv */
-JPADrawExecParticleVisitor::~JPADrawExecParticleVisitor() {
-    /* Nonmatching */
-}
-
-/* 80266BC0-80266C3C       .text __dt__32JPADrawCalcTextureAnmIndexRandomFv */
-JPADrawCalcTextureAnmIndexRandom::~JPADrawCalcTextureAnmIndexRandom() {
-    /* Nonmatching */
-}
-
-/* 80266C3C-80266C84       .text __dt__25JPADrawCalcEmitterVisitorFv */
-JPADrawCalcEmitterVisitor::~JPADrawCalcEmitterVisitor() {
-    /* Nonmatching */
-}
-
-/* 80266C84-80266D00       .text __dt__31JPADrawCalcTextureAnmIndexMergeFv */
-JPADrawCalcTextureAnmIndexMerge::~JPADrawCalcTextureAnmIndexMerge() {
-    /* Nonmatching */
-}
-
-/* 80266D00-80266D7C       .text __dt__33JPADrawCalcTextureAnmIndexReverseFv */
-JPADrawCalcTextureAnmIndexReverse::~JPADrawCalcTextureAnmIndexReverse() {
-    /* Nonmatching */
-}
-
-/* 80266D7C-80266DF8       .text __dt__32JPADrawCalcTextureAnmIndexRepeatFv */
-JPADrawCalcTextureAnmIndexRepeat::~JPADrawCalcTextureAnmIndexRepeat() {
-    /* Nonmatching */
-}
-
-/* 80266DF8-80266E74       .text __dt__32JPADrawCalcTextureAnmIndexNormalFv */
-JPADrawCalcTextureAnmIndexNormal::~JPADrawCalcTextureAnmIndexNormal() {
-    /* Nonmatching */
-}
-
-/* 80266E74-80266EF0       .text __dt__30JPADrawCalcColorAnmFrameRandomFv */
-JPADrawCalcColorAnmFrameRandom::~JPADrawCalcColorAnmFrameRandom() {
-    /* Nonmatching */
-}
-
-/* 80266EF0-80266F6C       .text __dt__29JPADrawCalcColorAnmFrameMergeFv */
-JPADrawCalcColorAnmFrameMerge::~JPADrawCalcColorAnmFrameMerge() {
-    /* Nonmatching */
-}
-
-/* 80266F6C-80266FE8       .text __dt__31JPADrawCalcColorAnmFrameReverseFv */
-JPADrawCalcColorAnmFrameReverse::~JPADrawCalcColorAnmFrameReverse() {
-    /* Nonmatching */
-}
-
-/* 80266FE8-80267064       .text __dt__30JPADrawCalcColorAnmFrameRepeatFv */
-JPADrawCalcColorAnmFrameRepeat::~JPADrawCalcColorAnmFrameRepeat() {
-    /* Nonmatching */
-}
-
-/* 80267064-802670E0       .text __dt__30JPADrawCalcColorAnmFrameNormalFv */
-JPADrawCalcColorAnmFrameNormal::~JPADrawCalcColorAnmFrameNormal() {
-    /* Nonmatching */
-}
-
-/* 802670E0-8026715C       .text __dt__19JPADrawCalcColorEnvFv */
-JPADrawCalcColorEnv::~JPADrawCalcColorEnv() {
-    /* Nonmatching */
-}
-
-/* 8026715C-802671D8       .text __dt__19JPADrawCalcColorPrmFv */
-JPADrawCalcColorPrm::~JPADrawCalcColorPrm() {
-    /* Nonmatching */
-}
-
-/* 802671D8-80267234       .text __dt__31JPADrawExecRegisterColorChildPEFv */
-JPADrawExecRegisterColorChildPE::~JPADrawExecRegisterColorChildPE() {
-    /* Nonmatching */
-}
-
-/* 80267234-80267290       .text __dt__32JPADrawExecRegisterColorEmitterEFv */
-JPADrawExecRegisterColorEmitterE::~JPADrawExecRegisterColorEmitterE() {
-    /* Nonmatching */
-}
-
-/* 80267290-802672EC       .text __dt__32JPADrawExecRegisterColorEmitterPFv */
-JPADrawExecRegisterColorEmitterP::~JPADrawExecRegisterColorEmitterP() {
-    /* Nonmatching */
-}
-
-/* 802672EC-80267348       .text __dt__33JPADrawExecRegisterColorEmitterPEFv */
-JPADrawExecRegisterColorEmitterPE::~JPADrawExecRegisterColorEmitterPE() {
-    /* Nonmatching */
-}
-
-/* 80267348-802673A4       .text __dt__22JPADrawExecStripeCrossFv */
-JPADrawExecStripeCross::~JPADrawExecStripeCross() {
-    /* Nonmatching */
-}
-
-/* 802673A4-80267400       .text __dt__17JPADrawExecStripeFv */
-JPADrawExecStripe::~JPADrawExecStripe() {
-    /* Nonmatching */
-}
-
-/* 80267400-8026745C       .text __dt__15JPADrawExecLineFv */
-JPADrawExecLine::~JPADrawExecLine() {
-    /* Nonmatching */
-}
-
-/* 8026745C-802674B8       .text __dt__16JPADrawExecPointFv */
-JPADrawExecPoint::~JPADrawExecPoint() {
-    /* Nonmatching */
-}
-
-/* 802674B8-80267514       .text __dt__24JPADrawExecRotationCrossFv */
-JPADrawExecRotationCross::~JPADrawExecRotationCross() {
-    /* Nonmatching */
-}
-
-/* 80267514-80267570       .text __dt__19JPADrawExecRotationFv */
-JPADrawExecRotation::~JPADrawExecRotation() {
-    /* Nonmatching */
-}
-
-/* 80267570-802675CC       .text __dt__23JPADrawExecDirBillBoardFv */
-JPADrawExecDirBillBoard::~JPADrawExecDirBillBoard() {
-    /* Nonmatching */
-}
-
-/* 802675CC-80267628       .text __dt__30JPADrawExecRotDirectionalCrossFv */
-JPADrawExecRotDirectionalCross::~JPADrawExecRotDirectionalCross() {
-    /* Nonmatching */
-}
-
-/* 80267628-80267684       .text __dt__27JPADrawExecDirectionalCrossFv */
-JPADrawExecDirectionalCross::~JPADrawExecDirectionalCross() {
-    /* Nonmatching */
-}
-
-/* 80267684-802676E0       .text __dt__25JPADrawExecRotDirectionalFv */
-JPADrawExecRotDirectional::~JPADrawExecRotDirectional() {
-    /* Nonmatching */
-}
-
-/* 802676E0-8026773C       .text __dt__22JPADrawExecDirectionalFv */
-JPADrawExecDirectional::~JPADrawExecDirectional() {
-    /* Nonmatching */
-}
-
-/* 8026773C-80267798       .text __dt__24JPADrawExecRotYBillBoardFv */
-JPADrawExecRotYBillBoard::~JPADrawExecRotYBillBoard() {
-    /* Nonmatching */
-}
-
-/* 80267798-802677F4       .text __dt__21JPADrawExecYBillBoardFv */
-JPADrawExecYBillBoard::~JPADrawExecYBillBoard() {
-    /* Nonmatching */
-}
-
-/* 802677F4-80267850       .text __dt__23JPADrawExecRotBillBoardFv */
-JPADrawExecRotBillBoard::~JPADrawExecRotBillBoard() {
-    /* Nonmatching */
-}
-
-/* 80267850-802678AC       .text __dt__20JPADrawExecBillBoardFv */
-JPADrawExecBillBoard::~JPADrawExecBillBoard() {
-    /* Nonmatching */
-}
-
-/* 802678AC-80267908       .text __dt__26JPADrawExecRegisterPrmAEnvFv */
-JPADrawExecRegisterPrmAEnv::~JPADrawExecRegisterPrmAEnv() {
-    /* Nonmatching */
-}
-
-/* 80267908-80267964       .text __dt__26JPADrawExecRegisterPrmCEnvFv */
-JPADrawExecRegisterPrmCEnv::~JPADrawExecRegisterPrmCEnv() {
-    /* Nonmatching */
-}
-
-/* 80267964-802679C0       .text __dt__30JPADrawExecRegisterEnvColorAnmFv */
-JPADrawExecRegisterEnvColorAnm::~JPADrawExecRegisterEnvColorAnm() {
-    /* Nonmatching */
-}
-
-/* 802679C0-80267A1C       .text __dt__30JPADrawExecRegisterPrmAlphaAnmFv */
-JPADrawExecRegisterPrmAlphaAnm::~JPADrawExecRegisterPrmAlphaAnm() {
-    /* Nonmatching */
-}
-
-/* 80267A1C-80267A78       .text __dt__30JPADrawExecRegisterPrmColorAnmFv */
-JPADrawExecRegisterPrmColorAnm::~JPADrawExecRegisterPrmColorAnm() {
-    /* Nonmatching */
-}
-
-/* 80267A78-80267AD4       .text __dt__23JPADrawExecSetLineWidthFv */
-JPADrawExecSetLineWidth::~JPADrawExecSetLineWidth() {
-    /* Nonmatching */
-}
-
-/* 80267AD4-80267B30       .text __dt__23JPADrawExecSetPointSizeFv */
-JPADrawExecSetPointSize::~JPADrawExecSetPointSize() {
-    /* Nonmatching */
-}
-
-/* 80267B30-80267BAC       .text __dt__22JPADrawExecLoadTextureFv */
-JPADrawExecLoadTexture::~JPADrawExecLoadTexture() {
-    /* Nonmatching */
-}
-
-/* 80267BAC-80267C08       .text __dt__29JPADrawExecLoadDefaultTextureFv */
-JPADrawExecLoadDefaultTexture::~JPADrawExecLoadDefaultTexture() {
-    /* Nonmatching */
-}
-
-/* 80267C08-80267C84       .text __dt__20JPADrawExecSetTexMtxFv */
-JPADrawExecSetTexMtx::~JPADrawExecSetTexMtx() {
-    /* Nonmatching */
-}
-
-/* 80267C84-80267CE0       .text __dt__20JPADrawExecGenIdtMtxFv */
-JPADrawExecGenIdtMtx::~JPADrawExecGenIdtMtx() {
-    /* Nonmatching */
-}
-
-/* 80267CE0-80267D3C       .text __dt__21JPADrawExecGenTexMtx0Fv */
-JPADrawExecGenTexMtx0::~JPADrawExecGenTexMtx0() {
-    /* Nonmatching */
-}
-
-/* 80267D3C-80267D98       .text __dt__23JPADrawExecGenPrjTexMtxFv */
-JPADrawExecGenPrjTexMtx::~JPADrawExecGenPrjTexMtx() {
-    /* Nonmatching */
-}
-
-/* 80267D98-80267DF4       .text __dt__20JPADrawExecGenPrjMtxFv */
-JPADrawExecGenPrjMtx::~JPADrawExecGenPrjMtx() {
-    /* Nonmatching */
-}
-
-/* 80267DF4-80267E50       .text __dt__20JPADrawExecLoadExTexFv */
-JPADrawExecLoadExTex::~JPADrawExecLoadExTex() {
-    /* Nonmatching */
-}
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-