Merge remote-tracking branch 'Upstream/master'

22 files changed, 652 insertions, 151 deletions

diff --git a/include/JSystem/J2DGraph/J2DAnimation.h b/include/JSystem/J2DGraph/J2DAnimation.h
index 41e7f7f92c..654c997b51 100644
--- a/include/JSystem/J2DGraph/J2DAnimation.h
+++ b/include/JSystem/J2DGraph/J2DAnimation.h
@@ -1,20 +1,24 @@
 #ifndef J2DANIMATION_H
 #define J2DANIMATION_H
 
+#include "JSystem/J3DGraphAnimator/J3DAnimation.h"
 #include "JSystem/JUtility/JUTNameTab.h"
 #include "JSystem/JUtility/JUTTexture.h"
 #include "dolphin/gx/GX.h"
+#include "dolphin/os/OS.h"
 #include "dolphin/types.h"
 
 class J2DScreen;
 
 class J2DAnmBase {
 public:
-    /* 80053C94 */ virtual ~J2DAnmBase();
+    /* 80053C94 */ virtual ~J2DAnmBase() {}
     /* 800569B0 */ virtual void searchUpdateMaterialID(J2DScreen*);
 
     s16 getFrameMax() const { return mFrameMax; }
     void setFrame(f32 frame) { mFrame = frame; }
+    f32 getFrame() const { return mFrame; }
+    s32 getKind() const { return mKind; }
 
 private:
     /* 0x0 */  // vtable
@@ -26,7 +30,7 @@ private:
 
 class J2DAnmVtxColor : public J2DAnmBase {
 public:
-    /* 8030A358 */ virtual ~J2DAnmVtxColor();
+    /* 8030A358 */ virtual ~J2DAnmVtxColor() {}
     /* 8030363C */ virtual void getColor(u8, u16, _GXColor*) const;
 
 private:
@@ -38,31 +42,54 @@ private:
 struct J3DTransformInfo;
 struct J3DTextureSRTInfo;
 
+struct J2DAnmVtxColorKeyInfo {
+    J3DAnmKeyTableBase mRInfo;
+    J3DAnmKeyTableBase mGInfo;
+    J3DAnmKeyTableBase mBInfo;
+    J3DAnmKeyTableBase mAInfo;
+};  // Size = 0x18
+
 class J2DAnmVtxColorKey : public J2DAnmVtxColor {
-    /* 8030CC20 */ virtual ~J2DAnmVtxColorKey();
+    /* 8030CC20 */ virtual ~J2DAnmVtxColorKey() {}
     /* 8030B704 */ virtual void getColor(u8, u16, _GXColor*) const;
 
 private:
-    /* 0x24 */ void* field_0x24[2];
-    /* 0x2C */ void* field_0x2c;
-    /* 0x30 */ void* field_0x30;
-    /* 0x34 */ void* field_0x34;
-    /* 0x38 */ void* field_0x38;
+    /* 0x24 */ J2DAnmVtxColorKeyInfo* mInfoTable[2];
+    /* 0x2C */ s16* mRValues;
+    /* 0x30 */ s16* mGValues;
+    /* 0x34 */ s16* mBValues;
+    /* 0x38 */ s16* mAValues;
 };  // Size: 0x3C
 
+struct J2DAnmVtxColorFullInfo {
+    /* 0x00 */ u16 mRMaxFrame;
+    /* 0x02 */ u16 mROffset;
+    /* 0x04 */ u16 mGMaxFrame;
+    /* 0x06 */ u16 mGOffset;
+    /* 0x08 */ u16 mBMaxFrame;
+    /* 0x0A */ u16 mBOffset;
+    /* 0x0C */ u16 mAMaxFrame;
+    /* 0x0E */ u16 mAOffset;
+};  // Size = 0x10
+
 class J2DAnmVtxColorFull : public J2DAnmVtxColor {
 public:
-    /* 8030CC8C */ virtual ~J2DAnmVtxColorFull();
+    /* 8030CC8C */ virtual ~J2DAnmVtxColorFull() {}
     /* 8030B4C4 */ virtual void getColor(u8, u16, _GXColor*) const;
 
 private:
-    /* 0x24 */ void* field_0x24[2];
-    /* 0x2C */ void* field_0x2c;
-    /* 0x30 */ void* field_0x30;
-    /* 0x34 */ void* field_0x34;
-    /* 0x38 */ void* field_0x38;
+    /* 0x24 */ J2DAnmVtxColorFullInfo* mInfoTable[2];
+    /* 0x2C */ u8* mRValues;
+    /* 0x30 */ u8* mGValues;
+    /* 0x34 */ u8* mBValues;
+    /* 0x38 */ u8* mAValues;
 };  // Size: 0x3C
 
+struct J2DAnmVisibilityFullInfo {
+    u16 _0;
+    u16 _2;
+};  // Size = 0x4
+
 class J2DAnmVisibilityFull : public J2DAnmBase {
 public:
     /* 8030A3B4 */ virtual ~J2DAnmVisibilityFull();
@@ -71,60 +98,84 @@ public:
 private:
     /* 0x10 */ u16 field_0x10;
     /* 0x12 */ u16 field_0x12;
-    /* 0x14 */ void* field_0x14;
-    /* 0x18 */ void* field_0x18;
+    /* 0x14 */ J2DAnmVisibilityFullInfo* field_0x14;
+    /* 0x18 */ u8* field_0x18;
 };  // Size: 0x1C
 
 class J2DAnmTransform : public J2DAnmBase {
 public:
-    /* 80184370 */ virtual ~J2DAnmTransform();
+    /* 80184370 */ virtual ~J2DAnmTransform() {}
     /* 80191130 */ virtual void getTransform(u16, J3DTransformInfo*) const;
 
-private:
-    /* 0x10 */ f32* field_0x10;
-    /* 0x14 */ s16* field_0x14;
-    /* 0x18 */ f32* field_0x18;
+protected:
+    /* 0x10 */ f32* mScaleValues;
+    /* 0x14 */ s16* mRotationValues;
+    /* 0x18 */ f32* mTranslateValues;
 };  // Size: 0x1C
 
+struct J2DAnmTransformKeyInfo {
+    J3DAnmKeyTableBase mScaleInfo;
+    J3DAnmKeyTableBase mRotationInfo;
+    J3DAnmKeyTableBase mTranslateInfo;
+};  // Size = 0x12
+
 class J2DAnmTransformKey : public J2DAnmTransform {
 public:
-    /* 801959C0 */ virtual ~J2DAnmTransformKey();
-    /* 8030CD7C */ virtual void getTransform(u16, J3DTransformInfo*) const;
+    /* 801959C0 */ virtual ~J2DAnmTransformKey() {}
+    /* 8030CD7C */ virtual void getTransform(u16 p1, J3DTransformInfo* pInfo) const {
+        this->calcTransform(getFrame(), p1, pInfo);
+    }
     /* 8030AAFC */ virtual void calcTransform(f32, u16, J3DTransformInfo*) const;
 
 private:
     /* 0x1C */ u8 field_0x1c[8];
-    /* 0x24 */ void* field_0x24;
-    /* 0x28 */ void* field_0x28;
+    /* 0x24 */ u32 field_0x24;
+    /* 0x28 */ J2DAnmTransformKeyInfo* mInfoTable;
 };
 
+struct J2DAnmTransformFullInfo {
+    /* 0x00 */ u16 mScaleMaxFrame;
+    /* 0x02 */ u16 mScaleOffset;
+    /* 0x04 */ u16 mRotationMaxFrame;
+    /* 0x06 */ u16 mRotationOffset;
+    /* 0x08 */ u16 mTranslateMaxFrame;
+    /* 0x0A */ u16 mTranslateOffset;
+};  // Size = 0xC
+
 class J2DAnmTransformFull : public J2DAnmTransform {
 public:
-    /* 8030CDAC */ virtual ~J2DAnmTransformFull();
+    /* 8030CDAC */ virtual ~J2DAnmTransformFull() {}
     /* 8030A590 */ virtual void getTransform(u16, J3DTransformInfo*) const;
 
 private:
     /* 0x1C */ u8 field_0x1c[6];
     /* 0x22 */ u16 field_0x22;
-    /* 0x24 */ void* field_0x24;
+    /* 0x24 */ J2DAnmTransformFullInfo* mTableInfo;
 };
 
+struct J2DAnmTextureSRTKeyInfo {
+    J3DAnmKeyTableBase mScaleInfo;
+    J3DAnmKeyTableBase mRotationInfo;
+    J3DAnmKeyTableBase mTranslationInfo;
+};  // Size = 0x12
+
 class J2DAnmTextureSRTKey : public J2DAnmBase {
 public:
     /* 8030B9F0 */ void calcTransform(f32, u16, J3DTextureSRTInfo*) const;
 
-    /* 80184274 */ virtual ~J2DAnmTextureSRTKey();
+    /* 80184274 */ virtual ~J2DAnmTextureSRTKey() {}
     /* 8030BC60 */ virtual void searchUpdateMaterialID(J2DScreen*);
+    u16 getUpdateMaterialNum() const { return mUpdateMaterialNum / 3; }
 
 private:
     /* 0x10 */ int field_0x10;
-    /* 0x14 */ int field_0x14;
+    /* 0x14 */ J2DAnmTextureSRTKeyInfo* mInfoTable;
     /* 0x18 */ u16 mUpdateMaterialNum;
     /* 0x1A */ u16 field_0x1a;
     /* 0x1C */ u16 field_0x1c;
-    /* 0x20 */ int field_0x20;
-    /* 0x24 */ int field_0x24;
-    /* 0x28 */ int field_0x28;
+    /* 0x20 */ f32* mScaleValues;
+    /* 0x24 */ s16* mRotationValues;
+    /* 0x28 */ f32* mTranslationValues;
     /* 0x2C */ u8* mUpdateTexMtxID;
     /* 0x30 */ u16* mUpdateMaterialID;
     /* 0x34 */ JUTNameTab field_0x34;
@@ -143,6 +194,13 @@ private:
     /* 0x7C */ int field_0x7c;
 };
 
+struct J2DAnmTexPatternInfo {
+    /* 0x00 */ u16 mMaxFrame;
+    /* 0x02 */ u16 mOffset;
+    /* 0x04 */ u16 _4;
+    /* 0x06 */ u16 _6;
+};  // Size = 0x8
+
 class J2DAnmTexPattern : public J2DAnmBase {
 public:
     struct J2DAnmTexPatternTIMGPointer {
@@ -154,15 +212,16 @@ public:
     };  // Size: 0x8
 
     /* 8030BEE8 */ void getTexNo(u16, u16*) const;
-    /* 8030BF9C */ void getResTIMG(u16) const;
-    /* 8030BFF0 */ void getPalette(u16) const;
+    /* 8030BF9C */ ResTIMG* getResTIMG(u16) const;
+    /* 8030BFF0 */ JUTPalette* getPalette(u16) const;
 
-    /* 8030CB90 */ virtual ~J2DAnmTexPattern();
+    /* 8030CB90 */ virtual ~J2DAnmTexPattern() { delete[] mTIMGPtrArray; }
     /* 8030BD10 */ virtual void searchUpdateMaterialID(J2DScreen*);
+    u16 getUpdateMaterialNum() const { return mUpdateMaterialNum; }
 
 private:
-    /* 0x10 */ int field_0x10;
-    /* 0x14 */ void* mAnmTable;
+    /* 0x10 */ u16* mValues;
+    /* 0x14 */ J2DAnmTexPatternInfo* mAnmTable;
     /* 0x18 */ u8 field_0x18[2];
     /* 0x1A */ u16 mUpdateMaterialNum;
     /* 0x1C */ u16* mUpdaterMaterialID;
@@ -170,13 +229,21 @@ private:
     /* 0x30 */ J2DAnmTexPatternTIMGPointer* mTIMGPtrArray;
 };
 
+struct J2DAnmTevRegKeyInfo {
+    /* 0x00 */ J3DAnmKeyTableBase mRTable;
+    /* 0x06 */ J3DAnmKeyTableBase mGTable;
+    /* 0x0C */ J3DAnmKeyTableBase mBTable;
+    /* 0x12 */ J3DAnmKeyTableBase mATable;
+    /* 0x18 */ u8 _18[4];
+};  // Size = 0x1C
+
 class J2DAnmTevRegKey : public J2DAnmBase {
 public:
     /* 8030C0F0 */ void getTevColorReg(u16, _GXColorS10*) const;
     /* 8030C3B4 */ void getTevKonstReg(u16, _GXColor*) const;
 
-    /* 801841EC */ virtual ~J2DAnmTevRegKey();
-    /* 8030C678 */ virtual void searchUpdateMaterialID(J2DScreen*);
+    /* 801841EC */ virtual ~J2DAnmTevRegKey() {}
+    /* 8030C678 */ virtual void searchUpdateMaterialID(J2DScreen* pScreen);
 
 private:
     /* 0x10 */ u16 mCRegUpdateMaterialNum;
@@ -193,27 +260,28 @@ private:
     /* 0x28 */ JUTNameTab field_0x28;
     /* 0x38 */ u16* mKRegUpdateMaterialID;
     /* 0x3C */ JUTNameTab field_0x3c;
-    /* 0x4C */ void* mAnmCRegKeyTable;
-    /* 0x50 */ void* mAnmKRegKeyTable;
-    /* 0x54 */ int field_0x54;
-    /* 0x58 */ int field_0x58;
-    /* 0x5C */ int field_0x5c;
-    /* 0x60 */ int field_0x60;
-    /* 0x64 */ int field_0x64;
-    /* 0x68 */ int field_0x68;
-    /* 0x6C */ int field_0x6c;
-    /* 0x70 */ int field_0x70;
+    /* 0x4C */ J2DAnmTevRegKeyInfo* mAnmCRegKeyTable;
+    /* 0x50 */ J2DAnmTevRegKeyInfo* mAnmKRegKeyTable;
+    /* 0x54 */ s16* mCRValues;
+    /* 0x58 */ s16* mCGValues;
+    /* 0x5C */ s16* mCBValues;
+    /* 0x60 */ s16* mCAValues;
+    /* 0x64 */ s16* mKRValues;
+    /* 0x68 */ s16* mKGValues;
+    /* 0x6C */ s16* mKBValues;
+    /* 0x70 */ s16* mKAValues;
 };
 
 class J2DAnmColor : public J2DAnmBase {
 public:
-    /* 801842FC */ virtual ~J2DAnmColor();
+    /* 801842FC */ virtual ~J2DAnmColor() {}
     /* 8030AF24 */ virtual void searchUpdateMaterialID(J2DScreen*);
     /* 802EB390 */ virtual void getColor(u16, _GXColor*) const;
+    u16 getUpdateMaterialNum() const { return mUpdateMaterialNum; }
 
 private:
     /* 0x10 */ u16 field_0x10;
-    /* 0x10 */ u16 field_0x12;
+    /* 0x12 */ u16 field_0x12;
     /* 0x14 */ u16 field_0x14;
     /* 0x16 */ u16 field_0x16;
     /* 0x18 */ u16 mUpdateMaterialNum;
@@ -221,30 +289,135 @@ private:
     /* 0x20 */ JUTNameTab field_0x20;
 };  // Size: 0x30
 
+struct J2DAnmColorKeyInfo {
+    J3DAnmKeyTableBase mRInfo;
+    J3DAnmKeyTableBase mGInfo;
+    J3DAnmKeyTableBase mBInfo;
+    J3DAnmKeyTableBase mAInfo;
+};  // Size = 0x18
+
 class J2DAnmColorKey : public J2DAnmColor {
 public:
-    /* 80239BE0 */ virtual ~J2DAnmColorKey();
+    /* 80239BE0 */ virtual ~J2DAnmColorKey() {}
     /* 8030B200 */ virtual void getColor(u16, _GXColor*) const;
 
 private:
-    /* 0x30 */ int field_0x30;
-    /* 0x34 */ int field_0x34;
-    /* 0x38 */ int field_0x38;
-    /* 0x3C */ int field_0x3c;
-    /* 0x40 */ int field_0x40;
+    /* 0x30 */ s16* mRValues;
+    /* 0x34 */ s16* mGValues;
+    /* 0x38 */ s16* mBValues;
+    /* 0x3C */ s16* mAValues;
+    /* 0x40 */ J2DAnmColorKeyInfo* mInfoTable;
 };
 
+struct J2DAnmColorFullInfo {
+    /* 0x00 */ u16 mRMaxFrame;
+    /* 0x02 */ u16 mROffset;
+    /* 0x04 */ u16 mGMaxFrame;
+    /* 0x06 */ u16 mGOffset;
+    /* 0x08 */ u16 mBMaxFrame;
+    /* 0x0A */ u16 mBOffset;
+    /* 0x0C */ u16 mAMaxFrame;
+    /* 0x0E */ u16 mAOffset;
+};  // Size = 0x10
+
 class J2DAnmColorFull : public J2DAnmColor {
 public:
-    /* 8030CCF8 */ virtual ~J2DAnmColorFull();
+    /* 8030CCF8 */ virtual ~J2DAnmColorFull() {}
     /* 8030AFC8 */ virtual void getColor(u16, _GXColor*) const;
 
 private:
-    /* 0x30 */ int field_0x30;
-    /* 0x34 */ int field_0x34;
-    /* 0x38 */ int field_0x38;
-    /* 0x3C */ int field_0x3c;
-    /* 0x40 */ int field_0x40;
+    /* 0x30 */ u8* mRValues;
+    /* 0x34 */ u8* mGValues;
+    /* 0x38 */ u8* mBValues;
+    /* 0x3C */ u8* mAValues;
+    /* 0x40 */ J2DAnmColorFullInfo* mInfoTable;
 };
 
+template <typename T>
+inline f32 J2DHermiteInterpolation(f32, T*, T*, T*, T*, T*, T*);
+
+inline f32 JMAHermiteInterpolation(register f32 p1, register f32 p2, register f32 p3,
+                                   register f32 p4, register f32 p5, register f32 p6,
+                                   register f32 p7) {
+    register f32 ff25;
+    register f32 ff31;
+    register f32 ff30;
+    register f32 ff29;
+    register f32 ff28;
+    register f32 ff27;
+    register f32 ff26;
+    // clang-format off
+    asm {
+        fsubs   ff31, p1, p2
+        fsubs   ff30, p5, p2
+        fdivs   ff29, ff31, ff30
+        fmuls   ff28,ff29,ff29
+        fadds   ff25,ff29,ff29
+        fsubs   ff27,ff28,ff29
+        fsubs   ff30, p3, p6
+        fmsubs  ff26,ff25,ff27,ff28
+        fmadds  ff25,p4,ff27,p4
+        fmadds  ff26,ff26,ff30,p3
+        fmadds  ff25,p7,ff27,ff25
+        fmsubs  ff25,ff29,p4,ff25
+        fnmsubs ff25,ff31,ff25,ff26
+
+    }
+    // clang-format on
+    return ff25;
+}
+
+template <>
+inline f32 J2DHermiteInterpolation<f32>(f32 f1, f32* f2, f32* f3, f32* f4, f32* f5, f32* f6,
+                                        f32* f7) {
+    return JMAHermiteInterpolation(f1, *f2, *f3, *f4, *f5, *f6, *f7);
+}
+
+template <>
+inline f32 J2DHermiteInterpolation<s16>(register f32 pp1, register s16* pp2, register s16* pp3,
+                                        register s16* pp4, register s16* pp5, register s16* pp6,
+                                        register s16* pp7) {
+    register f32 p1 = pp1;
+    register f32 ff8;
+    register f32 ff7;
+    register f32 ff6;
+    register f32 ff5;
+    register f32 ff4;
+    register f32 ff3;
+    register f32 ff2;
+    register f32 ff0;
+    register f32 fout;
+    register s16* p2 = pp2;
+    register s16* p3 = pp3;
+    register s16* p4 = pp4;
+    register s16* p5 = pp5;
+    register s16* p6 = pp6;
+    register s16* p7 = pp7;
+    // clang-format off
+    asm {
+        psq_l ff2, 0(p2), 0x1, 5
+        psq_l ff0, 0(p5), 0x1, 5
+        psq_l ff7, 0(p3), 0x1, 5
+        fsubs ff5, ff0, ff2
+        psq_l ff6, 0(p6), 0x1, 5
+        fsubs ff3, p1, ff2
+        psq_l ff0, 0(p7), 0x1, 5
+        fsubs ff4, ff6, ff7
+        fdivs ff3, ff3, ff5
+        psq_l fout, 0(p4), 0x1, 5
+        fmadds ff0, ff0, ff5, ff7
+        fmuls ff2, ff3, ff3
+        fnmsubs ff4, ff5, fout, ff4
+        fsubs ff0, ff0, ff6
+        fsubs ff0, ff0, ff4
+        fmuls ff0, ff2, ff0
+        fmadds fout, ff5, fout, ff0
+        fmadds fout, fout, ff3, ff7
+        fmadds fout, ff4, ff2, fout
+        fsubs fout, fout, ff0
+    }
+    // clang-format on
+    return fout;
+}
+
 #endif /* J2DANIMATION_H */
diff --git a/include/JSystem/J2DGraph/J2DGrafContext.h b/include/JSystem/J2DGraph/J2DGrafContext.h
index 7d7efa7a65..be64fcc38f 100644
--- a/include/JSystem/J2DGraph/J2DGrafContext.h
+++ b/include/JSystem/J2DGraph/J2DGrafContext.h
@@ -1,6 +1,7 @@
 #ifndef J2DGRAFCONTEXT_H
 #define J2DGRAFCONTEXT_H
 
+#include "JSystem/J2DGraph/J2DMatBlock.h"
 #include "JSystem/JGeometry.h"
 #include "JSystem/JUtility/TColor.h"
 #include "dolphin/mtx/mtx.h"
@@ -35,7 +36,7 @@ public:
     /* 802E9664 */ virtual s32 getGrafType() const { return 0; }
     /* 802E966C */ virtual void setLookat() {}
 
-protected:
+public:
     /* 0x04 */ JGeometry::TBox2<f32> mBounds;
     /* 0x14 */ JGeometry::TBox2<f32> mScissorBounds;
     /* 0x24 */ JUtility::TColor mColorTL;
@@ -46,15 +47,9 @@ protected:
     /* 0x38 */ JGeometry::TVec2<f32> mPrevPos;
     /* 0x40 */ Mtx44 mMtx44;
     /* 0x80 */ Mtx mPosMtx;
-    /* 0xB0 */ u8 field_0xb0;
-    /* 0xB1 */ u8 field_0xb1;
-    /* 0xB2 */ u8 field_0xb2;
-    /* 0xB3 */ u8 mLineBlendMode;
-    /* 0xB4 */ u8 mLineSrcBlendFactor;
-    /* 0xB5 */ u8 mLineDstBlendFactor;
-    /* 0xB6 */ u8 mBoxBlendMode;
-    /* 0xB7 */ u8 mBoxSrcBlendFactor;
-    /* 0xB8 */ u8 mBoxDstBlendFactor;
+    /* 0xB0 */ J2DBlendInfo field_0xb0;
+    /* 0xB3 */ J2DBlendInfo mLinePart;
+    /* 0xB6 */ J2DBlendInfo mBoxPart;
 };
 
 #endif /* J2DGRAFCONTEXT_H */
diff --git a/include/JSystem/J2DGraph/J2DManage.h b/include/JSystem/J2DGraph/J2DManage.h
index 6222e2139b..96a9e5ebc0 100644
--- a/include/JSystem/J2DGraph/J2DManage.h
+++ b/include/JSystem/J2DGraph/J2DManage.h
@@ -5,14 +5,26 @@
 #include "dolphin/types.h"
 
 struct J2DResReference {
-    /* 8030CF10 */ void getResReference(u16) const;
-    /* 8030CF44 */ void getName(u16) const;
+    /* 0x00 */ u16 mCount;
+    /* 0x02 */ u16 mOffsets[1];
+
+    /* 8030CF10 */ s8* getResReference(u16) const;
+    /* 8030CF44 */ char* getName(u16) const;
+};
+
+struct J2DataManageLink {
+    /* 0x00 */ void* mData;
+    /* 0x04 */ char* mName;
+    /* 0x08 */ J2DataManageLink* mNext;
 };
 
 class J2DDataManage {
+private:
+    /* 0x00 */ J2DataManageLink* mList;
+
 public:
-    /* 8030CE18 */ void get(char const*);
-    /* 8030CE7C */ void get(JSUInputStream*);
+    /* 8030CE18 */ void* get(char const*);
+    /* 8030CE7C */ void* get(JSUInputStream*);
 };
 
 #endif /* J2DMANAGE_H */
diff --git a/include/JSystem/J2DGraph/J2DMatBlock.h b/include/JSystem/J2DGraph/J2DMatBlock.h
index 0333028fb5..810fccc091 100644
--- a/include/JSystem/J2DGraph/J2DMatBlock.h
+++ b/include/JSystem/J2DGraph/J2DMatBlock.h
@@ -414,11 +414,11 @@ struct J2DBlendInfo {
     /* 0x0 */ u8 mType;
     /* 0x1 */ u8 mSrcFactor;
     /* 0x2 */ u8 mDstFactor;
-    /* 0x3 */ u8 mOp;
 };
 
 struct J2DBlend {
     /* 0x0 */ J2DBlendInfo mBlendInfo;
+    /* 0x3 */ u8 mOp;
 };
 
 class J2DPEBlock {
diff --git a/include/JSystem/J2DGraph/J2DPane.h b/include/JSystem/J2DGraph/J2DPane.h
index a58858aa85..73a920ee42 100644
--- a/include/JSystem/J2DGraph/J2DPane.h
+++ b/include/JSystem/J2DGraph/J2DPane.h
@@ -31,7 +31,7 @@ public:
     J2DPane(J2DPane* other, JSURandomInputStream* stream, u8 arg3);
     virtual ~J2DPane();
 
-    /* 0x0c */ virtual s32 getTypeID() const;
+    /* 0x0c */ virtual s32 getTypeID() const { return 16; }
     /* 0x10 */ virtual void move(f32 x, f32 y);
     /* 0x14 */ virtual void add(f32 x, f32 y);
     /* 0x18 */ virtual void resize(f32 x, f32 y);
@@ -53,12 +53,12 @@ public:
     /* 0x58 */ virtual void rewriteAlpha();
     /* 0x5c */ virtual void setAnimation(J2DAnmBase* anm);
     /* 0x60 */ virtual void setAnimation(J2DAnmTransform* anm);
-    /* 0x64 */ virtual void setAnimation(J2DAnmColor* anm);
-    /* 0x68 */ virtual void setAnimation(J2DAnmTexPattern* anm);
-    /* 0x6c */ virtual void setAnimation(J2DAnmTextureSRTKey* anm);
-    /* 0x70 */ virtual void setAnimation(J2DAnmTevRegKey* anm);
-    /* 0x74 */ virtual void setAnimation(J2DAnmVisibilityFull* anm);
-    /* 0x78 */ virtual void setAnimation(J2DAnmVtxColor* anm);
+    /* 0x64 */ virtual void setAnimation(J2DAnmColor* anm) {}
+    /* 0x68 */ virtual void setAnimation(J2DAnmTexPattern* anm) {}
+    /* 0x6c */ virtual void setAnimation(J2DAnmTextureSRTKey* anm) {}
+    /* 0x70 */ virtual void setAnimation(J2DAnmTevRegKey* anm) {}
+    /* 0x74 */ virtual void setAnimation(J2DAnmVisibilityFull* anm) {}
+    /* 0x78 */ virtual void setAnimation(J2DAnmVtxColor* anm) {}
     /* 0x7c */ virtual const J2DAnmTransform* animationTransform(const J2DAnmTransform* transform);
     /* 0x80 */ virtual void setVisibileAnimation(J2DAnmVisibilityFull* visibility);
     /* 0x84 */ virtual void setAnimationVF(J2DAnmVisibilityFull* visibility);
@@ -119,7 +119,7 @@ public:
     void clip(const JGeometry::TBox2<f32>& bounds);
     void setBasePosition(J2DBasePosition position);
     void setInfluencedAlpha(bool arg1, bool arg2);
-    void getGlbVtx(u8 arg1) const;
+    JGeometry::TVec3<f32> getGlbVtx(u8 arg1) const;
     J2DPane* getFirstChildPane();
     J2DPane* getNextChildPane();
     J2DPane* getParentPane();
@@ -130,7 +130,7 @@ public:
     void updateTransform(const J2DAnmTransform* transform);
     void setUserInfo(u64 info) { mUserInfoTag = info; }
 
-    static f32 static_mBounds[4];
+    static JGeometry::TBox2<f32> static_mBounds;
 
 public:
     /* 0x04 */ u16 _4;
diff --git a/include/JSystem/J2DGraph/J2DScreen.h b/include/JSystem/J2DGraph/J2DScreen.h
index 1e6527babf..486f1164c2 100644
--- a/include/JSystem/J2DGraph/J2DScreen.h
+++ b/include/JSystem/J2DGraph/J2DScreen.h
@@ -49,9 +49,11 @@ public:
     /* 802F9640 */ static void* getNameResource(char const*);
     /* 802F9690 */ void animation();
 
+    static J2DDataManage* getDataManage() { return mDataManage; }
+
     static J2DDataManage* mDataManage;
 
-private:
+    // private:
     /* 0x100 */ bool mScissor;
     /* 0x102 */ u16 mMaterialNum;
     /* 0x104 */ J2DMaterial* mMaterials;
diff --git a/include/JSystem/J3DGraphAnimator/J3DAnimation.h b/include/JSystem/J3DGraphAnimator/J3DAnimation.h
index 18ff4ee9e2..15ded86a06 100644
--- a/include/JSystem/J3DGraphAnimator/J3DAnimation.h
+++ b/include/JSystem/J3DGraphAnimator/J3DAnimation.h
@@ -40,6 +40,12 @@ private:
 };  // Size: 0x20
 
 class J3DAnmTransformKey : public J3DAnmTransform {
+public:
+    J3DAnmTransformKey() : J3DAnmTransform(0, NULL, NULL, NULL) {
+        field_0x20 = 0;
+        field_0x24 = 0;
+    }
+
     /* 80329A34 */ void calcTransform(f32, u16, J3DTransformInfo*) const;
 
     /* 8003B8D0 */ virtual ~J3DAnmTransformKey();
@@ -69,7 +75,11 @@ class J3DAnmTransformFullWithLerp : public J3DAnmTransformFull {
 struct J3DTextureSRTInfo;
 struct J3DModelData;
 struct J3DMaterialTable;
-struct J3DAnmKeyTableBase {};
+struct J3DAnmKeyTableBase {
+    /* 0x00 */ u16 mMaxFrame;
+    /* 0x02 */ u16 mOffset;
+    /* 0x04 */ u16 mType;
+};  // Size = 0x6
 
 class J3DAnmTextureSRTKey : public J3DAnmBase {
 public:
diff --git a/include/JSystem/J3DGraphBase/J3DShape.h b/include/JSystem/J3DGraphBase/J3DShape.h
index 1fd8e7c56c..b0576077c0 100644
--- a/include/JSystem/J3DGraphBase/J3DShape.h
+++ b/include/JSystem/J3DGraphBase/J3DShape.h
@@ -24,10 +24,11 @@ class J3DVertexData;
 class J3DDrawMtxData;
 
 enum J3DShpFlag {
+    J3DShpFlag_Visible    = 0x0001,
     J3DShpFlag_SkinPosCpu = 0x0004,
     J3DShpFlag_SkinNrmCpu = 0x0008,
-    J3DShpFlag_Hidden = 0x0010,
-    J3DShpFlag_EnableLod = 0x0100,
+    J3DShpFlag_Hidden     = 0x0010,
+    J3DShpFlag_EnableLod  = 0x0100,
 };
 
 class J3DShape {
@@ -56,8 +57,8 @@ public:
     void setVertexDataPointer(J3DVertexData* pVtxData) { mVertexData = pVtxData; }
     void* getVcdVatCmd() const { return mVcdVatCmd; }
     void setVcdVatCmd(void* pVatCmd) { mVcdVatCmd = pVatCmd; }
-    void show() { offFlag(1); }
-    void hide() { onFlag(1); }
+    void show() { offFlag(J3DShpFlag_Visible); }
+    void hide() { onFlag(J3DShpFlag_Visible); }
     void setCurrentViewNoPtr(u32* pViewNoPtr) { mCurrentViewNo = pViewNoPtr; }
     void setScaleFlagArray(u8* pScaleFlagArray) { mScaleFlagArray = pScaleFlagArray; }
     void setDrawMtx(Mtx** pDrawMtx) { mDrawMtx = pDrawMtx; }
@@ -66,7 +67,7 @@ public:
     u32 getBumpMtxOffset() const { return mBumpMtxOffset; }
 
     inline J3DMaterial* getMaterial() const { return mMaterial; }
-    inline u32 getPipeline() const { return (mFlags >> 2) & 7; }
+    inline u32 getPipeline() const { return (mFlags >> 2) & 0x07; }
     inline u32 getTexMtxLoadType() const { return mFlags & 0xF000; }
     static void resetVcdVatCache() { sOldVcdVatCmd = NULL; }
 
diff --git a/include/JSystem/J3DGraphLoader/J3DAnmLoader.h b/include/JSystem/J3DGraphLoader/J3DAnmLoader.h
index 265bc83c18..0c6a6a8474 100644
--- a/include/JSystem/J3DGraphLoader/J3DAnmLoader.h
+++ b/include/JSystem/J3DGraphLoader/J3DAnmLoader.h
@@ -3,12 +3,12 @@
 
 #include "dolphin/types.h"
 
-struct J3DAnmLoaderDataBaseFlag {};
+enum J3DAnmLoaderDataBaseFlag { UNK_FLAG0 };
 
 struct J3DAnmBase;
 
 struct J3DAnmLoaderDataBase {
-    /* 80337B40 */ void load(void const*, J3DAnmLoaderDataBaseFlag);
+    /* 80337B40 */ static void* load(void const*, J3DAnmLoaderDataBaseFlag);
     /* 80338134 */ void setResource(J3DAnmBase*, void const*);
 };
 
diff --git a/include/JSystem/JAudio2/JAISound.h b/include/JSystem/JAudio2/JAISound.h
index e94ea2cf13..61bac44a42 100644
--- a/include/JSystem/JAudio2/JAISound.h
+++ b/include/JSystem/JAudio2/JAISound.h
@@ -13,7 +13,7 @@ public:
     operator u32() const { return this->mId; }
     void operator=(JAISoundID const&);
 
-    JAISoundID(u32 pId);
+    JAISoundID(u32 pId) { mId = pId; };
 
     JAISoundID(JAISoundID const& other);
 
diff --git a/include/JSystem/JGeometry.h b/include/JSystem/JGeometry.h
index 0da0a2718b..a4c0ca50ed 100644
--- a/include/JSystem/JGeometry.h
+++ b/include/JSystem/JGeometry.h
@@ -33,6 +33,22 @@ struct TVec3<f32> {
         y = other.y;
         z = other.z;
     }
+
+    void set(f32 x_, f32 y_, f32 z_) {
+        x = x_;
+        y = y_;
+        z = z_;
+    }
+
+    void zero() {
+        x = y = z = 0.0f;
+    }
+
+    void mul(const TVec3<f32>& a, const TVec3<f32>& b) {
+        x = a.x * b.x;
+        y = a.y * b.y;
+        z = a.z * b.z;
+    }
 };
 
 template <typename T>
@@ -92,6 +108,10 @@ template<> struct TBox<TVec2<f32> > {
 
     bool isValid() const { return f.isAbove(i); }
 
+    void addPos(f32 x, f32 y) {
+        addPos(TVec2<f32>(x, y));
+    }
+
     void addPos(const TVec2<f32>& pos) {
         i.add(pos);
         f.add(pos);
@@ -123,7 +143,7 @@ struct TBox2 : TBox<TVec2<T> > {
     }
 
     void set(const TBox2& other) { set(other.i, other.f); }
-    void set(const TVec2<f32>& i, const TVec2<f32> f) { this->i.set(i), this->f.set(f); }
+    void set(const TVec2<f32>& i, const TVec2<f32>& f) { this->i.set(i), this->f.set(f); }
     void set(f32 x0, f32 y0, f32 x1, f32 y1) { i.set(x0, y0); f.set(x1, y1); }
 };
 
diff --git a/include/JSystem/JMath/JMATrigonometric.h b/include/JSystem/JMath/JMATrigonometric.h
index 79d3798ed2..a01b717ca8 100644
--- a/include/JSystem/JMath/JMATrigonometric.h
+++ b/include/JSystem/JMath/JMATrigonometric.h
@@ -17,6 +17,9 @@ struct pair {
 
 struct TSinCosTable {
     std::pair<f32, f32> table[0x2000];
+
+    f32 sinShort(s16 v) const { return table[static_cast<u16>(v) >> 3].a1; }
+    f32 cosShort(s16 v) const { return table[static_cast<u16>(v) >> 3].b1; }
 };
 
 struct TAtanTable {
@@ -35,4 +38,12 @@ extern TAtanTable atanTable_;
 extern TAsinAcosTable asinAcosTable_;
 };  // namespace JMath
 
+inline f32 JMASSin(s16 s) {
+    return JMath::sincosTable_.sinShort(s);
+}
+
+inline f32 JMASCos(s16 s) {
+    return JMath::sincosTable_.cosShort(s);
+}
+
 #endif /* JMATRIGONOMETRIC_H */
diff --git a/include/JSystem/JParticle/JPABaseShape.h b/include/JSystem/JParticle/JPABaseShape.h
index 0e7192f083..a081b0c916 100644
--- a/include/JSystem/JParticle/JPABaseShape.h
+++ b/include/JSystem/JParticle/JPABaseShape.h
@@ -2,5 +2,108 @@
 #define JPABASESHAPE_H
 
 #include "dolphin/types.h"
+#include "dolphin/gx/GX.h"
+
+class JPAEmitterWorkData;
+class JKRHeap;
+
+struct JPABaseShapeData {
+    // Common header.
+    /* 0x00 */ u8 mMagic[4];
+    /* 0x04 */ u32 mSize;
+
+    /* 0x08 */ u32 mFlags;
+    /* 0x0C */ s16 mClrPrmAnmOffset;
+    /* 0x0E */ s16 mClrEnvAnmOffset;
+    /* 0x10 */ f32 mBaseSizeX;
+    /* 0x14 */ f32 mBaseSizeY;
+    /* 0x18 */ u16 mBlendModeCfg;
+    /* 0x1A */ u8 mAlphaCompareCfg;
+    /* 0x1B */ u8 mAlphaRef0;
+    /* 0x1C */ u8 mAlphaRef1;
+    /* 0x1D */ u8 mZModeCfg;
+    /* 0x1E */ u8 mTexFlg;
+    /* 0x1F */ u8 mTexAnmNum;
+    /* 0x20 */ u8 mTexIdx;
+    /* 0x21 */ u8 mClrFlg;
+    /* 0x22 */ u8 mClrPrmKeyNum;
+    /* 0x23 */ u8 mClrEnvKeyNum;
+    /* 0x24 */ s16 mClrAnmFrmMax;
+    /* 0x26 */ GXColor mClrPrm;
+    /* 0x2A */ GXColor mClrEnv;
+    /* 0x2E */ u8 mAnmRndm;
+    /* 0x2F */ u8 mClrAnmRndmMask;
+    /* 0x30 */ u8 mTexAnmRndmMask;
+};
+
+struct JPABaseShape {
+public:
+    /* 8027A6DC */ JPABaseShape(u8 const*, JKRHeap*);
+    /* 8027A7E8 */ void setGX(JPAEmitterWorkData*) const;
+
+    static GXBlendMode st_bm[3];
+    static GXBlendFactor st_bf[10];
+    static GXLogicOp st_lo[16];
+    static GXCompare st_c[8];
+    static GXAlphaOp st_ao[4];
+    static GXTevColorArg st_ca[6][4];
+    static GXTevAlphaArg st_aa[2][4];
+
+    GXBlendMode getBlendMode() const { return st_bm[mpData->mBlendModeCfg & 0x03]; }
+    GXBlendFactor getBlendSrc() const { return st_bf[(mpData->mBlendModeCfg >> 2) & 0x0F]; }
+    GXBlendFactor getBlendDst() const { return st_bf[(mpData->mBlendModeCfg >> 6) & 0x0F]; }
+    GXLogicOp getLogicOp() const { return st_lo[(mpData->mBlendModeCfg >> 10) & 0x0F]; }
+    GXBool getZCompLoc() const { return (GXBool)((mpData->mZModeCfg >> 5) & 0x01); }
+
+    GXBool getZEnable() const { return (GXBool)(mpData->mZModeCfg & 0x01); }
+    GXCompare getZCmp() const { return st_c[(mpData->mZModeCfg >> 1) & 0x07]; }
+    GXBool getZUpd() const { return (GXBool)((mpData->mZModeCfg >> 4) & 0x01); }
+
+    GXCompare getAlphaCmp0() const { return st_c[mpData->mAlphaCompareCfg & 0x07]; }
+    u8 getAlphaRef0() const { return mpData->mAlphaRef0; }
+    GXAlphaOp getAlphaOp() const { return st_ao[(mpData->mAlphaCompareCfg >> 3) & 0x03]; }
+    GXCompare getAlphaCmp1() const { return st_c[(mpData->mAlphaCompareCfg >> 5) & 0x07]; }
+    u8 getAlphaRef1() const { return mpData->mAlphaRef1; }
+
+    const GXTevColorArg* getTevColorArg() const { return st_ca[(mpData->mFlags >> 0x0F) & 0x07]; }
+    const GXTevAlphaArg* getTevAlphaArg() const { return st_aa[(mpData->mFlags >> 0x12) & 0x01]; }
+
+    u32 getType() const { return (mpData->mFlags >> 0) & 0x0F; }
+    u32 getDirType() const { return (mpData->mFlags >> 4) & 0x07; }
+    u32 getRotType() const { return (mpData->mFlags >> 7) & 0x07; }
+    u32 getBasePlaneType() const { return (mpData->mFlags >> 10) & 0x07; }
+    u32 getTilingS() const { return (mpData->mFlags >> 25) & 0x01; }
+    u32 getTilingT() const { return (mpData->mFlags >> 26) & 0x01; }
+    bool isGlblClrAnm() const { return !!(mpData->mFlags & 0x00001000); }
+    bool isGlblTexAnm() const { return !!(mpData->mFlags & 0x00004000); }
+    bool isPrjTex() const { return !!(mpData->mFlags & 0x00100000); }
+    bool isDrawFwdAhead() const { return !!(mpData->mFlags & 0x00200000); }
+    bool isDrawPrntAhead() const { return !!(mpData->mFlags & 0x00400000); }
+    bool isClipOn() const { return !!(mpData->mFlags & 0x00800000); }
+    bool isTexCrdAnm() const { return !!(mpData->mFlags & 0x01000000); }
+    bool isNoDrawParent() const { return !!(mpData->mFlags & 0x08000000); }
+    bool isNoDrawChild() const { return !!(mpData->mFlags & 0x10000000); }
+
+    bool isPrmAnm() const { return !!(mpData->mClrFlg & 0x02); }
+    bool isEnvAnm() const { return !!(mpData->mClrFlg & 0x08); }
+    u8 getClrAnmType() const { return (mpData->mClrFlg >> 4) & 0x07; }
+    s16 getClrAnmMaxFrm() const { return mpData->mClrAnmFrmMax; }
+    void getPrmClr(s16 idx, GXColor* dst) { *dst = mpPrmClrAnmTbl[idx]; }
+    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; }
+
+    f32 getBaseSizeX() const { return mpData->mBaseSizeX; }
+    f32 getBaseSizeY() const { return mpData->mBaseSizeY; }
+
+public:
+    /* 0x00 */ const JPABaseShapeData* mpData;
+    /* 0x04 */ const void* mpTexCrdMtxAnmTbl;
+    /* 0x08 */ const u8* mpTexIdxAnimTbl;
+    /* 0x0C */ GXColor* mpPrmClrAnmTbl;
+    /* 0x10 */ GXColor* mpEnvClrAnmTbl;
+};
 
 #endif /* JPABASESHAPE_H */
diff --git a/include/JSystem/JParticle/JPAChildShape.h b/include/JSystem/JParticle/JPAChildShape.h
index f5ef5fa60e..5f6edf0d30 100644
--- a/include/JSystem/JParticle/JPAChildShape.h
+++ b/include/JSystem/JParticle/JPAChildShape.h
@@ -2,5 +2,43 @@
 #define JPACHILDSHAPE_H
 
 #include "dolphin/types.h"
+#include "dolphin/gx/GX.h"
+
+struct JPAChildShapeData {
+    // Common header.
+    /* 0x00 */ u8 mMagic[4];
+    /* 0x04 */ u32 mSize;
+
+    /* 0x08 */ u32 mFlags;
+    /* 0x0C */ f32 mPosRndm;
+    /* 0x10 */ f32 mBaseVel;
+    /* 0x14 */ f32 mBaseVelRndm;
+    /* 0x18 */ f32 mVelInfRate;
+    /* 0x1C */ f32 mGravity;
+    /* 0x20 */ f32 mScaleX;
+    /* 0x24 */ f32 mScaleY;
+    /* 0x28 */ f32 mInheritScale;
+    /* 0x2C */ f32 mInheritAlpha;
+    /* 0x30 */ f32 mInheritRGB;
+    /* 0x34 */ GXColor mPrmClr;
+    /* 0x38 */ GXColor mEnvClr;
+    /* 0x3C */ f32 mTiming;
+    /* 0x40 */ s16 mLife;
+    /* 0x42 */ s16 mRate;
+    /* 0x44 */ u8 mStep;
+    /* 0x45 */ u8 mTexIdx;
+    /* 0x46 */ s16 mRotSpeed;
+};
+
+class JPAChildShape {
+public:
+    /* 8027B038 */ JPAChildShape(u8 const*);
+
+    void getPrmClr(GXColor* dst) { *dst = mpData->mPrmClr; }
+    void getEnvClr(GXColor* dst) { *dst = mpData->mEnvClr; }
+
+public:
+    /* 0x00 */ const JPAChildShapeData* mpData;
+};
 
 #endif /* JPACHILDSHAPE_H */
diff --git a/include/JSystem/JParticle/JPADynamicsBlock.h b/include/JSystem/JParticle/JPADynamicsBlock.h
index aa424f49a9..8b3e441c19 100644
--- a/include/JSystem/JParticle/JPADynamicsBlock.h
+++ b/include/JSystem/JParticle/JPADynamicsBlock.h
@@ -35,13 +35,21 @@ struct JPADynamicsBlockData {
     /* 0x70 */ s16 mStartFrame;
     /* 0x72 */ s16 mLifeTime;
     /* 0x74 */ s16 mVolumeSize;
-    /* 0x76 */ s16 mDivNumber;
+    /* 0x76 */ u16 mDivNumber;
     /* 0x78 */ u8 mRateStep;
     /* 0x7C */ u32 field_0x7c;
 };
 
 typedef void (*JPADynamicsCalcVolumeFunc)(JPAEmitterWorkData*);
 
+enum {
+    JPADynFlag_FixedDensity   = 0x01,
+    JPADynFlag_FixedInterval  = 0x02,
+    JPADynFlag_InheritScale   = 0x04,
+    JPADynFlag_FollowEmtr     = 0x08,
+    JPADynFlag_FollowEmtrChld = 0x10,
+};
+
 class JPADynamicsBlock {
 public:
     /* 8027BB18 */ JPADynamicsBlock(u8 const*);
@@ -52,10 +60,14 @@ public:
 
     s16 getStartFrame() const { return mpData->mStartFrame; }
     u32 getResUserWork() const { return mpData->mResUserWork; }
+    u32 getFlag() const { return mpData->mFlags; }
+    u32 getVolumeType() const { return (mpData->mFlags >> 8) & 0x07; }
+    u16 getDivNumber() const { return mpData->mDivNumber; }
+    f32 getRateRndm() const { return mpData->mRateRndm; }
 
 public:
-    JPADynamicsBlockData* mpData;
-    JPADynamicsCalcVolumeFunc mpCalcVolumeFunc;
+    /* 0x00 */ const JPADynamicsBlockData* mpData;
+    /* 0x04 */ JPADynamicsCalcVolumeFunc mpCalcVolumeFunc;
 };
 
 #endif /* JPADYNAMICSBLOCK_H */
diff --git a/include/JSystem/JParticle/JPAExtraShape.h b/include/JSystem/JParticle/JPAExtraShape.h
index abdcdd0b4d..0df0e57436 100644
--- a/include/JSystem/JParticle/JPAExtraShape.h
+++ b/include/JSystem/JParticle/JPAExtraShape.h
@@ -3,4 +3,71 @@
 
 #include "dolphin/types.h"
 
+struct JPAExtraShapeData {
+    // Common header.
+    /* 0x00 */ u8 mMagic[4];
+    /* 0x04 */ u32 mSize;
+
+    /* 0x08 */ u32 mFlags;
+    /* 0x0C */ f32 mScaleInTiming;
+    /* 0x10 */ f32 mScaleOutTiming;
+    /* 0x14 */ f32 mScaleInValueX;
+    /* 0x18 */ f32 mScaleOutValueX;
+    /* 0x1C */ f32 mScaleInValueY;
+    /* 0x20 */ f32 mScaleOutValueY;
+    /* 0x24 */ f32 mScaleOutRandom;
+    /* 0x28 */ s16 mScaleAnmCycleX;
+    /* 0x2A */ s16 mScaleAnmCycleY;
+    /* 0x2C */ f32 mAlphaInTiming;
+    /* 0x30 */ f32 mAlphaOutTiming;
+    /* 0x34 */ f32 mAlphaInValue;
+    /* 0x38 */ f32 mAlphaBaseValue;
+    /* 0x3C */ f32 mAlphaOutValue;
+    /* 0x40 */ f32 mAlphaWaveFrequency;
+    /* 0x44 */ f32 mAlphaWaveRandom;
+    /* 0x48 */ f32 mAlphaWaveAmplitude;
+    /* 0x4C */ f32 mRotateAngle;
+    /* 0x50 */ f32 mRotateAngleRandom;
+    /* 0x54 */ f32 mRotateSpeed;
+    /* 0x58 */ f32 mRotateSpeedRandom;
+    /* 0x5C */ f32 mRotateDirection;
+};
+
+class JPAExtraShape {
+public:
+    /* 8027AD88 */ JPAExtraShape(u8 const*);
+    /* 8027ADBC */ void init();
+
+    f32 getScaleInTiming() const { return mpData->mScaleInTiming; }
+    f32 getScaleOutTiming() const { return mpData->mScaleOutTiming; }
+    f32 getScaleInValueX() const { return mpData->mScaleInValueX; }
+    f32 getScaleInValueY() const { return mpData->mScaleInValueY; }
+    f32 getScaleOutValueX() const { return mpData->mScaleOutValueX; }
+    f32 getScaleOutValueY() const { return mpData->mScaleOutValueY; }
+    s16 getScaleAnmCycleX() const { return mpData->mScaleAnmCycleX; }
+    s16 getScaleAnmCycleY() const { return mpData->mScaleAnmCycleY; }
+    f32 getAlphaInTiming() const { return mpData->mAlphaInTiming; }
+    f32 getAlphaOutTiming() const { return mpData->mAlphaOutTiming; }
+    f32 getAlphaInValue() const { return mpData->mAlphaInValue; }
+    f32 getAlphaOutValue() const { return mpData->mAlphaOutValue; }
+    f32 getAlphaBaseValue() const { return mpData->mAlphaBaseValue; }
+    f32 getAlphaFreq() const { return mpData->mAlphaWaveFrequency; }
+    f32 getAlphaAmp() const { return mpData->mAlphaWaveAmplitude; }
+    f32 getScaleIncRateX() const { return mScaleIncRateX; }
+    f32 getScaleDecRateX() const { return mScaleDecRateX; }
+    f32 getScaleIncRateY() const { return mScaleIncRateY; }
+    f32 getScaleDecRateY() const { return mScaleDecRateY; }
+    f32 getAlphaIncRate() const { return mAlphaIncRate; }
+    f32 getAlphaDecRate() const { return mAlphaDecRate; }
+
+private:
+    /* 0x00 */ const JPAExtraShapeData* mpData;
+    /* 0x04 */ f32 mAlphaIncRate;
+    /* 0x08 */ f32 mAlphaDecRate;
+    /* 0x0C */ f32 mScaleIncRateX;
+    /* 0x10 */ f32 mScaleIncRateY;
+    /* 0x14 */ f32 mScaleDecRateX;
+    /* 0x18 */ f32 mScaleDecRateY;
+};
+
 #endif /* JPAEXTRASHAPE_H */
diff --git a/include/JSystem/JParticle/JPAParticle.h b/include/JSystem/JParticle/JPAParticle.h
index 046353808f..ae0a07b8b2 100644
--- a/include/JSystem/JParticle/JPAParticle.h
+++ b/include/JSystem/JParticle/JPAParticle.h
@@ -7,6 +7,9 @@
 #include "JSystem/JGeometry.h"
 #include "JSystem/JSupport/JSUList.h"
 
+#include "JSystem/JParticle/JPADynamicsBlock.h"
+#include "JSystem/JParticle/JPAResource.h"
+
 class JKRHeap;
 class JPABaseEmitter;
 class JPABaseParticle;
@@ -31,6 +34,30 @@ public:
     JPARandom() { mSeed = 0; }
     void set_seed(u32 seed) { mSeed = seed; }
 
+    u32 get_rndm_u() {
+        return mSeed = mSeed * 0x19660du + 0x3c6ef35fu;
+    }
+
+    f32 get_rndm_f() {
+        union { u32 u; f32 f; } a;
+        a.u = ((get_rndm_u() >> 9) | 0x3f800000);
+        return a.f - 1.0f;
+    }
+
+    f32 get_rndm_zp() {
+        f32 f = get_rndm_f();
+        return (f + f) - 1.0f;
+    }
+
+    f32 get_rndm_zh() {
+        f32 f = get_rndm_f();
+        return f - 1.0f;
+    }
+
+    s16 get_rndm_ss() {
+        return ((s16)get_rndm_u()) >> 16;
+    }
+
 public:
     u32 mSeed;
 };
@@ -175,6 +202,13 @@ public:
     /* 8027E6A4 */ ~JPAEmitterCallBack();
 };
 
+enum {
+    JPAEmtrStts_StopEmit     = 0x01,
+    JPAEmtrStts_StopCalc     = 0x02,
+    JPAEmtrStts_FirstEmit    = 0x10,
+    JPAEmtrStts_RateStepEmit = 0x20,
+};
+
 class JPABaseEmitter {
 public:
     /* 8027E5EC */ ~JPABaseEmitter();
@@ -191,9 +225,17 @@ public:
     /* 8027EF50 */ bool loadTexture(u8, GXTexMapID);
 
     void setStatus(u32 status) { mStatus |= status; }
+    void clearStatus(u32 status) { mStatus &= ~status; }
     bool checkStatus(u32 status) { return !!(mStatus & status); }
+    bool checkFlag(u32 flag) { return !!(mpRes->getDyn()->getFlag() & flag); }
     u8 getResourceManagerID() const { return mResMgrID; }
     u8 getGroupID() const { return mGroupID; }
+    u8 getDrawTimes() const { return mDrawTimes; }
+
+    f32 get_r_f() { return mRndm.get_rndm_f(); }
+    f32 get_r_zp() { return mRndm.get_rndm_zp(); }
+    f32 get_r_zh() { return mRndm.get_rndm_zh(); }
+    s16 get_r_ss() { return mRndm.get_rndm_ss(); }
 
 public:
     /* 0x00 */ Vec mLocalScl;
@@ -234,7 +276,7 @@ public:
     /* 0xFC */ f32 mScaleOut;
     /* 0x100 */ u32 mTick;
     /* 0x104 */ s16 mWaitTime;
-    /* 0x106 */ u16 mRateStepTimer;
+    /* 0x106 */ s16 mRateStepTimer;
     /* 0x108 */ GXColor mPrmClr;
     /* 0x10C */ GXColor mEnvClr;
     /* 0x110 */ u8 mDrawTimes;
@@ -245,11 +287,15 @@ public:
 
 class JPAParticleCallBack {
 public:
-    ~JPAParticleCallBack();
+    virtual ~JPAParticleCallBack();
     virtual void execute(JPABaseEmitter*, JPABaseParticle*);
     virtual void draw(JPABaseEmitter*, JPABaseParticle*);
 };
 
+enum {
+    JPAPtclStts_Invisible = 0x08,
+};
+
 class JPABaseParticle {
 public:
     /* 8027EFEC */ void init_p(JPAEmitterWorkData*);
@@ -277,7 +323,7 @@ public:
     /* 0x74 */ f32 mDrag;
     /* 0x78 */ u32 field_0x78;
     /* 0x7C */ u32 mStatus;
-    /* 0x80 */ u16 mAge;
+    /* 0x80 */ s16 mAge;
     /* 0x82 */ u16 mLifeTime;
     /* 0x84 */ f32 mTime;
     /* 0x88 */ u16 mRotateAngle;
diff --git a/include/JSystem/JParticle/JPAResource.h b/include/JSystem/JParticle/JPAResource.h
index f207f15d88..5b3e891bc3 100644
--- a/include/JSystem/JParticle/JPAResource.h
+++ b/include/JSystem/JParticle/JPAResource.h
@@ -20,7 +20,7 @@ class JPAResource {
 public:
     /* 80274010 */ JPAResource();
     /* 80274080 */ void init(JKRHeap*);
-    /* 802755E8 */ void calc(JPAEmitterWorkData*, JPABaseEmitter*);
+    /* 802755E8 */ bool calc(JPAEmitterWorkData*, JPABaseEmitter*);
     /* 80275A94 */ void draw(JPAEmitterWorkData*, JPABaseEmitter*);
     /* 80275B74 */ void drawP(JPAEmitterWorkData*);
     /* 80275EB0 */ void drawC(JPAEmitterWorkData*);
diff --git a/include/JSystem/JSupport/JSUInputStream.h b/include/JSystem/JSupport/JSUInputStream.h
index f4a3ed3af3..5bb0f4f98e 100644
--- a/include/JSystem/JSupport/JSUInputStream.h
+++ b/include/JSystem/JSupport/JSUInputStream.h
@@ -19,8 +19,36 @@ public:
     /* vt[4] */ virtual s32 skip(s32);
     /* vt[5] */ virtual u32 readData(void*, s32) = 0;
 
+    u32 read32b() {
+        u32 val;
+        this->read(&val, sizeof(val));
+        return val;
+    }
+
+    s16 readS16() {
+        s16 val;
+        this->read(&val, sizeof(val));
+        return val;
+    }
+
+    u16 readU16() {
+        u16 val;
+        this->read(&val, sizeof(val));
+        return val;
+    }
+
+    u8 readU8() {
+        u8 val;
+        this->read(&val, sizeof(val));
+        return val;
+    }
+
     // TODO: return value probably wrong
     /* 802DC298 */ s32 read(void*, s32);
 };  // Size = 0x8
 
+// move?
+template <typename T>
+T* JSUConvertOffsetToPtr(const void*, const void*);
+
 #endif /* JSUINPUTSTREAM_H */
diff --git a/include/JSystem/JSupport/JSUList.h b/include/JSystem/JSupport/JSUList.h
index f204f239ee..b0bbdd4fb9 100644
--- a/include/JSystem/JSupport/JSUList.h
+++ b/include/JSystem/JSupport/JSUList.h
@@ -157,67 +157,33 @@ private:
 // Tree
 //
 
-#define JSU_TREE_FROM_LINK(T, LINK) (JSUTree<T>*)(((u8*)(LINK)) - 12)
-#define JSU_TREE_LINK_IF_NOT_NULL(TREE)                                                            \
-    if (TREE) {                                                                                    \
-        TREE = (JSUTree<T>*)(&(TREE)->mLink);                                                      \
-    }
-
-#define _JSU_TREE_AS_LINK(TREE) ((JSULink<T>*)(TREE))
-
 template <typename T>
-class JSUTree {
+class JSUTree : public JSUList<T>, public JSULink<T> {
 public:
-    JSUTree(T* owner) : mList(), mLink(owner) {}
+    JSUTree(T* owner) : JSUList<T>(), JSULink<T>(owner) {}
     ~JSUTree() {}
 
-    bool appendChild(JSUTree<T>* child) {
-        JSU_TREE_LINK_IF_NOT_NULL(child);
-        return this->mList.append(_JSU_TREE_AS_LINK(child));
-    }
+    bool appendChild(JSUTree<T>* child) { return this->append(child); }
 
-    bool removeChild(JSUTree<T>* child) {
-        JSU_TREE_LINK_IF_NOT_NULL(child);
-        return this->mList.remove(_JSU_TREE_AS_LINK(child));
-    }
+    bool removeChild(JSUTree<T>* child) { return this->remove(child); }
 
-    bool insertChild(JSUTree<T>* before, JSUTree<T>* child) {
-        JSU_TREE_LINK_IF_NOT_NULL(before);
-        JSU_TREE_LINK_IF_NOT_NULL(child);
-        return this->mList.insert(_JSU_TREE_AS_LINK(before), _JSU_TREE_AS_LINK(child));
-    }
+    bool insertChild(JSUTree<T>* before, JSUTree<T>* child) { return this->insert(before, child); }
 
     JSUTree<T>* getEndChild() const { return NULL; }
 
-    JSUTree<T>* getFirstChild() const {
-        JSULink<T>* link = this->mList.getFirst();
-        return link ? JSU_TREE_FROM_LINK(T, link) : (JSUTree<T>*)link;
-    }
-
-    JSUTree<T>* getLastChild() const {
-        JSULink<T>* link = this->mList.getLast();
-        return link ? JSU_TREE_FROM_LINK(T, link) : (JSUTree<T>*)link;
-    }
+    JSUTree<T>* getFirstChild() const { return (JSUTree<T>*)this->getFirst(); }
 
-    JSUTree<T>* getNextChild() const {
-        JSULink<T>* link = this->mLink.getNext();
-        return link ? JSU_TREE_FROM_LINK(T, link) : (JSUTree<T>*)link;
-    }
+    JSUTree<T>* getLastChild() const { return (JSUTree<T>*)this->getLast(); }
 
-    JSUTree<T>* getPrevChild() const {
-        JSULink<T>* link = this->mLink.getPrev();
-        return link ? JSU_TREE_FROM_LINK(T, link) : (JSUTree<T>*)link;
-    }
+    JSUTree<T>* getNextChild() const { return (JSUTree<T>*)this->getNext(); }
 
-    u32 getNumChildren() const { return this->mList.getNumLinks(); }
+    JSUTree<T>* getPrevChild() const { return (JSUTree<T>*)this->getPrev(); }
 
-    T* getObject() const { return this->mLink.getObject(); }
+    u32 getNumChildren() const { return this->getNumLinks(); }
 
-    JSUTree<T>* getParent() const { return (JSUTree<T>*)this->mLink.getList(); }
+    T* getObject() const { return (T*)this->getObjectPtr(); }
 
-private:
-    JSUList<T> mList;
-    JSULink<T> mLink;
+    JSUTree<T>* getParent() const { return (JSUTree<T>*)this->getList(); }
 };
 
 template <typename T>
diff --git a/include/JSystem/JUtility/JUTPalette.h b/include/JSystem/JUtility/JUTPalette.h
index dd9ab27cf5..f269bed464 100644
--- a/include/JSystem/JUtility/JUTPalette.h
+++ b/include/JSystem/JUtility/JUTPalette.h
@@ -14,6 +14,9 @@ struct ResTLUT {
 
 class JUTPalette {
 public:
+    JUTPalette(_GXTlut p1, _GXTlutFmt p2, JUTTransparency p3, u16 p4, void* p5) {
+        this->storeTLUT(p1, p2, p3, p4, p5);
+    }
     /* 802DE890 */ void storeTLUT(_GXTlut, ResTLUT*);
     /* 802DE91C */ void storeTLUT(_GXTlut, _GXTlutFmt, JUTTransparency, u16, void*);
     /* 802DE95C */ bool load();
diff --git a/include/JSystem/JUtility/JUTResource.h b/include/JSystem/JUtility/JUTResource.h
index 9101795e68..3447ca53af 100644
--- a/include/JSystem/JUtility/JUTResource.h
+++ b/include/JSystem/JUtility/JUTResource.h
@@ -1,6 +1,20 @@
 #ifndef JUTRESOURCE_H
 #define JUTRESOURCE_H
 
+#include "JSystem/JKernel/JKRArchive.h"
+#include "JSystem/JSupport/JSUInputStream.h"
 #include "dolphin/types.h"
 
+class JUTResReference {
+private:
+    u8 unk_0x0[0x101];
+
+public:
+    JUTResReference() { unk_0x0[0] = 0; }
+    /* 802DE078 */ void* getResource(JSUInputStream*, u32, JKRArchive*);
+    /* 802DE120 */ void* getResource(void const*, u32, JKRArchive*);
+    /* 802DE1BC */ void* getResource(u32, JKRArchive*);
+};
+// only rough size known due to getPointer__7J2DPaneFP20JSURandomInputStreamUlP10JKRArchive
+
 #endif /* JUTRESOURCE_H */