Finish merge

include/JSystem/J3DGraphAnimator/J3DAnimation.h

@@ -281,10 +281,8 @@ STATIC_ASSERT(sizeof(J3DAnmColorFullData) == 0x34);
 class J3DAnmBase {
 public:
     J3DAnmBase(s16 i_frameMax) {
-        mAttribute = 0;
-        field_0x5 = 0;
-        mFrameMax = i_frameMax;
         mFrame = 0.0f;
+        mFrameMax = i_frameMax;
     }
 
     virtual ~J3DAnmBase();
@@ -303,7 +301,12 @@ private:
 
 class J3DAnmTransform : public J3DAnmBase {
 public:
-    J3DAnmTransform(s16, f32*, s16*, f32*);
+    J3DAnmTransform(s16 i_frameMax, f32* p1, s16* p2, f32* p3) : J3DAnmBase(i_frameMax) {
+        field_0x10 = p2;
+        field_0x14 = p3;
+        field_0x18 = 0;
+        field_0xc = p1;
+    }
 
     virtual ~J3DAnmTransform();
     virtual s32 getKind() const;
@@ -313,17 +316,17 @@ private:
     /* 0x0C */ f32* field_0xc;
     /* 0x10 */ s16* field_0x10;
     /* 0x14 */ f32* field_0x14;
-    /* 0x18 */ s16 field_0x18;
-    /* 0x1A */ s16 field_0x1a;
-    /* 0x1C */ s16 field_0x1c;
-    /* 0x1E */ s16 field_0x1e;
-};  // Size: 0x20
+    /* 0x18 */ s32 field_0x18;
+    /* 0x1C */ s16 field_0x1a;
+    /* 0x1E */ s16 field_0x1c;
+    /* 0x20 */ s16 field_0x1e;
+};  // Size: 0x22
 
 class J3DAnmTransformKey : public J3DAnmTransform {
 public:
     J3DAnmTransformKey() : J3DAnmTransform(0, NULL, NULL, NULL) {
-        field_0x20 = 0;
         field_0x24 = 0;
+        field_0x28 = 0;
     }
 
     void calcTransform(f32, u16, J3DTransformInfo*) const;
@@ -333,9 +336,9 @@ public:
     virtual void getTransform(u16, J3DTransformInfo*) const;
 
 private:
-    /* 0x20 */ int field_0x20;
     /* 0x24 */ int field_0x24;
-};  // Size: 0x28
+    /* 0x28 */ int field_0x28;
+};  // Size: 0x2C
 
 class J3DAnmTransformFull : public J3DAnmTransform {
 public:

include/JSystem/J3DGraphAnimator/J3DJoint.h

@@ -1,8 +1,9 @@
 #ifndef J3DJOINT_H
 #define J3DJOINT_H
 
-#include "JSystem/J3DGraphBase/J3DTransform.h"
 #include "JSystem/J3DGraphAnimator/J3DNode.h"
+#include "JSystem/J3DGraphBase/J3DSys.h"
+#include "JSystem/J3DGraphBase/J3DTransform.h"
 
 class J3DAnmTransform;
 class J3DJoint;
@@ -11,45 +12,117 @@ class J3DMtxBuffer;
 
 class J3DMtxCalc {
 public:
-    static void setMtxBuffer(J3DMtxBuffer*);
+    virtual void init(const Vec&, const Mtx&) {}
+    virtual void recursiveCalc(J3DNode*) {}
+    virtual void calcTransform(u16, const J3DTransformInfo&) {}
+    virtual void calc(u16) {}
 
-    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;
+    void initAnm() {
+        for (int i = 0; i < 4; i++) {
+            mOne[i] = 0;
+            mTwo[i] = 0.0f;
+        }
+    }
+    void setAnmTransform(J3DAnmTransform* mAnmTransform);
 
-    static J3DMtxBuffer* getMtxBuffer() { return mMtxBuffer; }
-    static J3DJoint* getJoint() { return mJoint; }
-    static void setJoint(J3DJoint* joint) { mJoint = joint; }
-
-    static J3DMtxBuffer* mMtxBuffer;
-    static J3DJoint* mJoint;
-};  // Size: 0x4
-
-class J3DMtxCalcNoAnmBase : public J3DMtxCalc {
 public:
-    virtual ~J3DMtxCalcNoAnmBase();
+    u32 mOne[4];
+    f32 mTwo[4];
 };
 
-template <class A, class B>
-class J3DMtxCalcNoAnm : public J3DMtxCalcNoAnmBase, public A, public B {
+class J3DMtxCalcAnm : public virtual J3DMtxCalc {
 public:
-    J3DMtxCalcNoAnm() {}
-    virtual ~J3DMtxCalcNoAnm() {}
-    virtual void init(Vec const& param_0, f32 const (&param_1)[3][4]);
-    virtual void calc();
+    J3DMtxCalcAnm(J3DAnmTransform* mAnmTransform) : J3DMtxCalc() { setAnmTransform(mAnmTransform); }
+    virtual ~J3DMtxCalcAnm() { initAnm(); }
+    virtual void calc(u16);
+};
+
+class J3DMtxCalcBasic : public virtual J3DMtxCalc {
+private:
+    Mtx mBackupMtx;
+    Vec mBackupS;
+    Vec mBackupParentS;
+
+public:
+    J3DMtxCalcBasic();
+    virtual ~J3DMtxCalcBasic() {}
+    virtual void init(const Vec& vec, const Mtx& mtx);
+    virtual void recursiveCalc(J3DNode*);
+    virtual void calcTransform(u16, const J3DTransformInfo&);
+    virtual void calc(u16);
+
+    Mtx& getBackupMtx() { return mBackupMtx; }
+    Vec& getBackupS() { return mBackupS; }
+    Vec& getBackupParentS() { return mBackupParentS; }
+
+    void setBackupS(const Vec& vec) { mBackupS = vec; }
+    void setBackupParentS(const Vec& vec) { mBackupParentS = vec; }
+};
+
+class J3DMtxCalcSoftimage : public J3DMtxCalcBasic {
+public:
+    J3DMtxCalcSoftimage() : J3DMtxCalc() {}
+    virtual ~J3DMtxCalcSoftimage();
+    virtual void init(const Vec& vec, const Mtx& mtx);
+    virtual void calcTransform(u16, const J3DTransformInfo&);
+};
+
+class J3DMtxCalcMaya : public J3DMtxCalcBasic {
+public:
+    J3DMtxCalcMaya() : J3DMtxCalcBasic() {}
+    virtual ~J3DMtxCalcMaya() {}
+    virtual void init(const Vec& vec, const Mtx& mtx) {
+        // TODO: This breaks some TUs by adding extra data ({0x3F800000, 0x3F800000, 0x3F800000})
+        // J3DSys::mParentS = (Vec){1.0f, 1.0f, 1.0f};
+        J3DSys::mCurrentS = vec;
+        J3DSys::mCurrentMtx[0][0] = mtx[0][0] * J3DSys::mCurrentS.x;
+        J3DSys::mCurrentMtx[0][1] = mtx[0][1] * J3DSys::mCurrentS.y;
+        J3DSys::mCurrentMtx[0][2] = mtx[0][2] * J3DSys::mCurrentS.z;
+        J3DSys::mCurrentMtx[0][3] = mtx[0][3];
+        J3DSys::mCurrentMtx[1][0] = mtx[1][0] * J3DSys::mCurrentS.x;
+        J3DSys::mCurrentMtx[1][1] = mtx[1][1] * J3DSys::mCurrentS.y;
+        J3DSys::mCurrentMtx[1][2] = mtx[1][2] * J3DSys::mCurrentS.z;
+        J3DSys::mCurrentMtx[1][3] = mtx[1][3];
+        J3DSys::mCurrentMtx[2][0] = mtx[2][0] * J3DSys::mCurrentS.x;
+        J3DSys::mCurrentMtx[2][1] = mtx[2][1] * J3DSys::mCurrentS.y;
+        J3DSys::mCurrentMtx[2][2] = mtx[2][2] * J3DSys::mCurrentS.z;
+        J3DSys::mCurrentMtx[2][3] = mtx[2][3];
+    }
+    virtual void calcTransform(u16, const J3DTransformInfo&);
+};
+
+class J3DMtxCalcMayaAnm : public J3DMtxCalcMaya, public J3DMtxCalcAnm {
+public:
+    J3DMtxCalcMayaAnm(J3DAnmTransform* pAnmTransform)
+        : J3DMtxCalcMaya(), J3DMtxCalcAnm(pAnmTransform) {}
+    virtual ~J3DMtxCalcMayaAnm() {}
+    virtual void calc(u16 v) { J3DMtxCalcAnm::calc(v); }
+};
+
+enum J3DJointMtxType {
+    J3DJntMtxType_Normal,
+    J3DJntMtxType_BBoard,
+    J3DJntMtxType_YBBoard,
+    J3DJntMtxType_Multi,
 };
 
 class J3DJoint : public J3DNode {
 public:
-    J3DJoint();
-    void entryIn();
-    void recursiveCalc();
+    void initialize();
     void addMesh(J3DMaterial*);
+    void calcIn();
+    void calcOut();
+    void entryIn();
+    u32 getType() const { return 'NJNT'; }
+    void recursiveCalc();
+
+    J3DJoint();
+    ~J3DJoint() {}
 
     J3DMaterial* getMesh() { return mMesh; }
     u16 getJntNo() const { return mJntNo; }
+    u8 getKind() const { return mKind; }
+    u8 getMtxType() const { return getKind() >> 4; }
     u8 getScaleCompensate() const { return mScaleCompensate; }
     void setCurrentMtxCalc(J3DMtxCalc* pMtxCalc) { mCurrentMtxCalc = pMtxCalc; }
     J3DTransformInfo& getTransformInfo() { return mTransformInfo; }
@@ -67,7 +140,7 @@ private:
     friend struct J3DJointFactory;
     friend class J3DJointTree;
 
-    /* 0x14 */ u16 mJntNo;
+    /* 0x18 */ u16 mJntNo;
     /* 0x1A */ u8 mKind;
     /* 0x1B */ u8 mScaleCompensate;
     /* 0x1C */ J3DTransformInfo mTransformInfo;
@@ -77,26 +150,6 @@ private:
     /* 0x58 */ J3DMtxCalc* mMtxCalc;
     /* 0x5C */ J3DMtxCalc* mOldMtxCalc;
     /* 0x60 */ J3DMaterial* mMesh;
-};  // Size: 0x54
-
-struct J3DMtxCalcJ3DSysInitMaya {
-    static void init(Vec const&, f32 const (&)[3][4]);
-};
-
-struct J3DMtxCalcJ3DSysInitBasic {
-    static void init(Vec const&, f32 const (&)[3][4]);
-};
-
-struct J3DMtxCalcCalcTransformSoftimage {
-    static void calcTransform(J3DTransformInfo const&);
-};
-
-struct J3DMtxCalcCalcTransformMaya {
-    static void calcTransform(J3DTransformInfo const&);
-};
-
-struct J3DMtxCalcCalcTransformBasic {
-    static void calcTransform(J3DTransformInfo const&);
-};
+};  // Size: 0x64
 
 #endif /* J3DJOINT_H */

include/JSystem/J3DGraphAnimator/J3DJointTree.h

@@ -10,6 +10,8 @@ class JUTNameTab;
 struct J3DModelHierarchy {
     /* 0x0 */ u16 mType;
     /* 0x2 */ u16 mValue;
+
+    inline u16 getValue() const { return mValue; }
 };
 
 class J3DMaterialTable;

include/JSystem/J3DGraphAnimator/J3DMaterialAnm.h

@@ -9,24 +9,29 @@ typedef struct _GXColorS10 GXColorS10;
 class J3DMatColorAnm {
 public:
     ~J3DMatColorAnm() {}
-    J3DMatColorAnm() {}
-    J3DMatColorAnm(J3DAnmColor * pAnm, u16 materialIdx) {
+    J3DMatColorAnm() {
+        mAnmColor = NULL;
+        mAnmIndex = 0;
+    }
+    J3DMatColorAnm(J3DAnmColor* pAnm, u16 anmIdx) {
         mAnmColor = pAnm;
-        mMaterialIdx = materialIdx;
+        mAnmIndex = anmIdx;
     }
 
     void operator=(J3DMatColorAnm const& other) {
         mAnmColor = other.mAnmColor;
-        mMaterialIdx = other.mMaterialIdx;
+        mAnmIndex = other.mAnmIndex;
         mAnmFlag = other.mAnmFlag;
     }
 
+    void setAnmIndex(u16 index) { mAnmIndex = index; }
     void setAnmFlag(bool flag) { mAnmFlag = flag; }
     bool getAnmFlag() const { return mAnmFlag; }
-    void calc(_GXColor* pColor) const { mAnmColor->getColor(mMaterialIdx, pColor); }
+    void setAnmColor(J3DAnmColor* anmColor) { mAnmColor = anmColor; }
+    void calc(_GXColor* pColor) const { mAnmColor->getColor(mAnmIndex, pColor); }
 
 private:
-    /* 0x0 */ u16 mMaterialIdx;
+    /* 0x0 */ u16 mAnmIndex;
     /* 0x2 */ u16 mAnmFlag;
     /* 0x4 */ J3DAnmColor* mAnmColor;
 };  // Size: 0x8
@@ -34,21 +39,26 @@ private:
 class J3DTexNoAnm {
 public:
     ~J3DTexNoAnm() {};
-    J3DTexNoAnm() {};
-    virtual void calc(u16* param_0) const { mAnmTexPattern->getTexNo(field_0x4, param_0); }
+    J3DTexNoAnm() {
+        mAnmTexPattern = NULL;
+        mAnmIndex = 0;
+    };
+    virtual void calc(u16* param_0) const { mAnmTexPattern->getTexNo(mAnmIndex, param_0); }
 
     void operator=(J3DTexNoAnm const& other) {
         mAnmTexPattern = other.mAnmTexPattern;
-        field_0x4 = other.field_0x4;
+        mAnmIndex = other.mAnmIndex;
         mAnmFlag = other.mAnmFlag;
     }
 
+    void setAnmIndex(u16 index) { mAnmIndex = index; }
     void setAnmFlag(bool flag) { mAnmFlag = flag; }
     bool getAnmFlag() const { return mAnmFlag; }
     J3DAnmTexPattern* getAnmTexPattern() { return mAnmTexPattern; }
+    void setAnmTexPattern(J3DAnmTexPattern* pattern) { mAnmTexPattern = pattern; }
 
 private:
-    /* 0x4 */ u16 field_0x4;
+    /* 0x4 */ u16 mAnmIndex;
     /* 0x6 */ u16 mAnmFlag;
     /* 0x8 */ J3DAnmTexPattern* mAnmTexPattern;
 };  // Size: 0xC
@@ -56,26 +66,31 @@ private:
 class J3DTexMtxAnm {
 public:
     ~J3DTexMtxAnm() {}
-    J3DTexMtxAnm() {}
-    J3DTexMtxAnm(J3DAnmTextureSRTKey * pAnm, u16 materialIdx) {
+    J3DTexMtxAnm() {
+        mAnmIndex = 0;
+        mAnmTransform = NULL;
+    }
+    J3DTexMtxAnm(J3DAnmTextureSRTKey * pAnm, u16 anmIdx) {
         mAnmTransform = pAnm;
-        mMaterialIdx = materialIdx;
+        mAnmIndex = anmIdx;
     }
 
     void operator=(J3DTexMtxAnm const& other) {
         mAnmTransform = other.mAnmTransform;
-        mMaterialIdx = other.mMaterialIdx;
+        mAnmIndex = other.mAnmIndex;
         mAnmFlag = other.mAnmFlag;
     }
 
-    void setAnmFlag(bool flag) { mAnmFlag = flag; }
-    void calc(J3DTextureSRTInfo* pSRTInfo) const {
-        mAnmTransform->getTransform(mMaterialIdx, pSRTInfo);
-    }
+    void setAnmIndex(u16 index) { mAnmIndex = index; }
     bool getAnmFlag() const { return mAnmFlag; }
+    void setAnmFlag(bool flag) { mAnmFlag = flag; }
+    void setAnmTransform(J3DAnmTextureSRTKey* transform) { mAnmTransform = transform; }
+    void calc(J3DTextureSRTInfo* pSRTInfo) const {
+        mAnmTransform->getTransform(mAnmIndex, pSRTInfo);
+    }
 
 private:
-    /* 0x0 */ u16 mMaterialIdx;
+    /* 0x0 */ u16 mAnmIndex;
     /* 0x2 */ u16 mAnmFlag;
     /* 0x4 */ J3DAnmTextureSRTKey* mAnmTransform;
 };  // Size: 0x8
@@ -83,24 +98,29 @@ private:
 class J3DTevKColorAnm {
 public:
     ~J3DTevKColorAnm() {}
-    J3DTevKColorAnm() {}
-    J3DTevKColorAnm(J3DAnmTevRegKey * pAnm, u16 materialIdx) {
+    J3DTevKColorAnm() {
+        mAnmTevReg = NULL;
+        mAnmIndex = 0;
+    }
+    J3DTevKColorAnm(J3DAnmTevRegKey * pAnm, u16 anmIdx) {
         mAnmTevReg = pAnm;
-        mMaterialIdx = materialIdx;
+        mAnmIndex = anmIdx;
     }
 
     void operator=(J3DTevKColorAnm const& other) {
         mAnmTevReg = other.mAnmTevReg;
-        mMaterialIdx = other.mMaterialIdx;
+        mAnmIndex = other.mAnmIndex;
         mAnmFlag = other.mAnmFlag;
     }
 
+    void setAnmIndex(u16 index) { mAnmIndex = index; }
     void setAnmFlag(bool flag) { mAnmFlag = flag; }
     bool getAnmFlag() const { return mAnmFlag; }
-    void calc(_GXColor* pColor) const { mAnmTevReg->getTevKonstReg(mMaterialIdx, pColor); }
+    void setAnmTevReg(J3DAnmTevRegKey* tevReg) { mAnmTevReg = tevReg; }
+    void calc(_GXColor* pColor) const { mAnmTevReg->getTevKonstReg(mAnmIndex, pColor); }
 
 private:
-    /* 0x0 */ u16 mMaterialIdx;
+    /* 0x0 */ u16 mAnmIndex;
     /* 0x2 */ u16 mAnmFlag;
     /* 0x4 */ J3DAnmTevRegKey* mAnmTevReg;
 };  // Size: 0x8
@@ -108,24 +128,29 @@ private:
 class J3DTevColorAnm {
 public:
     ~J3DTevColorAnm() {}
-    J3DTevColorAnm() {}
-    J3DTevColorAnm(J3DAnmTevRegKey * pAnm, u16 materialIdx) {
+    J3DTevColorAnm() {
+        mAnmTevReg = NULL;
+        mAnmIndex = 0;
+    }
+    J3DTevColorAnm(J3DAnmTevRegKey * pAnm, u16 anmIdx) {
         mAnmTevReg = pAnm;
-        mMaterialIdx = materialIdx;
+        mAnmIndex = anmIdx;
     }
 
     void operator=(J3DTevColorAnm const& other) {
         mAnmTevReg = other.mAnmTevReg;
-        mMaterialIdx = other.mMaterialIdx;
+        mAnmIndex = other.mAnmIndex;
         mAnmFlag = other.mAnmFlag;
     }
 
+    void setAnmIndex(u16 index) { mAnmIndex = index; }
     void setAnmFlag(bool flag) { mAnmFlag = flag; }
     bool getAnmFlag() const { return mAnmFlag; }
-    void calc(_GXColorS10* pColor) const { mAnmTevReg->getTevColorReg(mMaterialIdx, pColor); }
+    void setAnmTevReg(J3DAnmTevRegKey* tevReg) { mAnmTevReg = tevReg; }
+    void calc(_GXColorS10* pColor) const { mAnmTevReg->getTevColorReg(mAnmIndex, pColor); }
 
 private:
-    /* 0x0 */ u16 mMaterialIdx;
+    /* 0x0 */ u16 mAnmIndex;
     /* 0x2 */ u16 mAnmFlag;
     /* 0x4 */ J3DAnmTevRegKey* mAnmTevReg;
 };  // Size: 0x8

include/JSystem/J3DGraphAnimator/J3DMaterialAttach.h

@@ -35,7 +35,7 @@ public:
 
     virtual ~J3DMaterialTable();
 
-    J3DMaterial* getMaterialNodePointer(u16 idx) const { return mMaterialNodePointer[idx]; }
+    J3DMaterial* getMaterialNodePointer(const u16 idx) const { return mMaterialNodePointer[idx]; }
 
     J3DTexture* getTexture() const { return mTexture; }
     JUTNameTab* getTextureName() const { return mTextureName; }
@@ -45,6 +45,7 @@ public:
     JUTNameTab* getMaterialName() const { return mMaterialName; }
 
     u16 getMaterialNum() const { return mMaterialNum; }
+    bool isLocked() const { return field_0x20 == 1; }
 
 private:
     friend class J3DJointTree;
@@ -57,6 +58,7 @@ private:
     /* 0x14 */ u32 field_0x14;
     /* 0x18 */ J3DTexture* mTexture;
     /* 0x1C */ JUTNameTab* mTextureName;
-};  // Size: 0x20
+    /* 0x20 */ u16 field_0x20;
+};  // Size: 0x24
 
 #endif /* J3DMATERIALATTACH_H */

include/JSystem/J3DGraphAnimator/J3DModel.h

@@ -30,13 +30,21 @@ struct J3DUnkCalc2 {
 
 typedef void (*J3DCalcCallBack)(J3DModel*, u32 timing);
 
+class J3DAnmVisibilityFull;
 class J3DMatPacket;
 class J3DShapePacket;
 
 class J3DVisibilityManager {
 public:
+    J3DVisibilityManager(J3DAnmVisibilityFull* visibility) {
+        mAnmVisibility = visibility;
+        field_0x8 = 1;
+    }
     virtual ~J3DVisibilityManager();
     virtual void setVisibility(J3DModelData*);
+
+    /* 0x04 */ J3DAnmVisibilityFull* mAnmVisibility;
+    /* 0x08 */ int field_0x8;
 };
 
 class J3DUnkCallBack {
@@ -66,6 +74,8 @@ public:
     void calcDrawMtx();
     void prepareShapePackets();
     MtxP getAnmMtx(int idx) { return mpNodeMtx[idx]; }
+    void setAnmMtx(int idx, Mtx mtx) { MTXCopy(mtx, mpNodeMtx[idx]); }
+    MtxP getWeightAnmMtx(int idx) { return mpWeightEnvMtx[idx]; }
 
     s32 setNoUseDrawMtx();
     s32 createSingleDrawMtx(J3DModelData*);
@@ -76,7 +86,6 @@ public:
     virtual void entry();
     virtual void calc();
     virtual void calcMaterial();
-    virtual void calcDiffTexMtx();
     virtual void viewCalc();
     virtual ~J3DModel();
 
@@ -105,18 +114,25 @@ public:
     u32 getMtxCalcMode() const { return mFlags & 0x03; }
     u32* getCurrentViewNoPtr() { return &mCurrentViewNo; }
     u8* getScaleFlagArray() const { return mpScaleFlagArr; }
+    u8 getScaleFlag(u32 idx) const { return mpScaleFlagArr[idx]; }
+    void setScaleFlag(int idx, u8 param_1) { mpScaleFlagArr[idx] = param_1; }
+    u8 getEnvScaleFlag(u32 idx) const { return mpEvlpScaleFlagArr[idx]; }
     J3DVertexBuffer* getVertexBuffer() const { return (J3DVertexBuffer*)&mVertexBuffer; }
     J3DMatPacket* getMatPacket(u16 idx) const { return &mpMatPacket[idx]; }
     J3DShapePacket* getShapePacket(u16 idx) const { return &mpShapePacket[idx]; }
     Mtx** getDrawMtxPtrPtr() const { return mpDrawMtxBuf[1]; }
     Mtx* getDrawMtxPtr() const { return mpDrawMtxBuf[1][mCurrentViewNo]; }
+    Mtx& getDrawMtx(u32 idx) const { return getDrawMtxPtr()[idx]; }
     Mtx33** getNrmMtxPtrPtr() const { return mpNrmMtxBuf[1]; }
     Mtx33* getNrmMtxPtr() const { return mpNrmMtxBuf[1][mCurrentViewNo]; }
-    Mtx33*** getBumpMtxPtrPtr() const { return mpBumpMtxArr[1]; }
+    Mtx33& getNrmMtx(u32 idx) const { return getNrmMtxPtr()[idx]; }
+    Mtx33** getBumpMtxPtrPtr(u32 idx) const { return mpBumpMtxArr[1][idx]; }
+    Mtx33* getBumpMtxPtr(u32 idx) const { return mpBumpMtxArr[1][idx][mCurrentViewNo]; }
     void setBaseScale(const Vec& scale) { mBaseScale = scale; }
     void setUserArea(void* area) { mUserArea = area; }
     void* getUserArea() const { return mUserArea; }
     Vec* getBaseScale() { return &mBaseScale; }
+    void setVisibilityManager(J3DVisibilityManager* manager) { mpVisibilityManager = manager; }
 
     void setAnmMtx(int jntNo, Mtx mtx) {
         MTXCopy(mtx, mpNodeMtx[jntNo]);

include/JSystem/J3DGraphAnimator/J3DModelData.h

@@ -55,6 +55,8 @@ public:
     JUTNameTab* getTextureName() const { return mMaterialTable.getTextureName(); }
     void setTexture(J3DTexture* pTexture) { mMaterialTable.setTexture(pTexture); }
     void setTextureName(JUTNameTab* pTextureName) { mMaterialTable.setTextureName(pTextureName); }
+    bool isLocked() { return mMaterialTable.isLocked(); }
+    u16 getDrawFullWgtMtxNum() const { return mJointTree.getDrawFullWgtMtxNum(); }
     u16 getWEvlpMtxNum() const { return mJointTree.getWEvlpMtxNum(); }
     u16* getWEvlpMixMtxIndex() const { return mJointTree.getWEvlpMixIndex(); }
     f32* getWEvlpMixWeight() const { return mJointTree.getWEvlpMixWeight(); }
@@ -92,7 +94,7 @@ private:
     /* 0x0E */ u16 mbHasBillboard;
     /* 0x10 */ J3DJointTree mJointTree;
     /* 0x58 */ J3DMaterialTable mMaterialTable;
-    /* 0x78 */ J3DShapeTable mShapeTable;
+    /* 0x7C */ J3DShapeTable mShapeTable;
     /* 0x84 */ J3DVertexData mVertexData;
     /* 0xE0 */ JUTNameTab * mName;
 };  // Size: 0xE4

include/JSystem/J3DGraphAnimator/J3DMtxBuffer.h

@@ -1,81 +0,0 @@
-#ifndef J3DMTXBUFFER_H
-#define J3DMTXBUFFER_H
-
-#include "JSystem/J3DGraphAnimator/J3DModelData.h"
-#include "dolphin/types.h"
-
-class J3DModelData;
-
-class J3DMtxBuffer {
-public:
-    J3DMtxBuffer() { initialize(); }
-
-    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]); }
-    MtxP getWeightAnmMtx(int idx) const { return mpWeightEvlpMtx[idx]; }
-
-    void setScaleFlag(int idx, u8 flag) { mpScaleFlagArr[idx] = flag; }
-    u32* getCurrentViewNoPtr() { return &mCurrentViewNo; }
-    u8* getScaleFlagArray() const { return mpScaleFlagArr; }
-    u8 getScaleFlag(int idx) const { return mpScaleFlagArr[idx]; }
-    u8 getEnvScaleFlag(int idx) const { return mpEvlpScaleFlagArr[idx]; }
-    Mtx** getDrawMtxPtrPtr() const { return mpDrawMtxArr[1]; }
-    Mtx* getDrawMtxPtr() const { return mpDrawMtxArr[1][mCurrentViewNo]; }
-    Mtx* getDrawMtx(u16 idx) const { return &mpDrawMtxArr[1][mCurrentViewNo][idx]; }
-    Mtx33** getNrmMtxPtrPtr() const { return mpNrmMtxArr[1]; }
-    Mtx33* getNrmMtxPtr() const { return mpNrmMtxArr[1][mCurrentViewNo]; }
-    Mtx33* getNrmMtx(u16 idx) const { return &mpNrmMtxArr[1][mCurrentViewNo][idx]; }
-    Mtx33*** getBumpMtxPtrPtr() const { return mpBumpMtxArr[1]; }
-    Mtx33* getBumpMtxPtr(int idx) const { return mpBumpMtxArr[1][idx][mCurrentViewNo]; }
-    J3DJointTree* getJointTree() const { return mJointTree; }
-
-    void swapDrawMtx() {
-        Mtx* tmp = mpDrawMtxArr[0][mCurrentViewNo];
-        mpDrawMtxArr[0][mCurrentViewNo] = mpDrawMtxArr[1][mCurrentViewNo];
-        mpDrawMtxArr[1][mCurrentViewNo] = tmp;
-    }
-
-    void swapNrmMtx() {
-        Mtx33* tmp = mpNrmMtxArr[0][mCurrentViewNo];
-        mpNrmMtxArr[0][mCurrentViewNo] = mpNrmMtxArr[1][mCurrentViewNo];
-        mpNrmMtxArr[1][mCurrentViewNo] = tmp;
-    }
-
-    static Mtx sNoUseDrawMtx;
-    static Mtx33 sNoUseNrmMtx;
-    static Mtx* sNoUseDrawMtxPtr;
-    static Mtx33* sNoUseNrmMtxPtr;
-
-private:
-    /* 0x00 */ J3DJointTree* mJointTree;
-    /* 0x04 */ u8* mpScaleFlagArr;
-    /* 0x08 */ u8* mpEvlpScaleFlagArr;
-    /* 0x0C */ Mtx* mpAnmMtx;
-    /* 0x10 */ Mtx* mpWeightEvlpMtx;
-    /* 0x14 */ Mtx** mpDrawMtxArr[2];
-    /* 0x1C */ Mtx33** mpNrmMtxArr[2];
-    /* 0x28 */ Mtx33*** mpBumpMtxArr[2];
-    /* 0x2C */ u32 mFlags;
-    /* 0x30 */ u32 mCurrentViewNo;
-    /* 0x34 */ Mtx* mpUserAnmMtx;
-
-public:
-    virtual ~J3DMtxBuffer();
-};
-
-void J3DCalcViewBaseMtx(f32 (*param_0)[4], Vec const& param_1, f32 const (&param_2)[3][4],
-                            f32 (*param_3)[4]);
-
-#endif /* J3DMTXBUFFER_H */

include/JSystem/J3DGraphAnimator/J3DNode.h

@@ -4,14 +4,15 @@
 #include "dolphin/mtx/mtx.h"
 
 class J3DNode;
+class J3DModelData;
 typedef int (*J3DNodeCallBack)(J3DNode*, int);
 
 class J3DNode {
 public:
-    virtual void init(Vec const& param_0, Mtx*);
+    virtual void init(J3DModelData*) {}
     virtual void entryIn();
-    virtual void calcIn();
-    virtual void calcOut();
+    virtual void calcIn() {}
+    virtual void calcOut() {}
     virtual u32 getType() const;
     virtual ~J3DNode();
 

include/JSystem/J3DGraphAnimator/J3DShapeTable.h

@@ -17,9 +17,8 @@ public:
     J3DShape* getShapeNodePointer(u16 idx) const { return mShapeNodePointer[idx]; }
 
 private:
-    /* 0x0 */ void *field_0x0;
-    /* 0x4 */ u16 mShapeNum;
-    /* 0x8 */ J3DShape** mShapeNodePointer;
-};  // Size: 0x0C
+    /* 0x0 */ u16 mShapeNum;
+    /* 0x4 */ J3DShape** mShapeNodePointer;
+};  // Size: 0x08
 
 #endif /* J3DSHAPETABLE_H */

include/JSystem/J3DGraphAnimator/J3DSkinDeform.h

@@ -2,10 +2,11 @@
 #define J3DSKINDEFORM_H
 
 #include "JSystem/J3DGraphAnimator/J3DCluster.h"
-#include "JSystem/J3DGraphAnimator/J3DMtxBuffer.h"
 #include "JSystem/J3DGraphBase/J3DTransform.h"
 #include "dolphin/types.h"
 
+class J3DModelData;
+class J3DVertexBuffer;
 class J3DModel;
 class J3DAnmCluster;
 
@@ -51,13 +52,13 @@ public:
     void initSkinInfo(J3DModelData*);
     int initMtxIndexArray(J3DModelData*);
     void changeFastSkinDL(J3DModelData*);
-    void calcNrmMtx(J3DMtxBuffer*);
+    // 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 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) {