hsfload fixes

include/game/hsfdraw.h

@@ -70,7 +70,7 @@ void Hu3DModelObjMtxGet(s16 arg0, char *arg1, Mtx arg2);
 void PGObjCall(ModelData *arg0, HsfObject *arg1);
 void PGObjCalc(ModelData *arg0, HsfObject *arg1);
 void PGObjReplica(ModelData *arg0, HsfObject *arg1);
-HsfObject *Hu3DObjDuplicate(HsfData *arg0, u32 arg1);
+HsfObject *Hu3DObjDuplicate(HsfData *arg0, uintptr_t arg1);
 void Hu3DModelObjDrawInit(void);
 void Hu3DModelObjDraw(s16 arg0, char *arg1, Mtx arg2);
 

include/game/hsfformat.h

@@ -277,7 +277,8 @@ typedef struct hsf_object_data {
     HsfCluster **cluster;
     u32 cenvCnt;
     HsfCenv *cenv;
-    void *file[2];
+    HsfVector3f *vtxtop;
+    HsfVector3f *normtop;
 } HsfObjectData;
 
 typedef struct hsf_camera {

include/port/byteswap.h

@@ -156,6 +156,22 @@ typedef struct HsfShape32b {
     u32 vertex;
 } HsfShape32b;
 
+typedef struct HsfCenvDual32b {
+    u32 target1;
+    u32 target2;
+    u32 weightCnt;
+    u32 weight;
+} HsfCenvDual32b;
+
+typedef struct HsfCenvMulti32b {
+    u32 weightCnt;
+    u16 pos;
+    u16 posCnt;
+    u16 normal;
+    u16 normalCnt;
+    u32 weight;
+} HsfCenvMulti32b;
+
 typedef struct HsfCenv32b {
     u32 name;
     u32 singleData;
@@ -200,7 +216,8 @@ typedef struct HsfObjectData32b {
     u32 cluster;
     u32 cenvCnt;
     u32 cenv;
-    u32 file[2];
+    u32 vtxtop;
+    u32 normtop;
 } HsfObjectData32b;
 
 typedef struct HsfObject32b {
@@ -265,6 +282,12 @@ typedef struct HsfFace32b {
     Vec nbt;
 } HsfFace32b;
 
+typedef struct HsfMatrix32b {
+    u32 base_idx;
+    u32 count;
+    u32 data;
+} HsfMatrix32b;
+
 void byteswap_u16(u16 *src);
 void byteswap_s16(s16 *src);
 void byteswap_u32(u32 *src);
@@ -285,7 +308,7 @@ void byteswap_hsfattribute(HsfAttribute32b *src, HsfAttribute *dest);
 void byteswap_hsfmaterial(HsfMaterial32b *src, HsfMaterial *dest);
 void byteswap_hsfscene(HsfScene *src);
 void byteswap_hsfbuffer(HsfBuffer32b *src, HsfBuffer *dest);
-void byteswap_hsfmatrix(HsfMatrix *src);
+void byteswap_hsfmatrix(HsfMatrix32b *src, HsfMatrix *dest);
 void byteswap_hsfpalette(HsfPalette32b *src, HsfPalette *dest);
 void byteswap_hsfpart(HsfPart32b *src, HsfPart *dest);
 void byteswap_hsfbitmap(HsfBitmap32b *src, HsfBitmap *dest);
@@ -304,7 +327,6 @@ void byteswap_hsfattribute(HsfAttribute32b *src, HsfAttribute *dest);
 void byteswap_hsfmaterial(HsfMaterial32b *src, HsfMaterial *dest);
 void byteswap_hsfscene(HsfScene *src);
 void byteswap_hsfbuffer(HsfBuffer32b *src, HsfBuffer *dest);
-void byteswap_hsfmatrix(HsfMatrix *src);
 void byteswap_hsfpalette(HsfPalette32b *src, HsfPalette *dest);
 void byteswap_hsfpart(HsfPart32b *src, HsfPart *dest);
 void byteswap_hsfbitmap(HsfBitmap32b *src, HsfBitmap *dest);
@@ -312,6 +334,10 @@ void byteswap_hsfmapattr(HsfMapAttr32b *src, HsfMapAttr *dest);
 void byteswap_hsfskeleton(HsfSkeleton32b *src, HsfSkeleton *dest);
 void byteswap_hsfshape(HsfShape32b *src, HsfShape *dest);
 void byteswap_hsfcenv_single(HsfCenvSingle *src);
+void byteswap_hsfcenv_dual_weight(HsfCenvDualWeight *src);
+void byteswap_hsfcenv_dual(HsfCenvDual32b *src, HsfCenvDual *dest);
+void byteswap_hsfcenv_multi_weight(HsfCenvMultiWeight *src);
+void byteswap_hsfcenv_multi(HsfCenvMulti32b *src, HsfCenvMulti *dest);
 void byteswap_hsfcenv(HsfCenv32b *src, HsfCenv *dest);
 void byteswap_hsfobject(HsfObject32b *src, HsfObject *dest);
 void byteswap_hsfbitmapkey(HsfBitmapKey32b *src, HsfBitmapKey *dest);

src/dolphin/mtx/mtx.c

@@ -1322,8 +1322,8 @@ void C_MTXLightOrtho(Mtx m, f32 t, f32 b, f32 l, f32 r, f32 scaleS, f32 scaleT,
 void C_MTXReorder(const Mtx src, ROMtx dest)
 {
     u32 i, j;
-    for (i = 0; i < 3; j++) {
+    for (i = 0; i < 3; i++) {
-        for (int j = 0; j < 4; j++) {
+        for (j = 0; j < 4; j++) {
             dest[j][i] = src[i][j];
         }
     }

src/game/ClusterExec.c

@@ -127,9 +127,9 @@ void ClusterProc(ModelData *arg0)
                     Vertextop = temp_r31->data.vertex->data;
                     if (temp_r31->data.cenvCnt) {
                         for (k = 0; k < temp_r31->data.vertex->count; k++) {
-                            Vertextop[k].x = ((Vec *)temp_r31->data.file[0])[k].x;
+                            Vertextop[k].x = ((Vec *)temp_r31->data.vtxtop)[k].x;
-                            Vertextop[k].y = ((Vec *)temp_r31->data.file[0])[k].y;
+                            Vertextop[k].y = ((Vec *)temp_r31->data.vtxtop)[k].y;
-                            Vertextop[k].z = ((Vec *)temp_r31->data.file[0])[k].z;
+                            Vertextop[k].z = ((Vec *)temp_r31->data.vtxtop)[k].z;
                         }
                     }
                     SetClusterMain(var_r29);

src/game/EnvelopeExec.c

@@ -36,7 +36,7 @@ void InitEnvelope(HsfData *arg0) {
         var_r31 = arg0->object;
         for (Meshcnt = i = 0; i < arg0->objectCnt; i++, var_r31++) {
             if (var_r31->type == 2) {
-                if (var_r31->data.file[0]) {
+                if (var_r31->data.vtxtop) {
                     spC = var_r31->data.vertex;
                     sp8 = var_r31->data.normal;
                     Meshcnt++;
@@ -173,17 +173,17 @@ static void SetEnvelopMain(HsfData *arg0) {
             if (var_r31->data.unk120[0] != 0) {
                 Vertextop = temp_r30->data;
             } else {
-                Vertextop = var_r31->data.file[0];
+                Vertextop = (Vec*)var_r31->data.vtxtop;
             }
             vtxenv = temp_r30->data;
-            normtop = var_r31->data.file[1];
+            normtop = (Vec*)var_r31->data.normtop;
             normenv = temp_r28->data;
             var_r25 = var_r31->data.cenv;
             for (j = 0; j < var_r31->data.cenvCnt; j++, var_r25++) {
                 SetEnvelop(var_r25);
             }
             sp10 = temp_r30->data;
-            spC = var_r31->data.file[0];
+            spC = var_r31->data.vtxtop;
             sp8 = temp_r30->data;
             DCStoreRangeNoSync(normenv, temp_r28->count * sizeof(Vec));
             DCStoreRangeNoSync(vtxenv, temp_r30->count * sizeof(Vec));

src/game/armem.c

@@ -344,7 +344,7 @@ void *HuAR_ARAMtoMRAMFileRead(u32 dir, u32 num, HeapID heap) {
     DCInvalidateRange(&preLoadBuf, sizeof(preLoadBuf));
     amem_src = amemptr + (u32)((u32)(((u16)dir + 1) * 4) & 0xFFFFFFFE0);
     arqCnt++;
-    ARQPostRequest(&ARQueBuf[arqIdx].req, 0x1234, 1, 0, amem_src, (u32) &preLoadBuf, sizeof(preLoadBuf), ArqCallBackAMFileRead);
+    ARQPostRequest(&ARQueBuf[arqIdx].req, 0x1234, 1, 0, amem_src, (uintptr_t) &preLoadBuf, sizeof(preLoadBuf), ArqCallBackAMFileRead);
     arqIdx++;
     arqIdx &= 0xF;
     while (HuARDMACheck());

src/game/data.c

@@ -286,10 +286,11 @@ BOOL HuDataGetAsyncStat(s32 status)
 
 static void GetFileInfo(DataReadStat *read_stat, s32 file_num)
 {
-    u32 *temp_ptr;
+    u32 *temp_ptr = (u32 *)PTR_OFFSET(read_stat->dir, (file_num * 4))+1;
-    temp_ptr = (u32 *)PTR_OFFSET(read_stat->dir, (file_num * 4))+1;
 #ifdef TARGET_PC
-    byteswap_u32(temp_ptr);
+    u32 ofs = *temp_ptr;
+    byteswap_u32(&ofs);
+    temp_ptr = &ofs;
 #endif
     read_stat->file = PTR_OFFSET(read_stat->dir, *temp_ptr);
     temp_ptr = read_stat->file;
@@ -336,7 +337,7 @@ void *HuDataReadNum(s32 data_num, s32 num)
     }
     read_stat = &ReadDataStat[status];
     GetFileInfo(read_stat, data_num & 0xFFFF);
-    buf = HuMemDirectMallocNum(0, DATA_EFF_SIZE(read_stat->raw_len), num);
+    buf = HuMemDirectMallocNum(HEAP_SYSTEM, DATA_EFF_SIZE(read_stat->raw_len), num);
     if(buf) {
         HuDecodeData(read_stat->file, buf, read_stat->raw_len, read_stat->comp_type);
     }

src/game/hsfdraw.c

@@ -3347,14 +3347,13 @@ void PGObjReplica(ModelData *arg0, HsfObject *arg1)
     }
 }
 
-HsfObject *Hu3DObjDuplicate(HsfData *arg0, u32 arg1)
+HsfObject *Hu3DObjDuplicate(HsfData *arg0, uintptr_t arg1)
 {
     HsfObject *temp_r27;
     HsfObject *var_r30;
     HsfObject *var_r31;
     s16 i;
     s16 j;
-
     var_r31 = HuMemDirectMallocNum(HEAP_DATA, arg0->objectCnt * sizeof(HsfObject), arg1);
     temp_r27 = var_r31;
     var_r30 = arg0->object;
@@ -3362,7 +3361,7 @@ HsfObject *Hu3DObjDuplicate(HsfData *arg0, u32 arg1)
     for (i = 0; i < arg0->objectCnt; i++, var_r31++, var_r30++) {
         if (var_r31->type != 8 && var_r31->type != 7) {
             if (var_r31->data.parent) {
-                var_r31->data.parent = (HsfObject *)((u8 *)temp_r27 + ((u32)var_r30->data.parent - (u32)arg0->object));
+                var_r31->data.parent = (HsfObject *)((u8 *)temp_r27 + ((uintptr_t)var_r30->data.parent - (uintptr_t)arg0->object));
             }
             var_r31->data.children = HuMemDirectMallocNum(HEAP_DATA, var_r30->data.childrenCount * 4, arg1);
             if (var_r30->constData) {
@@ -3370,7 +3369,7 @@ HsfObject *Hu3DObjDuplicate(HsfData *arg0, u32 arg1)
                 memcpy(var_r31->constData, var_r30->constData, sizeof(HsfConstData));
             }
             for (j = 0; j < var_r30->data.childrenCount; j++) {
-                var_r31->data.children[j] = (HsfObject *)((u8 *)temp_r27 + ((u32)var_r30->data.children[j] - (u32)arg0->object));
+                var_r31->data.children[j] = (HsfObject *)((u8 *)temp_r27 + ((uintptr_t)var_r30->data.children[j] - (uintptr_t)arg0->object));
             }
         }
     }

src/game/hsfload.c

@@ -1,6 +1,8 @@
 #include "game/hsfload.h"
-#include "string.h"
+#include "game/EnvelopeExec.h"
 #include "ctype.h"
+#include "string.h"
+
 
 #ifdef TARGET_PC
 #include "game/memory.h"
@@ -89,7 +91,9 @@ HsfData *LoadHSF(void *data)
     NormalLoad();
     STLoad();
     FaceLoad();
+#if __MWERKS__
     ObjectLoad();
+#endif
     CenvLoad();
     SkeletonLoad();
     PartLoad();
@@ -98,6 +102,10 @@ HsfData *LoadHSF(void *data)
     MapAttrLoad();
     MotionLoad();
     MatrixLoad();
+#if TARGET_PC
+    // to properly set pointers
+    ObjectLoad();
+#endif
     hsf = SetHsfModel();
     InitEnvelope(hsf);
     objtop = NULL;
@@ -448,7 +456,7 @@ static void NormalLoad(void)
         Model.normal = new_normal;
         Model.normalCnt = head.normal.count;
 #ifdef TARGET_PC
-        VertexDataTop = data = (void *)&file_normal_real[head.normal.count];
+        NormalDataTop = data = (void *)&file_normal_real[head.normal.count];
 #else
         file_normal = (HsfBuffer *)((u32)fileptr+head.normal.ofs);
         NormalDataTop = data = (void *)&file_normal[head.normal.count];
@@ -460,8 +468,8 @@ static void NormalLoad(void)
             new_normal->data = (void *)((uintptr_t)data+(uintptr_t)temp_data);
 #ifdef TARGET_PC
             if (cenv_count != 0) {
-                for (i = 0; i < new_normal->count; i++) {
+                for (j = 0; j < new_normal->count; j++) {
-                    HsfVector3f *normalData = &((HsfVector3f *)new_normal->data)[i];
+                    HsfVector3f *normalData = &((HsfVector3f *)new_normal->data)[j];
                     byteswap_hsfvec3f(normalData);
                 }
             }
@@ -647,8 +655,16 @@ static void DispObject(HsfObject *parent, HsfObject *object)
             } else {
                 new_object->data.attribute = NULL;
             }
-            new_object->data.file[0] = (void *)((uintptr_t)fileptr + (uintptr_t)data->file[0]);
+            new_object->data.vtxtop = (void *)((uintptr_t)fileptr + (uintptr_t)data->vtxtop);
-            new_object->data.file[1] = (void *)((uintptr_t)fileptr + (uintptr_t)data->file[1]);
+            new_object->data.normtop = (void *)((uintptr_t)fileptr + (uintptr_t)data->normtop);
+#ifdef TARGET_PC
+            for (i = 0; i < new_object->data.vertex->count; i++) {
+                byteswap_hsfvec3f(&new_object->data.vtxtop[i]);
+            }
+            for (i = 0; i < new_object->data.normal->count; i++) {
+                byteswap_hsfvec3f(&new_object->data.normtop[i]);
+            }
+#endif
             new_object->data.base.pos.x = data->base.pos.x;
             new_object->data.base.pos.y = data->base.pos.y;
             new_object->data.base.pos.z = data->base.pos.z;
@@ -906,46 +922,70 @@ static void CenvLoad(void)
         Model.cenv = cenv_file;
         for(i=0; i<head.cenv.count; i++) {
             cenv_new[i].singleData = (HsfCenvSingle *)((uintptr_t)cenv_file[i].singleData + (uintptr_t)data_base);
+#ifdef __MWERKS__
             cenv_new[i].dualData = (HsfCenvDual *)((uintptr_t)cenv_file[i].dualData + (uintptr_t)data_base);
             cenv_new[i].multiData = (HsfCenvMulti *)((uintptr_t)cenv_file[i].multiData + (uintptr_t)data_base);
+#endif
             cenv_new[i].singleCount = cenv_file[i].singleCount;
             cenv_new[i].dualCount = cenv_file[i].dualCount;
             cenv_new[i].multiCount = cenv_file[i].multiCount;
             cenv_new[i].copyCount = cenv_file[i].copyCount;
             cenv_new[i].vtxCount = cenv_file[i].vtxCount;
+#if TARGET_PC
+            weight_base = (void *)((uintptr_t)weight_base + (cenv_new[i].singleCount * sizeof(HsfCenvSingle)));
+            weight_base = (void *)((uintptr_t)weight_base + (cenv_new[i].dualCount * sizeof(HsfCenvDual32b)));
+            weight_base = (void *)((uintptr_t)weight_base + (cenv_new[i].multiCount * sizeof(HsfCenvMulti32b)));
+#else
             weight_base = (void *)((uintptr_t)weight_base + (cenv_new[i].singleCount * sizeof(HsfCenvSingle)));
             weight_base = (void *)((uintptr_t)weight_base + (cenv_new[i].dualCount * sizeof(HsfCenvDual)));
             weight_base = (void *)((uintptr_t)weight_base + (cenv_new[i].multiCount * sizeof(HsfCenvMulti)));
-#ifdef TARGET_PC
-            byteswap_hsfcenv_single(cenv_new[i].singleData);
-            // TODO PC malloc dual, multi etc and byteswap them
 #endif
         }
         for(i=0; i<head.cenv.count; i++) {
+#ifdef TARGET_PC
+            HsfCenvDual32b *dual_data_real = (HsfCenvDual32b *)((uintptr_t)cenv_file[i].dualData + (uintptr_t)data_base);
+            HsfCenvMulti32b *multi_data_real = (HsfCenvMulti32b *)((uintptr_t)cenv_file[i].multiData + (uintptr_t)data_base);
+            cenv_new[i].dualData = HuMemDirectMallocNum(HEAP_DATA, cenv_file[i].dualCount * sizeof(HsfCenvDual), MEMORY_DEFAULT_NUM);
+            cenv_new[i].multiData = HuMemDirectMallocNum(HEAP_DATA, cenv_file[i].multiCount * sizeof(HsfCenvMulti), MEMORY_DEFAULT_NUM);
+#endif
             single_new = single_file = cenv_new[i].singleData;
             for(j=0; j<cenv_new[i].singleCount; j++) {
+#ifdef TARGET_PC
+                byteswap_hsfcenv_single(&single_new[j]);
+#endif
                 single_new[j].target = single_file[j].target;
                 single_new[j].posCnt = single_file[j].posCnt;
                 single_new[j].pos = single_file[j].pos;
                 single_new[j].normalCnt = single_file[j].normalCnt;
                 single_new[j].normal = single_file[j].normal;
-                
             }
             dual_new = dual_file = cenv_new[i].dualData;
             for(j=0; j<cenv_new[i].dualCount; j++) {
+#ifdef TARGET_PC
+                byteswap_hsfcenv_dual(&dual_data_real[j], &dual_new[j]);
+#endif
                 dual_new[j].target1 = dual_file[j].target1;
                 dual_new[j].target2 = dual_file[j].target2;
                 dual_new[j].weightCnt = dual_file[j].weightCnt;
                 dual_new[j].weight = (HsfCenvDualWeight *)((uintptr_t)weight_base + (uintptr_t)dual_file[j].weight);
+#ifdef TARGET_PC
+                byteswap_hsfcenv_dual_weight(dual_new[j].weight);
+#endif
             }
             multi_new = multi_file = cenv_new[i].multiData;
             for(j=0; j<cenv_new[i].multiCount; j++) {
+#ifdef TARGET_PC
+                byteswap_hsfcenv_multi(&multi_data_real[j], &multi_new[j]);
+#endif
                 multi_new[j].weightCnt = multi_file[j].weightCnt;
                 multi_new[j].pos = multi_file[j].pos;
                 multi_new[j].posCnt = multi_file[j].posCnt;
                 multi_new[j].normal = multi_file[j].normal;
                 multi_new[j].normalCnt = multi_file[j].normalCnt;
                 multi_new[j].weight = (HsfCenvMultiWeight *)((uintptr_t)weight_base + (uintptr_t)multi_file[j].weight);
+#ifdef TARGET_PC
+                byteswap_hsfcenv_multi_weight(dual_new[j].weight);
+#endif
             }
             dual_new = dual_file = cenv_new[i].dualData;
             for(j=0; j<cenv_new[i].dualCount; j++) {
@@ -1686,7 +1726,7 @@ static void MatrixLoad(void)
     if(head.matrix.count) {
 #ifdef TARGET_PC
         matrix_file = HuMemDirectMallocNum(HEAP_DATA, sizeof(HsfMatrix) * head.matrix.count, MEMORY_DEFAULT_NUM);
-        byteswap_hsfmatrix((HsfMatrix *)((uintptr_t)fileptr + head.matrix.ofs));
+        byteswap_hsfmatrix((HsfMatrix32b *)((uintptr_t)fileptr + head.matrix.ofs), matrix_file);
 #else
         matrix_file = (HsfMatrix *)((uintptr_t)fileptr+head.matrix.ofs);
         matrix_file->data = (Mtx *)((u32)fileptr+head.matrix.ofs+sizeof(HsfMatrix));
@@ -1883,12 +1923,16 @@ void KillHSF(HsfData *data)
     HuMemDirectFree(data->palette);
     HuMemDirectFree(data->st);
     HuMemDirectFree(data->vertex);
+    for (i = 0; i < data->cenvCnt; i++) {
+        HsfCenv *cenv = &data->cenv[i];
+        HuMemDirectFree(cenv->dualData);
+        HuMemDirectFree(cenv->multiData);
+    }
     HuMemDirectFree(data->cenv);
     HuMemDirectFree(data->cluster);
     HuMemDirectFree(data->part);
     HuMemDirectFree(data->shape);
     HuMemDirectFree(data->mapAttr);
     HuMemDirectFree(data->symbol);
-    // TODO PC free embedded data
 }
 #endif

src/game/hsfman.c

@@ -416,12 +416,6 @@ s16 Hu3DModelLink(s16 arg0) {
     ModelData* var_r31;
     s16 var_r28;
     s16 i;
-    s32 temp_r0;
-    s32 temp_r3;
-    s32 temp_r5;
-    s32 var_ctr;
-    HsfData* var_r4;
-    HsfData* var_r5;
 
     temp_r30 = &Hu3DData[arg0];
     var_r31 = Hu3DData;
@@ -434,11 +428,11 @@ s16 Hu3DModelLink(s16 arg0) {
         return -1;
     }
     var_r31->unk_C8 = temp_r30->hsfData;
-    var_r31->hsfData = HuMemDirectMallocNum(HEAP_DATA, 0x80, var_r31->unk_4C);
+    var_r31->hsfData = HuMemDirectMallocNum(HEAP_DATA, sizeof(HsfData), var_r31->unk_4C);
-    var_r31->unk_4C = (u32)var_r31->hsfData;
+    var_r31->unk_4C = (uintptr_t)var_r31->hsfData;
     *var_r31->hsfData = *temp_r30->hsfData;
     temp_r3_2 = Hu3DObjDuplicate(var_r31->hsfData, var_r31->unk_4C);
-    var_r31->hsfData->root = (HsfObject*)((u32)temp_r3_2 + ((u32)var_r31->hsfData->root - (u32)var_r31->hsfData->object));
+    var_r31->hsfData->root = (HsfObject*)((uintptr_t)temp_r3_2 + ((uintptr_t)var_r31->hsfData->root - (uintptr_t)var_r31->hsfData->object));
     var_r31->hsfData->object = temp_r3_2;
     var_r31->unk_48 = temp_r30->unk_48;
     var_r31->attr = temp_r30->attr;

src/port/byteswap.cpp

@@ -421,15 +421,18 @@ template <typename B> void bswap(B &base, HsfBuffer32b &obj, HsfBuffer &dest)
     dest.data = reinterpret_cast<void *>(static_cast<uintptr_t>(obj.data));
 }
 
-template <typename B> void bswap(B &base, HsfMatrix &obj)
+template <typename B> void bswap(B &base, HsfMatrix32b &obj, HsfMatrix &dest)
 {
     bswap(base, obj.base_idx);
     bswap(base, obj.count);
 
-    obj.data = reinterpret_cast<Mtx *>(reinterpret_cast<uintptr_t>(&obj) + 0xC); // hardcoded for 64 bit support
+    dest.base_idx = obj.base_idx;
+    dest.count = obj.count;
+
+    dest.data = reinterpret_cast<Mtx *>(&obj + 1);
     for (s32 i = 0; i < obj.count; i++) {
         for (s32 j = 0; j < 3; j++) {
-            bswap_flat(base, obj.data[i][j], 4);
+            bswap_flat(base, dest.data[i][j], 4);
         }
     }
 }
@@ -532,6 +535,48 @@ template <typename B> void bswap(B &base, HsfCenvSingle &obj)
     bswap(base, obj.normalCnt);
 }
 
+template <typename B> void bswap(B &base, HsfCenvDualWeight &obj)
+{
+    bswap(base, obj.weight);
+    bswap(base, obj.pos);
+    bswap(base, obj.posCnt);
+    bswap(base, obj.normal);
+    bswap(base, obj.normalCnt);
+}
+
+template <typename B> void bswap(B &base, HsfCenvDual32b &obj, HsfCenvDual &dest)
+{
+    bswap(base, obj.target1);
+    bswap(base, obj.target2);
+    bswap(base, obj.weightCnt);
+    bswap(base, obj.weight);
+
+    dest.target1 = obj.target1;
+    dest.target2 = obj.target2;
+    dest.weightCnt = obj.weightCnt;
+    dest.weight = reinterpret_cast<HsfCenvDualWeight *>(static_cast<uintptr_t>(obj.weight));
+}
+
+template <typename B> void bswap(B &base, HsfCenvMultiWeight &obj)
+{
+    bswap(base, obj.target);
+    bswap(base, obj.value);
+}
+
+template <typename B> void bswap(B &base, HsfCenvMulti32b &obj, HsfCenvMulti &dest)
+{
+    bswap(base, obj.weightCnt);
+    bswap(base, obj.pos);
+    bswap(base, obj.posCnt);
+    bswap(base, obj.normal);
+    bswap(base, obj.normalCnt);
+
+    dest.weightCnt = obj.weightCnt;
+    dest.pos = obj.pos;
+    dest.posCnt = obj.posCnt;
+    dest.weight = reinterpret_cast<HsfCenvMultiWeight *>(static_cast<uintptr_t>(obj.weight));
+}
+
 template <typename B> void bswap(B &base, HsfCenv32b &obj, HsfCenv &dest)
 {
     bswap(base, obj.name);
@@ -575,7 +620,8 @@ template <typename B> void bswap(B &base, HsfObjectData32b &obj, HsfObjectData &
     bswap(base, obj.cluster);
     bswap(base, obj.cenvCnt);
     bswap(base, obj.cenv);
-    bswap_flat(base, obj.file, sizeof(obj.file) / sizeof(u32));
+    bswap(base, obj.vtxtop);
+    bswap(base, obj.normtop);
 
     dest.parent = reinterpret_cast<struct hsf_object *>(static_cast<uintptr_t>(obj.parent));
     dest.childrenCount = obj.childrenCount;
@@ -598,8 +644,8 @@ template <typename B> void bswap(B &base, HsfObjectData32b &obj, HsfObjectData &
     dest.cluster = reinterpret_cast<HsfCluster **>(static_cast<uintptr_t>(obj.cluster));
     dest.cenvCnt = obj.cenvCnt;
     dest.cenv = reinterpret_cast<HsfCenv *>(static_cast<uintptr_t>(obj.cenv));
-    dest.file[0] = reinterpret_cast<void *>(static_cast<uintptr_t>(obj.file[0]));
+    dest.vtxtop = reinterpret_cast<HsfVector3f *>(static_cast<uintptr_t>(obj.vtxtop));
-    dest.file[1] = reinterpret_cast<void *>(static_cast<uintptr_t>(obj.file[1]));
+    dest.normtop = reinterpret_cast<HsfVector3f *>(static_cast<uintptr_t>(obj.normtop));
 
     switch (type) {
         case HSF_OBJ_MESH:
@@ -829,9 +875,9 @@ void byteswap_hsfbuffer(HsfBuffer32b *src, HsfBuffer *dest)
     sVisitedPtrs.clear();
 }
 
-void byteswap_hsfmatrix(HsfMatrix *src)
+void byteswap_hsfmatrix(HsfMatrix32b *src, HsfMatrix *dest)
 {
-    bswap(*src, *src);
+    bswap(*src, *src, *dest);
     sVisitedPtrs.clear();
 }
 
@@ -877,6 +923,30 @@ void byteswap_hsfcenv_single(HsfCenvSingle *src)
     sVisitedPtrs.clear();
 }
 
+void byteswap_hsfcenv_dual_weight(HsfCenvDualWeight *src)
+{
+    bswap(*src, *src);
+    sVisitedPtrs.clear();
+}
+
+void byteswap_hsfcenv_dual(HsfCenvDual32b *src, HsfCenvDual *dest)
+{
+    bswap(*src, *src, *dest);
+    sVisitedPtrs.clear();
+}
+
+void byteswap_hsfcenv_multi_weight(HsfCenvMultiWeight *src)
+{
+    bswap(*src, *src);
+    sVisitedPtrs.clear();
+}
+
+void byteswap_hsfcenv_multi(HsfCenvMulti32b *src, HsfCenvMulti *dest)
+{
+    bswap(*src, *src, *dest);
+    sVisitedPtrs.clear();
+}
+
 void byteswap_hsfcenv(HsfCenv32b *src, HsfCenv *dest)
 {
     bswap(*src, *src, *dest);