diff --git a/include/JSystem/J3DGraphAnimator/J3DJointTree.h b/include/JSystem/J3DGraphAnimator/J3DJointTree.h
index aaae4c8e9..32f41941a 100644
--- a/include/JSystem/J3DGraphAnimator/J3DJointTree.h
+++ b/include/JSystem/J3DGraphAnimator/J3DJointTree.h
@@ -8,7 +8,7 @@
 class JUTNameTab;
 
 struct J3DModelHierarchy {
-    /* 0x0 */ u16 mType;
+    /* 0x0 */ u16 mType; // TODO enum
     /* 0x2 */ u16 mValue;
 
     inline u16 getValue() const { return mValue; }
diff --git a/include/JSystem/J3DGraphLoader/J3DMaterialFactory.h b/include/JSystem/J3DGraphLoader/J3DMaterialFactory.h
index 7eb478020..b2cf98369 100644
--- a/include/JSystem/J3DGraphLoader/J3DMaterialFactory.h
+++ b/include/JSystem/J3DGraphLoader/J3DMaterialFactory.h
@@ -25,10 +25,10 @@ public:
     void createPatchedMaterial(J3DMaterial*, int, unsigned long) const;
     void modifyPatchedCurrentMtx(J3DMaterial*, int) const;
     void createLockedMaterial(J3DMaterial*, int, unsigned long) const;
-    void calcSize(J3DMaterial*, MaterialType, int, unsigned long) const;
-    void calcSizeNormalMaterial(J3DMaterial*, int, unsigned long) const;
-    void calcSizePatchedMaterial(J3DMaterial*, int, unsigned long) const;
-    void calcSizeLockedMaterial(J3DMaterial*, int, unsigned long) const;
+    u32 calcSize(J3DMaterial*, MaterialType, int, unsigned long) const;
+    u32 calcSizeNormalMaterial(J3DMaterial*, int, unsigned long) const;
+    u32 calcSizePatchedMaterial(J3DMaterial*, int, unsigned long) const;
+    u32 calcSizeLockedMaterial(J3DMaterial*, int, unsigned long) const;
     void newMatColor(int, int) const;
     void newColorChanNum(int) const;
     void newColorChan(int, int) const;
diff --git a/include/JSystem/J3DGraphLoader/J3DModelLoader.h b/include/JSystem/J3DGraphLoader/J3DModelLoader.h
index da967138b..3bdf64994 100644
--- a/include/JSystem/J3DGraphLoader/J3DModelLoader.h
+++ b/include/JSystem/J3DGraphLoader/J3DModelLoader.h
@@ -11,6 +11,10 @@ inline u32 getBdlFlag_MaterialType(u32 i_flags) {
 struct J3DModelBlock {
     /* 0x00 */ u32 mBlockType;
     /* 0x04 */ u32 mBlockSize;
+
+    const J3DModelBlock* getNext() const {
+        return reinterpret_cast<const J3DModelBlock*>(reinterpret_cast<const u8*>(this) + mBlockSize);
+    }
 };
 
 struct J3DModelFileData {
@@ -135,18 +139,18 @@ public:
     virtual J3DModelData* load(const void*, u32);
     virtual J3DMaterialTable* loadMaterialTable(const void*);
     virtual J3DModelData* loadBinaryDisplayList(const void*, u32);
-    virtual void calcLoadSize(const void*, u32);
-    virtual void calcLoadMaterialTableSize(const void*);
-    virtual void calcLoadBinaryDisplayListSize(const void*, u32);
-    virtual void countMaterialNum(const void*);
+    virtual u32 calcLoadSize(const void*, u32);
+    virtual u32 calcLoadMaterialTableSize(const void*);
+    virtual u32 calcLoadBinaryDisplayListSize(const void*, u32);
+    virtual u16 countMaterialNum(const void*);
     virtual void setupBBoardInfo();
     virtual ~J3DModelLoader() {}
     virtual void readMaterial(const J3DMaterialBlock*, u32) {}
     virtual void readMaterial_v21(const J3DMaterialBlock_v21*, u32) {}
     virtual void readMaterialTable(const J3DMaterialBlock*, u32) {}
     virtual void readMaterialTable_v21(const J3DMaterialBlock_v21*, u32) {}
-    virtual s32 calcSizeMaterial(const J3DMaterialBlock*, u32) { return 0; }
-    virtual s32 calcSizeMaterialTable(const J3DMaterialBlock*, u32) { return 0; }
+    virtual u32 calcSizeMaterial(const J3DMaterialBlock*, u32) { return 0; }
+    virtual u32 calcSizeMaterialTable(const J3DMaterialBlock*, u32) { return 0; }
     
     void readInformation(const J3DModelInfoBlock*, u32);
     void readVertex(const J3DVertexBlock*);
@@ -159,13 +163,13 @@ public:
     void readPatchedMaterial(const J3DMaterialBlock*, u32);
     void readMaterialDL(const J3DMaterialDLBlock*, u32);
     void modifyMaterial(u32);
-    void calcSizeInformation(const J3DModelInfoBlock*, u32);
-    void calcSizeJoint(const J3DJointBlock*);
-    void calcSizeShape(const J3DShapeBlock*, u32);
-    void calcSizeTexture(const J3DTextureBlock*);
-    void calcSizeTextureTable(const J3DTextureBlock*);
-    void calcSizePatchedMaterial(const J3DMaterialBlock*, u32);
-    void calcSizeMaterialDL(const J3DMaterialDLBlock*, u32);
+    u32 calcSizeInformation(const J3DModelInfoBlock*, u32);
+    u32 calcSizeJoint(const J3DJointBlock*);
+    u32 calcSizeShape(const J3DShapeBlock*, u32);
+    u32 calcSizeTexture(const J3DTextureBlock*);
+    u32 calcSizeTextureTable(const J3DTextureBlock*);
+    u32 calcSizePatchedMaterial(const J3DMaterialBlock*, u32);
+    u32 calcSizeMaterialDL(const J3DMaterialDLBlock*, u32);
 
 protected:
     /* 0x04 */ J3DModelData* mpModelData;
@@ -189,8 +193,8 @@ public:
     ~J3DModelLoader_v26() {}
     void readMaterial(const J3DMaterialBlock*, u32);
     void readMaterialTable(const J3DMaterialBlock*, u32);
-    s32 calcSizeMaterial(const J3DMaterialBlock*, u32);
-    s32 calcSizeMaterialTable(const J3DMaterialBlock*, u32);
+    u32 calcSizeMaterial(const J3DMaterialBlock*, u32);
+    u32 calcSizeMaterialTable(const J3DMaterialBlock*, u32);
 };
 
 #endif /* J3DMODELLOADER_H */
diff --git a/src/JSystem/J3DGraphLoader/J3DMaterialFactory.cpp b/src/JSystem/J3DGraphLoader/J3DMaterialFactory.cpp
index 9be37147b..a820a278c 100644
--- a/src/JSystem/J3DGraphLoader/J3DMaterialFactory.cpp
+++ b/src/JSystem/J3DGraphLoader/J3DMaterialFactory.cpp
@@ -57,22 +57,22 @@ void J3DMaterialFactory::createLockedMaterial(J3DMaterial*, int, unsigned long)
 }
 
 /* 802F83A0-802F8420       .text calcSize__18J3DMaterialFactoryCFP11J3DMaterialQ218J3DMaterialFactory12MaterialTypeiUl */
-void J3DMaterialFactory::calcSize(J3DMaterial*, J3DMaterialFactory::MaterialType, int, unsigned long) const {
+u32 J3DMaterialFactory::calcSize(J3DMaterial*, J3DMaterialFactory::MaterialType, int, unsigned long) const {
     /* Nonmatching */
 }
 
 /* 802F8420-802F8554       .text calcSizeNormalMaterial__18J3DMaterialFactoryCFP11J3DMaterialiUl */
-void J3DMaterialFactory::calcSizeNormalMaterial(J3DMaterial*, int, unsigned long) const {
+u32 J3DMaterialFactory::calcSizeNormalMaterial(J3DMaterial*, int, unsigned long) const {
     /* Nonmatching */
 }
 
 /* 802F8554-802F8624       .text calcSizePatchedMaterial__18J3DMaterialFactoryCFP11J3DMaterialiUl */
-void J3DMaterialFactory::calcSizePatchedMaterial(J3DMaterial*, int, unsigned long) const {
+u32 J3DMaterialFactory::calcSizePatchedMaterial(J3DMaterial*, int, unsigned long) const {
     /* Nonmatching */
 }
 
 /* 802F8624-802F863C       .text calcSizeLockedMaterial__18J3DMaterialFactoryCFP11J3DMaterialiUl */
-void J3DMaterialFactory::calcSizeLockedMaterial(J3DMaterial*, int, unsigned long) const {
+u32 J3DMaterialFactory::calcSizeLockedMaterial(J3DMaterial*, int, unsigned long) const {
     /* Nonmatching */
 }
 
diff --git a/src/JSystem/J3DGraphLoader/J3DModelLoader.cpp b/src/JSystem/J3DGraphLoader/J3DModelLoader.cpp
index 5fee05ecb..1f189aaf7 100644
--- a/src/JSystem/J3DGraphLoader/J3DModelLoader.cpp
+++ b/src/JSystem/J3DGraphLoader/J3DModelLoader.cpp
@@ -18,14 +18,15 @@ J3DModelData* J3DModelLoaderDataBase::load(const void* i_data, u32 i_flags) {
     if (i_data == NULL) {
         return NULL;
     }
-    if (*(u32*)i_data == 'J3D1' && *(u32*)((u32)i_data + 4) == 'bmd1') {
+    const J3DModelFileData* fileHeader = (const J3DModelFileData*)i_data;
+    if (fileHeader->mMagic1 == 'J3D1' && fileHeader->mMagic2 == 'bmd1') {
         return NULL;
     }
-    if (*(u32*)i_data == 'J3D2' && *(u32*)((u32)i_data + 4) == 'bmd2') {
+    if (fileHeader->mMagic1 == 'J3D2' && fileHeader->mMagic2 == 'bmd2') {
         J3DModelLoader_v21 loader;
         return loader.load(i_data, i_flags);
     }
-    if (*(u32*)i_data == 'J3D2' && *(u32*)((u32)i_data + 4) == 'bmd3') {
+    if (fileHeader->mMagic1 == 'J3D2' && fileHeader->mMagic2 == 'bmd3') {
         J3DModelLoader_v26 loader;
         return loader.load(i_data, i_flags);
     }
@@ -37,7 +38,8 @@ J3DMaterialTable* J3DModelLoaderDataBase::loadMaterialTable(const void* i_data)
     if (!i_data) {
         return NULL;
     }
-    if (*(u32*)i_data == 'J3D2' && *(u32*)((u32)i_data + 4) == 'bmt3') {
+    const J3DModelFileData* fileHeader = (const J3DModelFileData*)i_data;
+    if (fileHeader->mMagic1 == 'J3D2' && fileHeader->mMagic2 == 'bmt3') {
         J3DModelLoader_v26 loader;
         return loader.loadMaterialTable(i_data);
     }
@@ -49,12 +51,10 @@ J3DModelData* J3DModelLoaderDataBase::loadBinaryDisplayList(const void* i_data,
     if (!i_data) {
         return NULL;
     }
-    if (*(u32*)i_data == 'J3D2') {
-        u32 file_type = *(u32*)((u32)i_data + 4);
-        if (file_type == 'bdl3' || file_type == 'bdl4') {
-            J3DModelLoader_v26 loader;
-            return loader.loadBinaryDisplayList(i_data, i_flags);
-        }
+    const J3DModelFileData* fileHeader = (const J3DModelFileData*)i_data;
+    if (fileHeader->mMagic1 == 'J3D2' && (fileHeader->mMagic2 == 'bdl3' || fileHeader->mMagic2 == 'bdl4')) {
+        J3DModelLoader_v26 loader;
+        return loader.loadBinaryDisplayList(i_data, i_flags);
     }
     return NULL;
 }
@@ -102,7 +102,7 @@ J3DModelData* J3DModelLoader::load(const void* i_data, u32 i_flags) {
                 OSReport("Unknown data block\n");
                 break;
         }
-        block = (J3DModelBlock*)((u32)block + block->mBlockSize);
+        block = block->getNext();
     }
     const J3DModelHierarchy* hierarchy = mpModelData->getHierarchy();
     mpModelData->makeHierarchy(NULL, &hierarchy);
@@ -137,7 +137,7 @@ J3DMaterialTable* J3DModelLoader::loadMaterialTable(const void* i_data) {
                 OSReport("Unknown data block\n");
                 break;
         }
-        block = (J3DModelBlock*)((u32)block + block->mBlockSize);
+        block = block->getNext();
     }
     if (mpMaterialTable->getTexture() == NULL) {
         mpMaterialTable->setTexture(new J3DTexture(0, NULL));
@@ -182,21 +182,21 @@ J3DModelData* J3DModelLoader::loadBinaryDisplayList(const void* i_data, u32 i_fl
                 modifyMaterial(i_flags);
                 break;
             case 'MAT3':
-                u32 flags = 0x50100000;
-                flags |= i_flags & 0x03000000;
+                u32 matFlags = 0x50100000;
+                matFlags |= i_flags & 0x03000000;
                 mpMaterialBlock = (J3DMaterialBlock*)block;
                 u32 matType = getBdlFlag_MaterialType(i_flags);
                 if (matType == 0) {
-                    readMaterial((J3DMaterialBlock*)block, flags);
+                    readMaterial((J3DMaterialBlock*)block, matFlags);
                 } else if (matType == 0x2000) {
-                    readPatchedMaterial((J3DMaterialBlock*)block, flags);
+                    readPatchedMaterial((J3DMaterialBlock*)block, matFlags);
                 }
                 break;
             default:
                 OSReport("Unknown data block\n");
                 break;
         }
-        block = (J3DModelBlock*)((u32)block + block->mBlockSize);
+        block = block->getNext();
     }
     J3DModelHierarchy const* hierarchy = mpModelData->getHierarchy();
     mpModelData->makeHierarchy(NULL, &hierarchy);
@@ -248,8 +248,8 @@ void J3DModelLoader::readInformation(const J3DModelInfoBlock* i_block, u32 i_fla
     mpModelData->mFlags = i_flags | i_block->mFlags;
     mpModelData->getJointTree().setFlag(mpModelData->mFlags);
     J3DMtxCalc* mtx_calc = NULL;
-    switch (mpModelData->mFlags & 0xf) {
-        case 0:
+    switch (mpModelData->mFlags & 0xF) {
+        case 0: // TODO: enum for mtxcalc type (and other load flags)
             mtx_calc = new J3DMtxCalcBasic();
             break;
         case 1:
@@ -457,7 +457,7 @@ void J3DModelLoader_v21::readMaterial_v21(const J3DMaterialBlock_v21* i_block, u
         }
     } else {
         for (u16 i = 0; i < mpMaterialTable->mMaterialNum; i++) {
-            mpMaterialTable->mMaterialNodePointer[i]->mDiffFlag = 0xc0000000;
+            mpMaterialTable->mMaterialNodePointer[i]->mDiffFlag = 0xC0000000;
         }
     }
 }
@@ -593,7 +593,7 @@ void J3DModelLoader::readMaterialDL(const J3DMaterialDLBlock* i_block, u32 i_fla
             );
         }
         for (u16 i = 0; i < mpMaterialTable->mMaterialNum; i++) {
-            mpMaterialTable->mMaterialNodePointer[i]->mDiffFlag = 0xc0000000;
+            mpMaterialTable->mMaterialNodePointer[i]->mDiffFlag = 0xC0000000;
         }
     } else {
         for (u16 i = 0; i < mpMaterialTable->mMaterialNum; i++) {
diff --git a/src/JSystem/J3DGraphLoader/J3DModelLoaderCalcSize.cpp b/src/JSystem/J3DGraphLoader/J3DModelLoaderCalcSize.cpp
index fd1eb94f2..f8512645f 100644
--- a/src/JSystem/J3DGraphLoader/J3DModelLoaderCalcSize.cpp
+++ b/src/JSystem/J3DGraphLoader/J3DModelLoaderCalcSize.cpp
@@ -4,69 +4,293 @@
 //
 
 #include "JSystem/J3DGraphLoader/J3DModelLoaderCalcSize.h"
-#include "dolphin/types.h"
+#include "JSystem/J3DGraphLoader/J3DMaterialFactory.h"
+#include "JSystem/J3DGraphLoader/J3DMaterialFactory_v21.h"
+#include "JSystem/J3DGraphLoader/J3DShapeFactory.h"
+#include "JSystem/J3DGraphLoader/J3DJointFactory.h"
+#include "JSystem/JSupport/JSupport.h"
+#include "dolphin/os/OS.h"
 
 /* 802FD828-802FD868       .text countMaterialNum__14J3DModelLoaderFPCv */
-void J3DModelLoader::countMaterialNum(const void*) {
-    /* Nonmatching */
+u16 J3DModelLoader::countMaterialNum(const void* i_data) {
+    const J3DModelFileData* header = (const J3DModelFileData*)i_data;
+    const J3DModelBlock* block = &header->mBlocks[0];
+    for (int i = 0; i < header->mBlockNum; block = block->getNext(), i++) {
+        if (block->mBlockType == 'MAT3') {
+            return ((const J3DMaterialBlock*)block)->mMaterialNum;
+        }
+    }
+    return 0;
 }
 
 /* 802FD868-802FDA10       .text calcLoadSize__14J3DModelLoaderFPCvUl */
-void J3DModelLoader::calcLoadSize(const void*, u32) {
-    /* Nonmatching */
+u32 J3DModelLoader::calcLoadSize(const void* i_data, u32 i_flags) {
+    u32 flags;
+    u32 size = 0;
+    const J3DModelFileData* header = (const J3DModelFileData*)i_data;
+    const J3DModelBlock* block = &header->mBlocks[0];
+    u32 i = 0;
+    flags = (u32)i_flags;
+    size += sizeof(J3DModelData);
+    for (; i < header->mBlockNum; i++) {
+        switch (block->mBlockType) {
+        case 'INF1':
+            size += calcSizeInformation((J3DModelInfoBlock*)block, flags);
+            break;
+        case 'JNT1':
+            size += calcSizeJoint((J3DJointBlock*)block);
+            break;
+        case 'MAT2':
+            break;
+        case 'MAT3':
+            size += calcSizeMaterial((J3DMaterialBlock*)block, flags);
+            break;
+        case 'SHP1':
+            size += calcSizeShape((J3DShapeBlock*)block, flags);
+            break;
+        case 'TEX1':
+            size += calcSizeTexture((J3DTextureBlock*)block);
+            break;
+        case 'EVP1':
+            break;
+        case 'DRW1':
+            break;
+        case 'VTX1':
+            break;
+        default:
+            OSReport("Unknown data block\n");
+            break;
+        }
+        block = block->getNext();
+    }
+    return size;
 }
 
 /* 802FDA10-802FDB0C       .text calcLoadMaterialTableSize__14J3DModelLoaderFPCv */
-void J3DModelLoader::calcLoadMaterialTableSize(const void*) {
-    /* Nonmatching */
+u32 J3DModelLoader::calcLoadMaterialTableSize(const void* i_data) {
+    u32 size = 0;
+    const J3DModelFileData* header = (const J3DModelFileData*)i_data;
+    const J3DModelBlock* block = &header->mBlocks[0];
+    bool hasTextureTable = false;
+    u32 i = 0;
+    size += sizeof(J3DMaterialTable);
+    for (; i < header->mBlockNum; i++) {
+        switch (block->mBlockType) {
+        case 'MAT2':
+            break;
+        case 'MAT3':
+            size += calcSizeMaterialTable((const J3DMaterialBlock*)block, 0x51100000);
+            break;
+        case 'TEX1':
+            size += calcSizeTextureTable((const J3DTextureBlock*)block);
+            hasTextureTable = true;
+            break;
+        default:
+            OSReport("Unknown data block\n");
+            break;
+        }
+        block = block->getNext();
+    }
+
+    if (!hasTextureTable) {
+        size += 0xC;
+    }
+    return size;
 }
 
 /* 802FDB0C-802FDD28       .text calcLoadBinaryDisplayListSize__14J3DModelLoaderFPCvUl */
-void J3DModelLoader::calcLoadBinaryDisplayListSize(const void*, u32) {
-    /* Nonmatching */
+u32 J3DModelLoader::calcLoadBinaryDisplayListSize(const void* i_data, u32 i_flags) {
+    /* Nonmatching - regalloc */
+    u32 size = 0;
+    u32 i;
+    const J3DModelFileData* header = (const J3DModelFileData*)i_data;
+    const J3DModelBlock* block = &header->mBlocks[0];
+    i = 0;
+    size += sizeof(J3DModelData);
+    for (; i < header->mBlockNum; i++) {
+        switch (block->mBlockType) {
+        case 'INF1':
+            size += calcSizeInformation((const J3DModelInfoBlock*)block, i_flags);
+            break;
+        case 'JNT1':
+            size += calcSizeJoint((const J3DJointBlock*)block);
+            break;
+        case 'SHP1':
+            size += calcSizeShape((const J3DShapeBlock*)block, i_flags);
+            break;
+        case 'TEX1':
+            size += calcSizeTexture((const J3DTextureBlock*)block);
+            break;
+        case 'MDL3':
+            size += calcSizeMaterialDL((const J3DMaterialDLBlock*)block, i_flags);
+            break;
+        case 'MAT2':
+            break;
+        case 'MAT3':
+            u32 matFlags = 0x50100000;
+            matFlags |= i_flags & 0x03000000;
+            mpMaterialBlock = (J3DMaterialBlock*)block;
+            u32 matType = getBdlFlag_MaterialType(i_flags);
+            if (matType == 0) {
+                field_0x18 = 1;
+                size += calcSizeMaterial((const J3DMaterialBlock*)block, matFlags);
+            } else if (matType == 0x2000) {
+                field_0x18 = 1;
+                size += calcSizePatchedMaterial((const J3DMaterialBlock*)block, matFlags);
+            }
+            break;
+        case 'EVP1':
+            break;
+        case 'DRW1':
+            break;
+        case 'VTX1':
+            break;
+        default:
+            OSReport("Unknown data block\n");
+            break;
+        }
+        block = block->getNext();
+    }
+    return size;
 }
 
 /* 802FDD28-802FDDB4       .text calcSizeInformation__14J3DModelLoaderFPC17J3DModelInfoBlockUl */
-void J3DModelLoader::calcSizeInformation(const J3DModelInfoBlock*, u32) {
-    /* Nonmatching */
+u32 J3DModelLoader::calcSizeInformation(const J3DModelInfoBlock* i_block, u32 i_flags) {
+    u32 size = 0;
+    switch ((i_flags | i_block->mFlags) & 0xF) {
+    case 0: // TODO: enum for mtxcalc type (and other load flags)
+        size = sizeof(J3DMtxCalcBasic);
+        break;
+    case 1:
+        size = sizeof(J3DMtxCalcSoftimage);
+        break;
+    case 2:
+        size = sizeof(J3DMtxCalcMaya);
+        break;
+    default:
+        break;
+    }
+    mpModelHierarchy = JSUConvertOffsetToPtr<J3DModelHierarchy>(i_block, i_block->mpHierarchy);
+    return size;
 }
 
 /* 802FDDB4-802FDDE0       .text calcSizeJoint__14J3DModelLoaderFPC13J3DJointBlock */
-void J3DModelLoader::calcSizeJoint(const J3DJointBlock*) {
-    /* Nonmatching */
+u32 J3DModelLoader::calcSizeJoint(const J3DJointBlock* i_block) {
+    u32 size = 0;
+    if (i_block->mpNameTable) {
+        size = 0x10;
+    }
+    size += i_block->mJointNum * sizeof(J3DJoint*);
+    size += i_block->mJointNum * sizeof(J3DJoint);
+    return size;
 }
 
 /* 802FDDE0-802FDECC       .text calcSizeMaterial__18J3DModelLoader_v26FPC16J3DMaterialBlockUl */
-s32 J3DModelLoader_v26::calcSizeMaterial(const J3DMaterialBlock*, u32) {
-    /* Nonmatching */
+u32 J3DModelLoader_v26::calcSizeMaterial(const J3DMaterialBlock* i_block, u32 i_flags) {
+    u32 size = 0;
+    J3DMaterialFactory factory(*i_block);
+    u32 count = i_block->mMaterialNum;
+    u32 uniqueCount = factory.countUniqueMaterials();
+    if (i_block->mpNameTable) {
+        size = 0x10;
+    }
+    size += count * sizeof(J3DMaterial*);
+    if (i_flags & 0x00200000) {
+        size += ALIGN_NEXT(uniqueCount * sizeof(J3DMaterial), 0x20);
+    }
+    if (i_flags & 0x00200000) {
+        for (u32 i = 0; i < uniqueCount; i++) {
+            size += factory.calcSize(NULL, J3DMaterialFactory::MATERIAL_TYPE_NORMAL, i, i_flags);
+        }
+    }
+    for (u32 i = 0; i < count; i++) {
+        size += factory.calcSize(NULL, J3DMaterialFactory::MATERIAL_TYPE_NORMAL, i, i_flags);
+    }
+    return size;
 }
 
 /* 802FDECC-802FDF70       .text calcSizeShape__14J3DModelLoaderFPC13J3DShapeBlockUl */
-void J3DModelLoader::calcSizeShape(const J3DShapeBlock*, u32) {
-    /* Nonmatching */
+u32 J3DModelLoader::calcSizeShape(const J3DShapeBlock* i_block, u32 i_flags) {
+    u32 size = 0;
+    J3DShapeFactory factory(*i_block);
+    int count = i_block->mShapeNum;
+    if (i_block->mpNameTable) {
+        size = 0x10;
+    }
+    size += count * sizeof(J3DShape*);
+    size += factory.calcSizeVcdVatCmdBuffer(count);
+    for (J3DModelHierarchy* hierarchy = mpModelHierarchy; hierarchy->mType != 0; hierarchy = hierarchy + 1) {
+        if (hierarchy->mType == 0x12) {
+            size += factory.calcSize(hierarchy->mValue, i_flags);
+        }
+    }
+    return size;
 }
 
 /* 802FDF70-802FDF8C       .text calcSizeTexture__14J3DModelLoaderFPC15J3DTextureBlock */
-void J3DModelLoader::calcSizeTexture(const J3DTextureBlock*) {
-    /* Nonmatching */
+u32 J3DModelLoader::calcSizeTexture(const J3DTextureBlock* i_block) {
+    u32 size = 0;
+    if (i_block->mpNameTable) {
+        size = 0x10;
+    }
+    return size + 0xC;
 }
 
 /* 802FDF8C-802FE01C       .text calcSizeMaterialTable__18J3DModelLoader_v26FPC16J3DMaterialBlockUl */
-s32 J3DModelLoader_v26::calcSizeMaterialTable(const J3DMaterialBlock*, u32) {
-    /* Nonmatching */
+u32 J3DModelLoader_v26::calcSizeMaterialTable(const J3DMaterialBlock* i_block, u32 i_flags) {
+    u32 size = 0;
+    u32 count = i_block->mMaterialNum;
+    J3DMaterialFactory factory(*i_block);
+    if (i_block->mpNameTable) {
+        size = 0x10;
+    }
+    size += count * sizeof(J3DMaterial*);
+    for (u32 i = 0; (u16)i < count; i++) {
+        size += factory.calcSize(NULL, J3DMaterialFactory::MATERIAL_TYPE_NORMAL, (u16)i, i_flags);
+    }
+    return size;
 }
 
 /* 802FE01C-802FE03C       .text calcSizeTextureTable__14J3DModelLoaderFPC15J3DTextureBlock */
-void J3DModelLoader::calcSizeTextureTable(const J3DTextureBlock*) {
-    /* Nonmatching */
+u32 J3DModelLoader::calcSizeTextureTable(const J3DTextureBlock* i_block) {
+    return calcSizeTexture(i_block);
 }
 
 /* 802FE03C-802FE0CC       .text calcSizePatchedMaterial__14J3DModelLoaderFPC16J3DMaterialBlockUl */
-void J3DModelLoader::calcSizePatchedMaterial(const J3DMaterialBlock*, u32) {
-    /* Nonmatching */
+u32 J3DModelLoader::calcSizePatchedMaterial(const J3DMaterialBlock* i_block, u32 i_flags) {
+    u32 size = 0;
+    u32 count = i_block->mMaterialNum;
+    J3DMaterialFactory factory(*i_block);
+    if (i_block->mpNameTable) {
+        size = 0x10;
+    }
+    size += count * sizeof(J3DMaterial*);
+    for (u32 i = 0; (u16)i < count; i++) {
+        size += factory.calcSize(NULL, J3DMaterialFactory::MATERIAL_TYPE_PATCHED, (u16)i, i_flags);
+    }
+    return size;
 }
 
 /* 802FE0CC-802FE1A4       .text calcSizeMaterialDL__14J3DModelLoaderFPC18J3DMaterialDLBlockUl */
-void J3DModelLoader::calcSizeMaterialDL(const J3DMaterialDLBlock*, u32) {
-    /* Nonmatching */
+u32 J3DModelLoader::calcSizeMaterialDL(const J3DMaterialDLBlock* i_block, u32 i_flags) {
+    /* Nonmatching - regalloc */
+    u32 size = 0;
+    J3DMaterialFactory factory(*i_block);
+    u32 count;
+    if (!field_0x18) {
+        count = i_block->mMaterialNum;
+        if (i_block->mpNameTable) {
+            size = 0x10;
+        }
+        size += count * sizeof(J3DLockedMaterial*);
+        for (u32 i = 0; (u16)i < count; i++) {
+            size += factory.calcSize(NULL, J3DMaterialFactory::MATERIAL_TYPE_LOCKED, (u16)i, i_flags);
+        }
+    } else {
+        count = i_block->mMaterialNum;
+        for (u32 i = 0; (u16)i < count; i++) {
+            size += factory.calcSize((J3DMaterial*)this, J3DMaterialFactory::MATERIAL_TYPE_LOCKED, (u16)i, i_flags);
+        }
+    }
+    return size;
 }