diff --git a/include/JSystem/J3DGraphAnimator/J3DJoint.h b/include/JSystem/J3DGraphAnimator/J3DJoint.h
index b776f24da..26e4f4c36 100644
--- a/include/JSystem/J3DGraphAnimator/J3DJoint.h
+++ b/include/JSystem/J3DGraphAnimator/J3DJoint.h
@@ -11,17 +11,13 @@ class J3DMtxBuffer;
 
 class J3DMtxCalc {
 public:
-    /* 80325D1C */ static void setMtxBuffer(J3DMtxBuffer*);
+    static void setMtxBuffer(J3DMtxBuffer*);
 
-    /* 8000D948 */ virtual ~J3DMtxCalc();
-    /* 80014E90 */ virtual void setAnmTransform(J3DAnmTransform*);
-    /* 80014E9C */ virtual bool getAnmTransform();
-    /* 80014E8C */ virtual void setAnmTransform(u8, J3DAnmTransform*);
-    /* 80014E94 */ virtual bool getAnmTransform(u8);
-    /* 80014EA4 */ virtual void setWeight(u8, f32);
-    /* 80014EA8 */ virtual void getWeight(u8) const;
-    virtual void init(Vec const& param_0, Mtx*) = 0;
+    virtual ~J3DMtxCalc();
+    virtual void init(Vec const& param_0, const Mtx&) = 0;
+    virtual void recursiveCalc(J3DNode *);
     virtual void calc() = 0;
+    virtual void calcTransform(u16, J3DTransformInfo const &) = 0;
 
     static J3DMtxBuffer* getMtxBuffer() { return mMtxBuffer; }
     static J3DJoint* getJoint() { return mJoint; }
@@ -33,7 +29,7 @@ public:
 
 class J3DMtxCalcNoAnmBase : public J3DMtxCalc {
 public:
-    /* 8000FA8C */ virtual ~J3DMtxCalcNoAnmBase();
+    virtual ~J3DMtxCalcNoAnmBase();
 };
 
 template <class A, class B>
@@ -47,9 +43,9 @@ public:
 
 class J3DJoint : public J3DNode {
 public:
-    /* 8032F170 */ J3DJoint();
-    /* 8032F254 */ void entryIn();
-    /* 8032F3F8 */ void recursiveCalc();
+    J3DJoint();
+    void entryIn();
+    void recursiveCalc();
 
     J3DMaterial* getMesh() { return mMesh; }
     u16 getJntNo() const { return mJntNo; }
@@ -83,23 +79,23 @@ private:
 };  // Size: 0x54
 
 struct J3DMtxCalcJ3DSysInitMaya {
-    /* 8032ECAC */ static void init(Vec const&, f32 const (&)[3][4]);
+    static void init(Vec const&, f32 const (&)[3][4]);
 };
 
 struct J3DMtxCalcJ3DSysInitBasic {
-    /* 8032EC28 */ static void init(Vec const&, f32 const (&)[3][4]);
+    static void init(Vec const&, f32 const (&)[3][4]);
 };
 
 struct J3DMtxCalcCalcTransformSoftimage {
-    /* 8032EE50 */ static void calcTransform(J3DTransformInfo const&);
+    static void calcTransform(J3DTransformInfo const&);
 };
 
 struct J3DMtxCalcCalcTransformMaya {
-    /* 8032EFBC */ static void calcTransform(J3DTransformInfo const&);
+    static void calcTransform(J3DTransformInfo const&);
 };
 
 struct J3DMtxCalcCalcTransformBasic {
-    /* 8032ED30 */ static void calcTransform(J3DTransformInfo const&);
+    static void calcTransform(J3DTransformInfo const&);
 };
 
 #endif /* J3DJOINT_H */
diff --git a/include/JSystem/J3DGraphAnimator/J3DJointTree.h b/include/JSystem/J3DGraphAnimator/J3DJointTree.h
index af85bbd5c..e7324aee4 100644
--- a/include/JSystem/J3DGraphAnimator/J3DJointTree.h
+++ b/include/JSystem/J3DGraphAnimator/J3DJointTree.h
@@ -15,8 +15,8 @@ struct J3DModelHierarchy {
 class J3DMaterialTable;
 
 struct J3DDrawMtxData {
-    /* 803115E0 */ J3DDrawMtxData();
-    /* 803115F4 */ ~J3DDrawMtxData();
+    J3DDrawMtxData();
+    ~J3DDrawMtxData();
 
     /* 0x0 */ u16 mEntryNum;
     /* 0x2 */ u16 mDrawFullWgtMtxNum;
@@ -28,13 +28,12 @@ class J3DShapeTable;
 
 class J3DJointTree {
 public:
-    /* 80325A18 */ J3DJointTree();
-    /* 80325A9C */ void makeHierarchy(J3DJoint*, J3DModelHierarchy const**, J3DMaterialTable*,
-                                      J3DShapeTable*);
-    /* 80325C00 */ void findImportantMtxIndex();
+    J3DJointTree();
+    void makeHierarchy(J3DJoint*, J3DModelHierarchy const**, J3DMaterialTable*, J3DShapeTable*);
+    void findImportantMtxIndex();
 
-    /* 80325CAC */ virtual void calc(J3DMtxBuffer*, Vec const&, f32 const (&)[3][4]);
-    /* 80325D24 */ virtual ~J3DJointTree();
+    virtual void calc(J3DMtxBuffer*, Vec const&, f32 const (&)[3][4]);
+    virtual ~J3DJointTree();
 
     u16 getWEvlpMtxNum() const { return mWEvlpMtxNum; }
     u8 getWEvlpMixMtxNum(u16 idx) const { return mWEvlpMixMtxNum[idx]; }
diff --git a/include/JSystem/J3DGraphAnimator/J3DMaterialAttach.h b/include/JSystem/J3DGraphAnimator/J3DMaterialAttach.h
index f274de05a..5182c354c 100644
--- a/include/JSystem/J3DGraphAnimator/J3DMaterialAttach.h
+++ b/include/JSystem/J3DGraphAnimator/J3DMaterialAttach.h
@@ -53,7 +53,6 @@ private:
     /* 0x14 */ u32 field_0x14;
     /* 0x18 */ J3DTexture* mTexture;
     /* 0x1C */ JUTNameTab* mTextureName;
-    /* 0x20 */ u16 field_0x20;
-};  // Size: 0x22
+};  // Size: 0x20
 
 #endif /* J3DMATERIALATTACH_H */
diff --git a/include/JSystem/J3DGraphAnimator/J3DModel.h b/include/JSystem/J3DGraphAnimator/J3DModel.h
index 761048ed5..5e116750b 100644
--- a/include/JSystem/J3DGraphAnimator/J3DModel.h
+++ b/include/JSystem/J3DGraphAnimator/J3DModel.h
@@ -31,17 +31,21 @@ typedef void (*J3DCalcCallBack)(J3DModel*, u32 timing);
 
 class J3DMatPacket;
 class J3DShapePacket;
-class J3DVisibilityManager;
+
+class J3DVisibilityManager {
+public:
+    virtual ~J3DVisibilityManager();
+    virtual void setVisibility(J3DModelData*);
+};
+
+class J3DUnkCallBack {
+public:
+    virtual void calc(J3DModel*);
+};
 
 class J3DModel {
 public:
-    J3DModel() {
-        initialize();
-    }
-    J3DModel(J3DModelData* param_0, u32 param_1, u32 param_2) {
-        initialize();
-        entryModelData(param_0, param_1, param_2);
-    }
+    J3DModel();
 
     void initialize();
     s32 entryModelData(J3DModelData*, u32, u32);
@@ -57,9 +61,15 @@ public:
     void calcWeightEnvelopeMtx();
     void calcNrmMtx();
     void calcBumpMtx();
-    void calcBBoardMtx();
+    void calcBBoard();
+    void calcDrawMtx();
     void prepareShapePackets();
-    MtxP getAnmMtx(int);
+    MtxP getAnmMtx(int idx) { return mpNodeMtx[idx]; }
+
+    s32 setNoUseDrawMtx();
+    s32 createSingleDrawMtx(J3DModelData*);
+    s32 createDoubleDrawMtx(J3DModelData*, u32);
+    s32 createBumpMtxArray(J3DModelData*, u32);
 
     virtual void update();
     virtual void entry();
@@ -77,15 +87,31 @@ public:
 
     bool isCpuSkinningOn() const { return (mFlags & J3DMdlFlag_SkinPosCpu) && (mFlags & J3DMdlFlag_SkinNrmCpu); }
 
+    void swapDrawMtx() {
+        Mtx* tmp = mpDrawMtxBuf[0][mCurrentViewNo];
+        mpDrawMtxBuf[0][mCurrentViewNo] = mpDrawMtxBuf[1][mCurrentViewNo];
+        mpDrawMtxBuf[1][mCurrentViewNo] = tmp;
+    }
+
+    void swapNrmMtx() {
+        Mtx33* tmp = mpNrmMtxBuf[0][mCurrentViewNo];
+        mpNrmMtxBuf[0][mCurrentViewNo] = mpNrmMtxBuf[1][mCurrentViewNo];
+        mpNrmMtxBuf[1][mCurrentViewNo] = tmp;
+    }
+
     Mtx& getBaseTRMtx() { return mBaseTransformMtx; }
     void setBaseTRMtx(Mtx m) { MTXCopy(m, mBaseTransformMtx); }
     u32 getMtxCalcMode() const { return mFlags & 0x03; }
+    u32* getCurrentViewNoPtr() { return &mCurrentViewNo; }
+    u8* getScaleFlagArray() const { return mpScaleFlagArr; }
     J3DVertexBuffer* getVertexBuffer() const { return (J3DVertexBuffer*)&mVertexBuffer; }
     J3DMatPacket* getMatPacket(u16 idx) const { return &mpMatPacket[idx]; }
     J3DShapePacket* getShapePacket(u16 idx) const { return &mpShapePacket[idx]; }
-    // Mtx33* getBumpMtxPtr(int idx) const { return mMtxBuffer->getBumpMtxPtr(idx); }
-    Mtx33* getNrmMtxPtr() const { return mpNrmMtxBuf[1][mCurrentViewNo]; }
+    Mtx** getDrawMtxPtrPtr() const { return mpDrawMtxBuf[1]; }
     Mtx* getDrawMtxPtr() const { return mpDrawMtxBuf[1][mCurrentViewNo]; }
+    Mtx33** getNrmMtxPtrPtr() const { return mpNrmMtxBuf[1]; }
+    Mtx33* getNrmMtxPtr() const { return mpNrmMtxBuf[1][mCurrentViewNo]; }
+    Mtx33*** getBumpMtxPtrPtr() const { return mpBumpMtxArr[1]; }
     void setBaseScale(const Vec& scale) { mBaseScale = scale; }
     void setUserArea(u32 area) { mUserArea = area; }
     u32 getUserArea() const { return mUserArea; }
@@ -112,9 +138,15 @@ public:
     /* 0x0B8 */ J3DShapePacket* mpShapePacket;
     /* 0x0BC */ J3DDeformData* mpDeformData;
     /* 0x0C0 */ J3DSkinDeform* mpSkinDeform;
-    /* 0x0C4 */ void * pad4[2];
+    /* 0x0C4 */ J3DUnkCallBack * field_0xc4;
+    /* 0x0C8 */ J3DUnkCallBack * field_0xc8;
     /* 0x0CC */ J3DVertexBuffer mVertexBuffer;
     /* 0x104 */ J3DVisibilityManager * mpVisibilityManager;
+
+    static Mtx sNoUseDrawMtx;
+    static Mtx33 sNoUseNrmMtx;
+    static Mtx* sNoUseDrawMtxPtr;
+    static Mtx33* sNoUseNrmMtxPtr;
 };
 
 STATIC_ASSERT(sizeof(J3DModel) == 0x108);
diff --git a/include/JSystem/J3DGraphAnimator/J3DModelData.h b/include/JSystem/J3DGraphAnimator/J3DModelData.h
index cd23e5294..3f5bd7d30 100644
--- a/include/JSystem/J3DGraphAnimator/J3DModelData.h
+++ b/include/JSystem/J3DGraphAnimator/J3DModelData.h
@@ -13,16 +13,16 @@ class JUTNameTab;
 
 class J3DModelData {
 public:
-    /* 80325D88 */ void clear();
-    /* 80325DA0 */ J3DModelData();
-    /* 80325E14 */ s32 newSharedDisplayList(u32);
-    /* 80325EC8 */ void indexToPtr();
-    /* 80325F94 */ void makeSharedDL();
-    /* 8032600C */ void simpleCalcMaterial(u16, f32 (*)[4]);
-    /* 803260CC */ void syncJ3DSysPointers() const;
-    /* 803260F8 */ void syncJ3DSysFlags() const;
+    void clear();
+    J3DModelData();
+    s32 newSharedDisplayList(u32);
+    void indexToPtr();
+    void makeSharedDL();
+    void simpleCalcMaterial(u16, f32 (*)[4]);
+    void syncJ3DSysPointers() const;
+    void syncJ3DSysFlags() const;
 
-    /* 8032617C */ virtual ~J3DModelData();
+    virtual ~J3DModelData();
 
     J3DMaterialTable& getMaterialTable() { return mMaterialTable; }
     JUTNameTab* getMaterialName() const { return mMaterialTable.getMaterialName(); }
@@ -87,7 +87,10 @@ private:
     /* 0x10 */ J3DJointTree mJointTree;
     /* 0x58 */ J3DMaterialTable mMaterialTable;
     /* 0x78 */ J3DShapeTable mShapeTable;
-    /* 0x88 */ J3DVertexData mVertexData;
+    /* 0x84 */ J3DVertexData mVertexData;
+    /* 0xE0 */ JUTNameTab * mName;
 };  // Size: 0xE4
 
+STATIC_ASSERT(sizeof(J3DModelData) == 0xE4);
+
 #endif /* J3DMODELDATA_H */
diff --git a/include/JSystem/J3DGraphAnimator/J3DMtxBuffer.h b/include/JSystem/J3DGraphAnimator/J3DMtxBuffer.h
index 904fa1d36..1b791fc63 100644
--- a/include/JSystem/J3DGraphAnimator/J3DMtxBuffer.h
+++ b/include/JSystem/J3DGraphAnimator/J3DMtxBuffer.h
@@ -10,17 +10,17 @@ class J3DMtxBuffer {
 public:
     J3DMtxBuffer() { initialize(); }
 
-    /* 80326214 */ void initialize();
-    /* 80326258 */ s32 create(J3DModelData*, u32);
-    /* 80326364 */ s32 createAnmMtx(J3DModelData*);
-    /* 803263F0 */ s32 createWeightEnvelopeMtx(J3DModelData*);
-    /* 8032648C */ s32 setNoUseDrawMtx();
-    /* 803264B8 */ s32 createDoubleDrawMtx(J3DModelData*, u32);
-    /* 80326664 */ s32 createBumpMtxArray(J3DModelData*, u32);
-    /* 803268D4 */ void calcWeightEnvelopeMtx();
-    /* 80326ACC */ void calcDrawMtx(u32, Vec const&, f32 const (&)[3][4]);
-    /* 80326D3C */ void calcNrmMtx();
-    /* 80326EF0 */ void calcBBoardMtx();
+    void initialize();
+    s32 create(J3DModelData*, u32);
+    s32 createAnmMtx(J3DModelData*);
+    s32 createWeightEnvelopeMtx(J3DModelData*);
+    s32 setNoUseDrawMtx();
+    s32 createDoubleDrawMtx(J3DModelData*, u32);
+    s32 createBumpMtxArray(J3DModelData*, u32);
+    void calcWeightEnvelopeMtx();
+    void calcDrawMtx(u32, Vec const&, f32 const (&)[3][4]);
+    void calcNrmMtx();
+    void calcBBoardMtx();
 
     MtxP getAnmMtx(int idx) const { return mpAnmMtx[idx]; }
     void setAnmMtx(int i, Mtx m) { MTXCopy(m, (MtxP)mpAnmMtx[i]); }
@@ -72,7 +72,7 @@ private:
     /* 0x34 */ Mtx* mpUserAnmMtx;
 
 public:
-    /* 803283B4 */ virtual ~J3DMtxBuffer();
+    virtual ~J3DMtxBuffer();
 };
 
 void J3DCalcViewBaseMtx(f32 (*param_0)[4], Vec const& param_1, f32 const (&param_2)[3][4],
diff --git a/include/JSystem/J3DGraphAnimator/J3DShapeTable.h b/include/JSystem/J3DGraphAnimator/J3DShapeTable.h
index 4df0f6e0b..321d8b1c2 100644
--- a/include/JSystem/J3DGraphAnimator/J3DShapeTable.h
+++ b/include/JSystem/J3DGraphAnimator/J3DShapeTable.h
@@ -11,13 +11,12 @@ public:
     J3DShapeTable() {
         mShapeNum = 0;
         mShapeNodePointer = NULL;
-        mShapeName = NULL;
     }
 
-    /* 803258A0 */ void hide();
-    /* 803258D8 */ void show();
-    /* 80325910 */ void initShapeNodes(J3DDrawMtxData*, J3DVertexData*);
-    /* 8032597C */ void sortVcdVatCmd();
+    void hide();
+    void show();
+    void initShapeNodes(J3DDrawMtxData*, J3DVertexData*);
+    void sortVcdVatCmd();
 
     virtual ~J3DShapeTable();
 
@@ -27,7 +26,6 @@ public:
 private:
     /* 0x4 */ u16 mShapeNum;
     /* 0x8 */ J3DShape** mShapeNodePointer;
-    /* 0xC */ JUTNameTab* mShapeName;
-};  // Size: 0x10
+};  // Size: 0x0C
 
 #endif /* J3DSHAPETABLE_H */
diff --git a/include/JSystem/J3DGraphAnimator/J3DSkinDeform.h b/include/JSystem/J3DGraphAnimator/J3DSkinDeform.h
index 1844f2f15..48e7746eb 100644
--- a/include/JSystem/J3DGraphAnimator/J3DSkinDeform.h
+++ b/include/JSystem/J3DGraphAnimator/J3DSkinDeform.h
@@ -11,11 +11,11 @@ class J3DAnmCluster;
 
 class J3DDeformData {
 public:
-    /* 8032E1F8 */ J3DDeformData();
-    /* 8032E230 */ void offAllFlag(u32);
-    /* 8032E298 */ void deform(J3DVertexBuffer*);
-    /* 8032E274 */ void deform(J3DModel*);
-    /* 8032E364 */ void setAnm(J3DAnmCluster*);
+    J3DDeformData();
+    void offAllFlag(u32);
+    void deform(J3DVertexBuffer*);
+    void deform(J3DModel*);
+    void setAnm(J3DAnmCluster*);
 
 private:
     /* 0x00 */ u16 mClusterNum;
@@ -33,9 +33,9 @@ private:
 };  // Size: 0x28
 
 struct J3DSkinNList {
-    /* 8032C6E4 */ J3DSkinNList();
-    /* 8032C85C */ void calcSkin_VtxPosF32(f32 (*)[4], void*, void*);
-    /* 8032C8E4 */ void calcSkin_VtxNrmF32(f32 (*)[4], void*, void*);
+    J3DSkinNList();
+    void calcSkin_VtxPosF32(f32 (*)[4], void*, void*);
+    void calcSkin_VtxNrmF32(f32 (*)[4], void*, void*);
 
     /* 0x00 */ u16* field_0x0;
     /* 0x04 */ u16* field_0x4;
@@ -47,20 +47,19 @@ struct J3DSkinNList {
 
 class J3DSkinDeform {
 public:
-    /* 8032C96C */ J3DSkinDeform();
-    /* 8032C9B0 */ void initSkinInfo(J3DModelData*);
-    /* 8032CF44 */ int initMtxIndexArray(J3DModelData*);
-    /* 8032D378 */ void changeFastSkinDL(J3DModelData*);
-    /* 8032D5C4 */ void calcNrmMtx(J3DMtxBuffer*);
-    /* 8032D738 */ void transformVtxPosNrm(J3DModelData*);
-    /* 8032D87C */ void calcAnmInvJointMtx(J3DMtxBuffer*);
-    /* 8032D8F4 */ void deformFastVtxPos_F32(J3DVertexBuffer*, J3DMtxBuffer*) const;
-    /* 8032DA1C */ void deformFastVtxNrm_F32(J3DVertexBuffer*, J3DMtxBuffer*) const;
-    /* 8032DB50 */ void deformVtxPos_F32(J3DVertexBuffer*, J3DMtxBuffer*) const;
-    /* 8032DC74 */ void deformVtxPos_S16(J3DVertexBuffer*, J3DMtxBuffer*) const;
-    /* 8032DDB8 */ void deformVtxNrm_F32(J3DVertexBuffer*) const;
-    /* 8032DEBC */ void deformVtxNrm_S16(J3DVertexBuffer*) const;
-    /* 8032DFDC */ void deform(J3DModel*);
+    J3DSkinDeform();
+    void initSkinInfo(J3DModelData*);
+    int initMtxIndexArray(J3DModelData*);
+    void changeFastSkinDL(J3DModelData*);
+    void calcNrmMtx(J3DMtxBuffer*);
+    void transformVtxPosNrm(J3DModelData*);
+    void calcAnmInvJointMtx(J3DMtxBuffer*);
+    void deformFastVtxPos_F32(J3DVertexBuffer*, J3DMtxBuffer*) const;
+    void deformFastVtxNrm_F32(J3DVertexBuffer*, J3DMtxBuffer*) const;
+    void deformVtxPos_F32(J3DVertexBuffer*, J3DMtxBuffer*) const;
+    void deformVtxPos_S16(J3DVertexBuffer*, J3DMtxBuffer*) const;
+    void deformVtxNrm_F32(J3DVertexBuffer*) const;
+    void deformVtxNrm_S16(J3DVertexBuffer*) const;
     void setNrmMtx(int i, MtxP mtx) {
         J3DPSMtx33CopyFrom34(mtx, (Mtx3P)mNrmMtx[i]);
     }
@@ -69,8 +68,8 @@ public:
     void offFlag(u32 flag) { mFlags &= ~flag; }
     bool checkFlag(u32 flag) { return mFlags & flag; }
 
-    /* 8032E064 */ virtual void deform(J3DVertexBuffer*, J3DMtxBuffer*);
-    /* 8032E1B0 */ virtual ~J3DSkinDeform();
+    virtual void deform(J3DModel*);
+    virtual ~J3DSkinDeform();
 
     static u16* sWorkArea_WEvlpMixMtx[1024];
     static f32* sWorkArea_WEvlpMixWeight[1024];
@@ -91,12 +90,12 @@ private:
 
 class J3DDeformer {
 public:
-    /* 8032E39C */ J3DDeformer(J3DDeformData*);
-    /* 8032EAB4 */ void deform(J3DVertexBuffer*, u16, f32*);
-    /* 8032E3BC */ void deform(J3DVertexBuffer*, u16);
-    /* 8032E4A4 */ void deform_VtxPosF32(J3DVertexBuffer*, J3DCluster*, J3DClusterKey*, f32*);
-    /* 8032E60C */ void deform_VtxNrmF32(J3DVertexBuffer*, J3DCluster*, J3DClusterKey*, f32*);
-    /* 8032EBCC */ void normalizeWeight(int, f32*);
+    J3DDeformer(J3DDeformData*);
+    void deform(J3DVertexBuffer*, u16, f32*);
+    void deform(J3DVertexBuffer*, u16);
+    void deform_VtxPosF32(J3DVertexBuffer*, J3DCluster*, J3DClusterKey*, f32*);
+    void deform_VtxNrmF32(J3DVertexBuffer*, J3DCluster*, J3DClusterKey*, f32*);
+    void normalizeWeight(int, f32*);
 
 private:
     /* 0x00 */ J3DDeformData* mDeformData;
diff --git a/include/JSystem/J3DGraphBase/J3DSys.h b/include/JSystem/J3DGraphBase/J3DSys.h
index 7fd030089..f94b4da65 100644
--- a/include/JSystem/J3DGraphBase/J3DSys.h
+++ b/include/JSystem/J3DGraphBase/J3DSys.h
@@ -57,6 +57,9 @@ public:
     J3DMatPacket* getMatPacket() { return mMatPacket; }
     void setMaterialMode(u32 mode) { mMaterialMode = mode; }
 
+    void setCurrentMtxCalc(J3DMtxCalc * pCalc) { mCurrentMtxCalc = pCalc; }
+    J3DMtxCalc * getCurrentMtxCalc() const { return mCurrentMtxCalc; }
+
     void setTexture(J3DTexture* pTex) { mTexture = pTex; }
     J3DTexture* getTexture() { return mTexture; }
 
diff --git a/src/JSystem/J3DGraphAnimator/J3DModel.cpp b/src/JSystem/J3DGraphAnimator/J3DModel.cpp
index 8f54a16c9..04a393261 100644
--- a/src/JSystem/J3DGraphAnimator/J3DModel.cpp
+++ b/src/JSystem/J3DGraphAnimator/J3DModel.cpp
@@ -4,11 +4,19 @@
 //
 
 #include "JSystem/J3DGraphAnimator/J3DModel.h"
-#include "dolphin/types.h"
+#include "JSystem/J3DGraphAnimator/J3DMaterialAnm.h"
+#include "JSystem/J3DGraphBase/J3DSys.h"
+#include "JSystem/JKernel/JKRHeap.h"
+#include "dolphin/os/OSCache.h"
+
+Mtx J3DModel::sNoUseDrawMtx;
+Mtx33 J3DModel::sNoUseNrmMtx;
+Mtx* J3DModel::sNoUseDrawMtxPtr = &J3DModel::sNoUseDrawMtx;
+Mtx33* J3DModel::sNoUseNrmMtxPtr = &J3DModel::sNoUseNrmMtx;
 
 /* 802ED564-802ED5AC       .text __ct__8J3DModelFv */
 J3DModel::J3DModel() {
-    /* Nonmatching */
+    initialize();
 }
 
 /* 802ED5AC-802ED610       .text __dt__8J3DModelFv */
@@ -18,77 +26,357 @@ J3DModel::~J3DModel() {
 
 /* 802ED610-802ED6C4       .text initialize__8J3DModelFv */
 void J3DModel::initialize() {
-    /* Nonmatching */
+    mModelData = NULL;
+    mFlags = 0;
+    mDiffFlag = 0;
+    mCalcCallBack = NULL;
+    mUserArea = 0;
+
+    mBaseScale.x = 1.0f;
+    mBaseScale.y = 1.0f;
+    mBaseScale.z = 1.0f;
+
+    MTXIdentity(mBaseTransformMtx);
+    MTXIdentity(mInternalView);
+
+    mpScaleFlagArr = NULL;
+    mpEvlpScaleFlagArr = NULL;
+    mpNodeMtx = NULL;
+    mpWeightEnvMtx = NULL;
+    mpDrawMtxBuf[0] = NULL;
+    mpDrawMtxBuf[1] = NULL;
+    mpNrmMtxBuf[0] = NULL;
+    mpNrmMtxBuf[1] = NULL;
+    mpBumpMtxArr[0] = NULL;
+    mpBumpMtxArr[1] = NULL;
+    mMtxBufferFlag = 1;
+    mCurrentViewNo = 0;
+    mpMatPacket = NULL;
+    mpShapePacket = NULL;
+    mpDeformData = NULL;
+    mpSkinDeform = NULL;
+    field_0xc4 = NULL;
+    field_0xc8 = NULL;
+    mpVisibilityManager = NULL;
+}
+
+enum {
+    J3DMdlDataFlag_ConcatView = 0x10,
+    J3DMdlDataFlag_NoUseDrawMtx = 0x20,
+    J3DMdlDataFlag_NoAnimation = 0x100,
+};
+
+static inline u32 getMdlDataFlag_MtxLoadType(u32 flag) {
+    return flag & 0xF0;
 }
 
 /* 802ED6C4-802ED8D8       .text entryModelData__8J3DModelFP12J3DModelDataUlUl */
-void J3DModel::entryModelData(J3DModelData*, unsigned long, unsigned long) {
-    /* Nonmatching */
+s32 J3DModel::entryModelData(J3DModelData* pModelData, u32 modelFlag, u32 mtxBufferFlag) {
+    s32 ret = kJ3DError_Success;
+
+    mModelData = pModelData;
+    mMtxBufferFlag = mtxBufferFlag;
+
+    if (pModelData->getJointNum() != 0) {
+        mpScaleFlagArr = new u8[pModelData->getJointNum()];
+        if (pModelData->getWEvlpMtxNum() != 0)
+            mpEvlpScaleFlagArr = new u8[pModelData->getWEvlpMtxNum()];
+        mpNodeMtx = new Mtx[pModelData->getJointNum()];
+    }
+
+    if (pModelData->getWEvlpMtxNum() != 0) {
+        mpWeightEnvMtx = new Mtx[pModelData->getWEvlpMtxNum()];
+    }
+
+    if (mpScaleFlagArr == NULL)
+        return kJ3DError_Alloc;
+
+    if (pModelData->getWEvlpMtxNum() != 0 && mpEvlpScaleFlagArr == NULL)
+        return kJ3DError_Alloc;
+
+    if (mpNodeMtx == NULL)
+        return kJ3DError_Alloc;
+
+    if (pModelData->getWEvlpMtxNum() != 0 && mpWeightEnvMtx == NULL)
+        return kJ3DError_Alloc;
+
+    if (pModelData->checkFlag(J3DMdlDataFlag_NoAnimation)) {
+        setNoUseDrawMtx();
+    } else {
+        switch (getMdlDataFlag_MtxLoadType(pModelData->getFlag())) {
+        case J3DMdlDataFlag_NoUseDrawMtx:
+            ret = setNoUseDrawMtx();
+            break;
+        case J3DMdlDataFlag_ConcatView:
+            ret = createSingleDrawMtx(pModelData);
+            break;
+        case 0:
+        default:
+            ret = createDoubleDrawMtx(pModelData, mtxBufferFlag);
+            break;
+        }
+    }
+
+    if (ret != kJ3DError_Success)
+        return ret;
+
+    ret = createShapePacket(pModelData);
+    if (ret != kJ3DError_Success)
+        return ret;
+
+    ret = createMatPacket(pModelData, modelFlag);
+    if (ret != kJ3DError_Success)
+        return ret;
+
+    if (pModelData->checkFlag(J3DMdlDataFlag_ConcatView)) {
+        mModelData->setBumpFlag(0);
+    } else {
+        ret = createBumpMtxArray(pModelData, mtxBufferFlag);
+        if (ret != kJ3DError_Success)
+            return ret;
+    }
+
+    mVertexBuffer.setVertexData(&pModelData->getVertexData());
+    prepareShapePackets();
+    ret = kJ3DError_Success;
+
+    return ret;
 }
 
 /* 802ED8D8-802ED904       .text setNoUseDrawMtx__8J3DModelFv */
-void J3DModel::setNoUseDrawMtx() {
-    /* Nonmatching */
+s32 J3DModel::setNoUseDrawMtx() {
+    mpDrawMtxBuf[1] = &sNoUseDrawMtxPtr;
+    mpDrawMtxBuf[0] = &sNoUseDrawMtxPtr;
+    mpNrmMtxBuf[1] = &sNoUseNrmMtxPtr;
+    mpNrmMtxBuf[0] = &sNoUseNrmMtxPtr;
+    mpBumpMtxArr[1] = NULL;
+    mpBumpMtxArr[0] = NULL;
+    return kJ3DError_Success;
 }
 
 /* 802ED904-802EDA14       .text createSingleDrawMtx__8J3DModelFP12J3DModelData */
-void J3DModel::createSingleDrawMtx(J3DModelData*) {
-    /* Nonmatching */
+s32 J3DModel::createSingleDrawMtx(J3DModelData* pModelData) {
+    mpDrawMtxBuf[0] = new Mtx*[1];
+    mpDrawMtxBuf[1] = mpDrawMtxBuf[0];
+    mpNrmMtxBuf[0] = new Mtx33*[1];
+    mpNrmMtxBuf[1] = mpNrmMtxBuf[0];
+    mpBumpMtxArr[0] = NULL;
+    mpBumpMtxArr[1] = NULL;
+
+    if (mpDrawMtxBuf[0] == NULL)
+        return kJ3DError_Alloc;
+    if (mpNrmMtxBuf[0] == NULL)
+        return kJ3DError_Alloc;
+
+    if (pModelData->getDrawMtxNum() != 0) {
+        mpDrawMtxBuf[0][0] = new (0x20) Mtx[pModelData->getDrawMtxNum()];
+        mpDrawMtxBuf[1][0] = mpDrawMtxBuf[0][0];
+        mpNrmMtxBuf[0][0] = new (0x20) Mtx33[1];
+        mpNrmMtxBuf[1][0] = mpNrmMtxBuf[0][0];
+    }
+
+    if (pModelData->getDrawMtxNum() != 0 && mpDrawMtxBuf[0][0] == NULL)
+        return kJ3DError_Alloc;
+
+    return kJ3DError_Success;
 }
 
 /* 802EDA14-802EDBC0       .text createDoubleDrawMtx__8J3DModelFP12J3DModelDataUl */
-void J3DModel::createDoubleDrawMtx(J3DModelData*, unsigned long) {
-    /* Nonmatching */
+s32 J3DModel::createDoubleDrawMtx(J3DModelData* pModelData, u32 num) {
+    if (num != 0) {
+        for (s32 i = 0; i < 2; i++) {
+            mpDrawMtxBuf[i] = new Mtx*[num];
+            mpNrmMtxBuf[i] = new Mtx33*[num];
+            mpBumpMtxArr[i] = NULL;
+        }
+    }
+
+    if (num != 0) {
+        for (u32 i = 0; i < 2; i++) {
+            if (mpDrawMtxBuf[i] == NULL)
+                return kJ3DError_Alloc;
+            if (mpNrmMtxBuf[i] == NULL)
+                return kJ3DError_Alloc;
+        }
+    }
+
+    for (s32 i = 0; i < 2; i++) {
+        for (u32 j = 0; j < num; j++) {
+            if (pModelData->getDrawMtxNum() != 0) {
+                mpDrawMtxBuf[i][j] = new (0x20) Mtx[pModelData->getDrawMtxNum()];
+                mpNrmMtxBuf[i][j] = new (0x20) Mtx33[pModelData->getDrawMtxNum()];
+            }
+        }
+    }
+
+    for (s32 i = 0; i < 2; i++) {
+        for (u32 j = 0; j < num; j++) {
+            if (pModelData->getDrawMtxNum() != 0) {
+                if (mpDrawMtxBuf[i][j] == NULL)
+                    return kJ3DError_Alloc;
+                if (mpNrmMtxBuf[i][j] == NULL)
+                    return kJ3DError_Alloc;
+            }
+        }
+    }
+
+    return kJ3DError_Success;
 }
 
 /* 802EDBC0-802EDC8C       .text createShapePacket__8J3DModelFP12J3DModelData */
-void J3DModel::createShapePacket(J3DModelData*) {
-    /* Nonmatching */
+s32 J3DModel::createShapePacket(J3DModelData* pModelData) {
+    if (pModelData->getShapeNum() != 0) {
+        u16 shapeNum = pModelData->getShapeNum();
+
+        mpShapePacket = new J3DShapePacket[shapeNum];
+        if (mpShapePacket == NULL)
+            return kJ3DError_Alloc;
+
+        for (int i = 0; i < pModelData->getShapeNum(); i++) {
+            J3DShape* shapeNode = pModelData->getShapeNodePointer(i);
+            mpShapePacket[i].setShape(shapeNode);
+            mpShapePacket[i].setModel(this);
+        }
+    }
+
+    return kJ3DError_Success;
 }
 
 /* 802EDC8C-802EDF60       .text createMatPacket__8J3DModelFP12J3DModelDataUl */
-void J3DModel::createMatPacket(J3DModelData*, unsigned long) {
+s32 J3DModel::createMatPacket(J3DModelData*, unsigned long) {
     /* Nonmatching */
 }
 
 /* 802EDF60-802EE1D4       .text createBumpMtxArray__8J3DModelFP12J3DModelDataUl */
-void J3DModel::createBumpMtxArray(J3DModelData*, unsigned long) {
+s32 J3DModel::createBumpMtxArray(J3DModelData*, unsigned long) {
     /* Nonmatching */
 }
 
 /* 802EE1D4-802EE254       .text newDifferedDisplayList__8J3DModelFUl */
-void J3DModel::newDifferedDisplayList(unsigned long) {
-    /* Nonmatching */
+s32 J3DModel::newDifferedDisplayList(u32 flag) {
+    mDiffFlag = flag;
+    for (u16 i = 0; i < getModelData()->getShapeNum(); i++) {
+        s32 ret = getShapePacket(i)->newDifferedDisplayList(flag);
+        if (ret != kJ3DError_Success)
+            return ret;
+    }
+    return kJ3DError_Success;
 }
 
 /* 802EE254-802EE28C       .text lock__8J3DModelFv */
 void J3DModel::lock() {
-    /* Nonmatching */
+    u16 matNum = mModelData->getMaterialNum();
+
+    for (int i = 0; i < matNum; i++) {
+        mpMatPacket[i].lock();
+    }
 }
 
 /* 802EE28C-802EE2C4       .text unlock__8J3DModelFv */
 void J3DModel::unlock() {
-    /* Nonmatching */
+    u16 matNum = mModelData->getMaterialNum();
+
+    for (int i = 0; i < matNum; i++) {
+        mpMatPacket[i].unlock();
+    }
 }
 
 /* 802EE2C4-802EE42C       .text calcMaterial__8J3DModelFv */
 void J3DModel::calcMaterial() {
-    /* Nonmatching */
+    j3dSys.setTexture(mModelData->getTexture());
+
+    if (checkFlag(4)) {
+        j3dSys.onFlag(4);
+    } else {
+        j3dSys.offFlag(4);
+    }
+
+    if (checkFlag(8)) {
+        j3dSys.onFlag(8);
+    } else {
+        j3dSys.offFlag(8);
+    }
+
+    j3dSys.setModel(this);
+
+    for (u16 i = 0; i < mModelData->getMaterialNum(); i++) {
+        j3dSys.setMatPacket(&mpMatPacket[i]);
+        
+        J3DMaterial* pMaterial = mModelData->getMaterialNodePointer(i);
+        if (pMaterial->getMaterialAnm() != NULL)
+            pMaterial->getMaterialAnm()->calc(pMaterial);
+
+        s32 jntNo = pMaterial->getJoint()->getJntNo();
+        pMaterial->calc(getAnmMtx(jntNo));
+    }
 }
 
 /* 802EE42C-802EE4BC       .text diff__8J3DModelFv */
 void J3DModel::diff() {
-    /* Nonmatching */
+    for (u16 i = 0; i < getModelData()->getMaterialNum(); i++) {
+        j3dSys.setMatPacket(&mpMatPacket[i]);
+        getModelData()->getMaterialNodePointer(i)->diff(mDiffFlag);
+    }
 }
 
 /* 802EE4BC-802EE5D8       .text setSkinDeform__8J3DModelFP13J3DSkinDeformUl */
-void J3DModel::setSkinDeform(J3DSkinDeform*, unsigned long) {
-    /* Nonmatching */
+s32 J3DModel::setSkinDeform(J3DSkinDeform* pSkinDeform, u32 flags) {
+    mpSkinDeform = pSkinDeform;
+
+    s32 ret = kJ3DError_Success;
+
+    if (pSkinDeform == NULL) {
+        offFlag(J3DMdlFlag_SkinPosCpu);
+        offFlag(J3DMdlFlag_SkinNrmCpu);
+        return 5;
+    } else {
+        mpSkinDeform->initMtxIndexArray(mModelData);
+
+        ret = mModelData->checkFlag(0x100);
+        if (ret != kJ3DError_Success) {
+            mpSkinDeform->changeFastSkinDL(mModelData);
+            flags &= ~2;
+            flags &= ~4;
+        }
+
+        ret = 0;
+        if ((~flags & 2)) {
+            ret = mVertexBuffer.allocTransformedVtxPosArray();
+            if (ret != kJ3DError_Success) {
+                offFlag(J3DMdlFlag_SkinPosCpu);
+                return ret;
+            }
+            onFlag(J3DMdlFlag_SkinPosCpu);
+        } else {
+            offFlag(J3DMdlFlag_SkinPosCpu);
+        }
+
+        if ((~flags & 4)) {
+            ret = mVertexBuffer.allocTransformedVtxNrmArray();
+            if (ret != kJ3DError_Success) {
+                offFlag(J3DMdlFlag_SkinNrmCpu);
+                return ret;
+            }
+            onFlag(J3DMdlFlag_SkinNrmCpu);
+        } else {
+            offFlag(J3DMdlFlag_SkinNrmCpu);
+        }
+    }
+
+    return ret;
 }
 
 /* 802EE5D8-802EE67C       .text calcAnmMtx__8J3DModelFv */
 void J3DModel::calcAnmMtx() {
-    /* Nonmatching */
+    j3dSys.setCurrentMtxCalc(getModelData()->getJointTree().getBasicMtxCalc());
+    j3dSys.setModel(this);
+
+    if (checkFlag(2))
+        j3dSys.getCurrentMtxCalc()->init(j3dDefaultScale, j3dDefaultMtx);
+    else
+        j3dSys.getCurrentMtxCalc()->init(mBaseScale, mBaseTransformMtx);
+
+    j3dSys.getCurrentMtxCalc()->recursiveCalc(getModelData()->getJointTree().getRootNode());
 }
 
 /* 802EE67C-802EE874       .text calcWeightEnvelopeMtx__8J3DModelFv */
@@ -98,17 +386,74 @@ void J3DModel::calcWeightEnvelopeMtx() {
 
 /* 802EE874-802EE8C0       .text update__8J3DModelFv */
 void J3DModel::update() {
-    /* Nonmatching */
+    calc();
+    entry();
 }
 
 /* 802EE8C0-802EEA2C       .text calc__8J3DModelFv */
 void J3DModel::calc() {
-    /* Nonmatching */
+    j3dSys.setModel(this);
+
+    if (checkFlag(J3DMdlFlag_SkinPosCpu)) {
+        j3dSys.onFlag(J3DSysFlag_SkinPosCpu);
+    } else {
+        j3dSys.offFlag(J3DSysFlag_SkinPosCpu);
+    }
+
+    if (checkFlag(J3DMdlFlag_SkinNrmCpu)) {
+        j3dSys.onFlag(J3DSysFlag_SkinNrmCpu);
+    } else {
+        j3dSys.offFlag(J3DSysFlag_SkinNrmCpu);
+    }
+
+    mVertexBuffer.frameInit();
+
+    if (mpVisibilityManager != NULL)
+        mpVisibilityManager->setVisibility(getModelData());
+
+    if (mpDeformData != NULL)
+        mpDeformData->deform(this);
+
+    if (field_0xc4 != NULL)
+        field_0xc4->calc(this);
+
+    if (field_0xc8 != NULL)
+        field_0xc8->calc(this);
+
+    calcAnmMtx();
+    calcWeightEnvelopeMtx();
+
+    if (mpSkinDeform != NULL)
+        mpSkinDeform->deform(this);
+
+    if (mCalcCallBack != NULL)
+        mCalcCallBack(this, 0);
 }
 
 /* 802EEA2C-802EEB24       .text entry__8J3DModelFv */
 void J3DModel::entry() {
-    /* Nonmatching */
+    j3dSys.setModel(this);
+
+    if (checkFlag(J3DMdlFlag_SkinPosCpu)) {
+        j3dSys.onFlag(J3DSysFlag_SkinPosCpu);
+    } else {
+        j3dSys.offFlag(J3DSysFlag_SkinPosCpu);
+    }
+
+    if (checkFlag(J3DMdlFlag_SkinNrmCpu)) {
+        j3dSys.onFlag(J3DSysFlag_SkinNrmCpu);
+    } else {
+        j3dSys.offFlag(J3DSysFlag_SkinNrmCpu);
+    }
+
+    j3dSys.setTexture(getModelData()->getTexture());
+
+    for (u16 i = 0; i < getModelData()->getJointNum(); i++) {
+        J3DJoint* joint = getModelData()->getJointNodePointer(i);
+        if (joint->getMesh() != NULL) {
+            joint->entryIn();
+        }
+    }
 }
 
 /* 802EEB24-802EEBDC       .text calcViewBaseMtx__FPA4_fRC3VecRA3_A4_CfPA4_f */
@@ -123,7 +468,41 @@ void J3DModel::calcDrawMtx() {
 
 /* 802EEE30-802EF050       .text viewCalc__8J3DModelFv */
 void J3DModel::viewCalc() {
-    /* Nonmatching */
+    swapDrawMtx();
+    swapNrmMtx();
+
+    if (mModelData->checkFlag(0x20)) {
+        if (getMtxCalcMode() == 2)
+            calcViewBaseMtx(j3dSys.getViewMtx(), mBaseScale, mBaseTransformMtx, (MtxP)&mInternalView);
+
+        prepareShapePackets();
+    } else if (isCpuSkinningOn()) {
+        if (getMtxCalcMode() == 2)
+            calcViewBaseMtx(j3dSys.getViewMtx(), mBaseScale, mBaseTransformMtx, (MtxP)&mInternalView);
+
+        prepareShapePackets();
+    } else {
+        if (checkFlag(J3DMdlFlag_SkinPosCpu)) {
+            calcDrawMtx();
+            calcNrmMtx();
+            calcBumpMtx();
+            DCStoreRange(getDrawMtxPtr(), mModelData->getDrawMtxNum() * sizeof(Mtx));
+            DCStoreRange(getNrmMtxPtr(), mModelData->getDrawMtxNum() * sizeof(Mtx33));
+        } else if (checkFlag(J3DMdlFlag_SkinNrmCpu)) {
+            calcDrawMtx();
+            calcBBoard();
+            DCStoreRange(getDrawMtxPtr(), mModelData->getDrawMtxNum() * sizeof(Mtx));
+        } else {
+            calcDrawMtx();
+            calcNrmMtx();
+            calcBBoard();
+            calcBumpMtx();
+            DCStoreRange(getDrawMtxPtr(), mModelData->getDrawMtxNum() * sizeof(Mtx));
+            DCStoreRange(getNrmMtxPtr(), mModelData->getDrawMtxNum() * sizeof(Mtx33));
+        }
+
+        prepareShapePackets();
+    }
 }
 
 /* 802EF050-802EF1B8       .text calcNrmMtx__8J3DModelFv */
@@ -143,5 +522,44 @@ void J3DModel::calcBBoard() {
 
 /* 802EF414-802EF5D8       .text prepareShapePackets__8J3DModelFv */
 void J3DModel::prepareShapePackets() {
-    /* Nonmatching */
+    u16 shapeNum = getModelData()->getShapeNum();
+    for (u16 i = 0; i < shapeNum; i++) {
+        J3DShapePacket* pkt = getShapePacket(i);
+        pkt->mpScaleFlagArray = getScaleFlagArray();
+        pkt->mpDrawMtx = getDrawMtxPtrPtr();
+        pkt->mpNrmMtx = getNrmMtxPtrPtr();
+        pkt->mpCurrentViewNo = getCurrentViewNoPtr();
+    }
+
+    for (u16 i = 0; i < shapeNum; i++) {
+        J3DShape *pShape = getModelData()->getShapeNodePointer(i);
+        J3DShapePacket* pkt = getShapePacket(i);
+
+        if (checkFlag(J3DMdlFlag_SkinPosCpu))
+            pShape->onFlag(J3DSysFlag_SkinPosCpu);
+        else
+            pShape->offFlag(J3DSysFlag_SkinPosCpu);
+
+        if (checkFlag(J3DMdlFlag_SkinNrmCpu) && !pShape->checkFlag(J3DShpFlag_EnableLod))
+            pShape->onFlag(J3DSysFlag_SkinNrmCpu);
+        else
+            pShape->offFlag(J3DSysFlag_SkinNrmCpu);
+
+        if (getMtxCalcMode() == 2)
+            pkt->setBaseMtxPtr(&mInternalView);
+        else
+            pkt->setBaseMtxPtr(&j3dSys.mViewMtx);
+    }
+
+    if (getModelData()->checkBumpFlag() == 1) {
+        for (s32 i = 0; i < getModelData()->getMaterialNum(); i++) {
+            J3DMaterial* pMaterial = getModelData()->getMaterialNodePointer(i);
+            if (pMaterial->getTexGenBlock()->getNBTScale()->mbHasScale) {
+                J3DShape *pShape = pMaterial->getShape();
+                J3DShapePacket *pPacket = getShapePacket(pShape->getIndex());
+                u32 bumpMtxOffset = pShape->getBumpMtxOffset();
+                pPacket->setNrmMtx(getBumpMtxPtrPtr()[bumpMtxOffset]);
+            }
+        }
+    }
 }