From 319eb2076c44ec8ddcfd51a28286b10ed4651c95 Mon Sep 17 00:00:00 2001
From: dbalatoni13 <40299962+dbalatoni13@users.noreply.github.com>
Date: Thu, 10 Apr 2025 16:39:36 +0200
Subject: [PATCH] More byteswaps in hsfload.c

---
 include/game/hsfload.h    |   3 +
 include/game/hsfmotion.h  |   6 +-
 include/port/byteswap.h   |  87 ++++++++++++++--
 src/REL/E3setupDLL/main.c |   2 +-
 src/REL/bootDll/main.c    |   2 +-
 src/REL/m409Dll/player.c  |   2 +-
 src/game/ClusterExec.c    |   4 +-
 src/game/board/model.c    |   2 +-
 src/game/hsfex.c          |   2 +-
 src/game/hsfload.c        | 199 ++++++++++++++++++++++++-----------
 src/game/hsfman.c         |  12 ++-
 src/game/hsfmotion.c      | 213 +++++++++++++++++++-------------------
 src/port/byteswap.cpp     | 155 ++++++++++++++++++++++++++-
 13 files changed, 499 insertions(+), 190 deletions(-)

diff --git a/include/game/hsfload.h b/include/game/hsfload.h
index 1b67cb21..c1003f05 100644
--- a/include/game/hsfload.h
+++ b/include/game/hsfload.h
@@ -8,5 +8,8 @@ void ClusterAdjustObject(HsfData *model, HsfData *src_model);
 char *SetName(u32 *str_ofs);
 char *MakeObjectName(char *name);
 s32 CmpObjectName(char *name1, char *name2);
+#ifdef TARGET_PC
+void KillHSF(HsfData *data);
+#endif
 
 #endif
\ No newline at end of file
diff --git a/include/game/hsfmotion.h b/include/game/hsfmotion.h
index f820bd7f..7b07bf9d 100644
--- a/include/game/hsfmotion.h
+++ b/include/game/hsfmotion.h
@@ -10,9 +10,9 @@
 
 
 typedef struct motion_data {
-    s16 unk_00;
-    s16 unk_02;
-    HsfData *unk_04;
+    s16 attr;
+    s16 modelId;
+    HsfData *hsfData;
 } MotionData;
 
 typedef struct {
diff --git a/include/port/byteswap.h b/include/port/byteswap.h
index 09ee44e4..aaf461b2 100644
--- a/include/port/byteswap.h
+++ b/include/port/byteswap.h
@@ -132,19 +132,89 @@ typedef struct HsfCenv32b {
     u32 copyCount;
 } HsfCenv32b;
 
+typedef struct HsfObjectData32b {
+    u32 parent;
+    u32 childrenCount;
+    u32 children;
+    HsfTransform base;
+    HsfTransform curr;
+    union {
+        struct {
+            HsfVector3f min;
+            HsfVector3f max;
+            float baseMorph;
+            float morphWeight[33];
+        } mesh;
+        struct hsf_object *replica;
+    };
+
+    u32 face;
+    u32 vertex;
+    u32 normal;
+    u32 color;
+    u32 st;
+    u32 material;
+    u32 attribute;
+    u8 unk120[2];
+    u8 shapeType;
+    u8 unk123;
+    u32 vertexShapeCnt;
+    u32 vertexShape;
+    u32 clusterCnt;
+    u32 cluster;
+    u32 cenvCnt;
+    u32 cenv;
+    u32 file[2];
+} HsfObjectData32b;
+
 typedef struct HsfObject32b {
     u32 name;
     u32 type;
     u32 constData;
     u32 flags;
-    // TODO PC
-    union {
-        HsfObjectData data;
-        HsfCamera camera;
-        HsfLight light;
-    };
+    HsfObjectData32b data;
 } HsfObject32b;
 
+typedef struct HsfTrack32b {
+    u8 type;
+    u8 start;
+    union {
+        u16 target;
+        s16 target_s16;
+    };
+    union {
+        s32 unk04;
+        struct {
+            union {
+                s16 param;
+                u16 param_u16;
+            };
+            union {
+                u16 channel;
+                s16 channel_s16;
+            };
+        };
+    };
+    u16 curveType;
+    u16 numKeyframes;
+    union {
+        float value;
+        u32 data;
+    };
+} HsfTrack32b;
+
+typedef struct HsfMotion32b {
+    u32 name;
+    s32 numTracks;
+    u32 track;
+    float len;
+} HsfMotion32b;
+
+typedef struct HsfBitmapKey32b {
+    float time;
+    u32 data;
+} HsfBitmapKey32b;
+
 void byteswap_u16(u16 *src);
 void byteswap_s16(s16 *src);
 void byteswap_u32(u32 *src);
@@ -172,9 +242,12 @@ void byteswap_hsfbitmap(HsfBitmap32b *src, HsfBitmap *dest);
 void byteswap_hsfmapattr(HsfMapAttr32b *src, HsfMapAttr *dest);
 void byteswap_hsfskeleton(HsfSkeleton32b *src, HsfSkeleton *dest);
 void byteswap_hsfshape(HsfShape32b *src, HsfShape *dest);
-void byteswap_hsfcenvsingle(HsfCenvSingle *src);
+void byteswap_hsfcenv_single(HsfCenvSingle *src);
 void byteswap_hsfcenv(HsfCenv32b *src, HsfCenv *dest);
 void byteswap_hsfobject(HsfObject32b *src, HsfObject *dest);
+void byteswap_hsfbitmapkey(HsfBitmapKey32b *src, HsfBitmapKey *dest);
+void byteswap_hsftrack(HsfTrack32b *src, HsfTrack *dest);
+void byteswap_hsfmotion(HsfMotion32b *src, HsfMotion *dest);
 
 #ifdef __cplusplus
 }
diff --git a/src/REL/E3setupDLL/main.c b/src/REL/E3setupDLL/main.c
index a080e2de..c035cd01 100644
--- a/src/REL/E3setupDLL/main.c
+++ b/src/REL/E3setupDLL/main.c
@@ -300,7 +300,7 @@ float MotionMaxTimeGet(s16 arg0)
     HsfMotion *temp_r30;
     s16 temp_r29;
 
-    temp_r30 = temp_r31->unk_04->motion;
+    temp_r30 = temp_r31->hsfData->motion;
     temp_r29 = temp_r30->len;
     return temp_r29;
 }
diff --git a/src/REL/bootDll/main.c b/src/REL/bootDll/main.c
index 56bb9c06..6dd2f03a 100644
--- a/src/REL/bootDll/main.c
+++ b/src/REL/bootDll/main.c
@@ -565,9 +565,9 @@ void ObjectSetup(void)
      s16 sprite;
      AnimData *sprite_data;
      s16 i;
+     titleMdlId[0] = model = Hu3DModelCreateFile(TITLE_CHAR_HSF);
 #ifdef __MWERKS__
      // TODO PC
-     titleMdlId[0] = model = Hu3DModelCreateFile(TITLE_CHAR_HSF);
      Hu3DModelAttrSet(model, HU3D_ATTR_DISPOFF);
      Hu3DModelAttrSet(model, HU3D_MOTATTR_LOOP);
      titleMdlId[1] = model = Hu3DModelCreateFile(TITLE_CUBE_HSF);
diff --git a/src/REL/m409Dll/player.c b/src/REL/m409Dll/player.c
index 9157deeb..ed75457f 100644
--- a/src/REL/m409Dll/player.c
+++ b/src/REL/m409Dll/player.c
@@ -1263,7 +1263,7 @@ f32 fn_1_BF38(s16 arg0)
     f32 length;
 
     motionData = &Hu3DMotion[arg0];
-    hsfMotionData = motionData->unk_04->motion;
+    hsfMotionData = motionData->hsfData->motion;
     length = hsfMotionData->len;
     return length;
 }
diff --git a/src/game/ClusterExec.c b/src/game/ClusterExec.c
index eff1ded2..af0b6981 100644
--- a/src/game/ClusterExec.c
+++ b/src/game/ClusterExec.c
@@ -117,7 +117,7 @@ void ClusterProc(ModelData *arg0)
         temp_r24 = arg0->unk_10[i];
         if (temp_r24 != -1) {
             temp_r22 = &Hu3DMotion[temp_r24];
-            temp_r27 = temp_r22->unk_04;
+            temp_r27 = temp_r22->hsfData;
             temp_r23 = arg0->hsfData;
             var_r29 = temp_r27->cluster;
             for (j = 0; j < temp_r27->clusterCnt; j++, var_r29++) {
@@ -159,7 +159,7 @@ void ClusterMotionExec(ModelData *arg0)
         if (arg0->unk_10[i] != -1) {
             var_r20 = arg0->unk_10[i];
             var_r23 = &Hu3DMotion[var_r20];
-            temp_r28 = var_r23->unk_04;
+            temp_r28 = var_r23->hsfData;
             temp_r27 = temp_r28->motion;
             var_r31 = temp_r27->track;
             temp_f31 = arg0->unk_A4[i];
diff --git a/src/game/board/model.c b/src/game/board/model.c
index 599f05e2..5162b2fe 100644
--- a/src/game/board/model.c
+++ b/src/game/board/model.c
@@ -747,7 +747,7 @@ float BoardModelMotionShapeMaxTimeGet(s16 model)
             return 0;
         }
         motion = &Hu3DMotion[hsf_model->unk_0E];
-        motion_hsf = motion->unk_04->motion;
+        motion_hsf = motion->hsfData->motion;
         return motion_hsf->len;
     }
 }
diff --git a/src/game/hsfex.c b/src/game/hsfex.c
index 467def93..9455c65d 100644
--- a/src/game/hsfex.c
+++ b/src/game/hsfex.c
@@ -59,7 +59,7 @@ void CamMotionEx(s16 arg0, s16 arg1, Vec *arg2, Vec *arg3, Vec *arg4, float arg5
     temp_r23 = &Hu3DData[arg0];
     temp_r19 = &Hu3DMotion[temp_r23->unk_08];
     temp_r22 = temp_r23->hsfData;
-    temp_r18 = temp_r19->unk_04;
+    temp_r18 = temp_r19->hsfData;
     temp_r26 = temp_r18->motion;
     for (var_r25 = 0; var_r25 < HU3D_CAM_MAX; var_r25++) {
         if (arg1 & (1 << var_r25)) {
diff --git a/src/game/hsfload.c b/src/game/hsfload.c
index 4830ba7a..fe4d12a3 100644
--- a/src/game/hsfload.c
+++ b/src/game/hsfload.c
@@ -143,15 +143,18 @@ static void FileLoad(void *data)
     StringTable = (char *)((uintptr_t)fileptr+head.string.ofs);
     ClusterTop = HuMemDirectMallocNum(HEAP_DATA, sizeof(HsfCluster) * head.cluster.count, MEMORY_DEFAULT_NUM);
     for (i = 0; i < head.cluster.count; i++) {
-        byteswap_hsfcluster(&((HsfCluster32b *)((uintptr_t)fileptr + head.cluster.ofs))[i], &ClusterTop[i]);
+        HsfCluster32b *file_cluster_real = (HsfCluster32b *)((uintptr_t)fileptr + head.cluster.ofs);
+        byteswap_hsfcluster(&file_cluster_real[i], &ClusterTop[i]);
     }
     AttributeTop = HuMemDirectMallocNum(HEAP_DATA, sizeof(HsfAttribute) * head.attribute.count, MEMORY_DEFAULT_NUM);
     for (i = 0; i < head.attribute.count; i++) {
-        byteswap_hsfattribute(&((HsfAttribute32b *)((uintptr_t)fileptr + head.attribute.ofs))[i], &AttributeTop[i]);
+        HsfAttribute32b *file_attribute_real = (HsfAttribute32b *)((uintptr_t)fileptr + head.attribute.ofs);
+        byteswap_hsfattribute(&file_attribute_real[i], &AttributeTop[i]);
     }
     MaterialTop = HuMemDirectMallocNum(HEAP_DATA, sizeof(HsfMaterial) * head.material.count, MEMORY_DEFAULT_NUM);
     for (i = 0; i < head.material.count; i++) {
-        byteswap_hsfmaterial(&((HsfMaterial32b *)((uintptr_t)fileptr + head.material.ofs))[i], &MaterialTop[i]);
+        HsfMaterial32b *file_material_real = (HsfMaterial32b *)((uintptr_t)fileptr + head.material.ofs);
+        byteswap_hsfmaterial(&file_material_real[i], &MaterialTop[i]);
     }
 #else
     NSymIndex = (void **)((uintptr_t)fileptr+head.symbol.ofs);
@@ -273,10 +276,7 @@ static void MaterialLoad(void)
             rgba[i].b = new_mat->litColor[2];
             rgba[i].a = 255;
             for(j=0; j<new_mat->numAttrs; j++) {
-#ifdef __MWERKS__
-                // TODO PC
                 new_mat->attrs[j] = new_mat->attrs[j];
-#endif
             }
         }
     }
@@ -341,9 +341,10 @@ static void ColorLoad(void)
     
     if(head.color.count) {
 #ifdef TARGET_PC
+        HsfBuffer32b * file_color_real = (HsfBuffer32b *)((uintptr_t)fileptr + head.color.ofs);
         temp_color = file_color = ColorTop = HuMemDirectMallocNum(HEAP_DATA, sizeof(HsfBuffer) * head.color.count, MEMORY_DEFAULT_NUM);
         for (i = 0; i < head.color.count; i++) {
-            byteswap_hsfbuffer(&((HsfBuffer32b *)((uintptr_t)fileptr + head.color.ofs))[i], &file_color[i]);
+            byteswap_hsfbuffer(&file_color_real[i], &file_color[i]);
         }
 #else
         temp_color = file_color = (HsfBuffer *)((u32)fileptr+head.color.ofs);
@@ -354,7 +355,7 @@ static void ColorLoad(void)
         Model.color = new_color;
         Model.colorCnt = head.color.count;
 #ifdef TARGET_PC
-        data = (u16 *)&((HsfBuffer32b *)((uintptr_t)fileptr + head.color.ofs))[head.color.count];
+        data = (u16 *)&file_color_real[head.color.count];
 #else
         file_color = (HsfBuffer *)((u32)fileptr+head.color.ofs);
         data = &file_color[head.color.count];
@@ -378,9 +379,10 @@ static void VertexLoad(void)
     
     if(head.vertex.count) {
 #ifdef TARGET_PC
+        HsfBuffer32b *file_vertex_real = (HsfBuffer32b *)((uintptr_t)fileptr + head.vertex.ofs);
         vtxtop = file_vertex = HuMemDirectMallocNum(HEAP_DATA, sizeof(HsfBuffer) * head.vertex.count, MEMORY_DEFAULT_NUM);
         for (i = 0; i < head.vertex.count; i++) {
-            byteswap_hsfbuffer(&((HsfBuffer32b *)((uintptr_t)fileptr + head.vertex.ofs))[i], &file_vertex[i]);
+            byteswap_hsfbuffer(&file_vertex_real[i], &file_vertex[i]);
         }
 #else
         vtxtop = file_vertex = (HsfBuffer *)((u32)fileptr+head.vertex.ofs);
@@ -395,7 +397,7 @@ static void VertexLoad(void)
         Model.vertex = new_vertex;
         Model.vertexCnt = head.vertex.count;
 #ifdef TARGET_PC
-        VertexDataTop = data = (void *)&((HsfBuffer32b *)((uintptr_t)fileptr + head.vertex.ofs))[head.vertex.count];
+        VertexDataTop = data = (void *)&file_vertex_real[head.vertex.count];
 #else
         file_vertex = (HsfBuffer *)((u32)fileptr+head.vertex.ofs);
         VertexDataTop = data = (void *)&file_vertex[head.vertex.count];
@@ -431,9 +433,10 @@ static void NormalLoad(void)
     if(head.normal.count) {
         s32 cenv_count = head.cenv.count;
 #ifdef TARGET_PC
+        HsfBuffer32b *file_normal_real = (HsfBuffer32b *)((uintptr_t)fileptr + head.normal.ofs);
         temp_normal = file_normal = NormalTop = HuMemDirectMallocNum(HEAP_DATA, sizeof(HsfBuffer) * head.normal.count, MEMORY_DEFAULT_NUM);
         for (i = 0; i < head.normal.count; i++) {
-            byteswap_hsfbuffer(&((HsfBuffer32b *)((uintptr_t)fileptr + head.normal.ofs))[i], &file_normal[i]);
+            byteswap_hsfbuffer(&file_normal_real[i], &file_normal[i]);
         }
 #else
         temp_normal = file_normal = (HsfBuffer *)((u32)fileptr+head.normal.ofs);
@@ -443,7 +446,7 @@ static void NormalLoad(void)
         Model.normal = new_normal;
         Model.normalCnt = head.normal.count;
 #ifdef TARGET_PC
-        VertexDataTop = data = (void *)&((HsfBuffer32b *)((uintptr_t)fileptr + head.normal.ofs))[head.normal.count];
+        VertexDataTop = 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];
@@ -469,9 +472,10 @@ static void STLoad(void)
     
     if(head.st.count) {
 #ifdef TARGET_PC
+        HsfBuffer32b *file_st_real = (HsfBuffer32b *)((uintptr_t)fileptr + head.st.ofs);
         temp_st = file_st = StTop = HuMemDirectMallocNum(HEAP_DATA, sizeof(HsfBuffer) * head.st.count, MEMORY_DEFAULT_NUM);
         for (i = 0; i < head.st.count; i++) {
-            byteswap_hsfbuffer(&((HsfBuffer32b *)((uintptr_t)fileptr + head.st.ofs))[i], &file_st[i]);
+            byteswap_hsfbuffer(&file_st_real[i], &file_st[i]);
         }
 #else
         temp_st = file_st = (HsfBuffer *)((u32)fileptr+head.st.ofs);
@@ -486,7 +490,7 @@ static void STLoad(void)
         Model.st = new_st;
         Model.stCnt = head.st.count;
 #ifdef TARGET_PC
-        data = (void *)&((HsfBuffer32b *)((uintptr_t)fileptr + head.st.ofs))[head.st.count];
+        data = (void *)&file_st_real[head.st.count];
 #else
         file_st = (HsfBuffer *)((u32)fileptr+head.st.ofs);
         data = (void *)&file_st[head.st.count];
@@ -523,9 +527,10 @@ static void FaceLoad(void)
     
     if(head.face.count) {
 #ifdef TARGET_PC
+        HsfBuffer32b *file_face_real = (HsfBuffer32b *)((uintptr_t)fileptr + head.face.ofs);
         temp_face = file_face = FaceTop = HuMemDirectMallocNum(HEAP_DATA, sizeof(HsfBuffer) * head.face.count, MEMORY_DEFAULT_NUM);
         for (i = 0; i < head.face.count; i++) {
-            byteswap_hsfbuffer(&((HsfBuffer32b *)((uintptr_t)fileptr + head.face.ofs))[i], &file_face[i]);
+            byteswap_hsfbuffer(&file_face[i], &file_face[i]);
         }
 #else
         temp_face = file_face = (HsfBuffer *)((u32)fileptr+head.face.ofs);
@@ -535,7 +540,7 @@ static void FaceLoad(void)
         Model.face = new_face;
         Model.faceCnt = head.face.count;
 #ifdef TARGET_PC
-        data = (void *)&((HsfBuffer32b *)((uintptr_t)fileptr + head.face.ofs))[head.face.count];
+        data = (void *)&file_face_real[head.face.count];
 #else
         file_face = (HsfBuffer *)((u32)fileptr+head.face.ofs);
         data = (HsfFace *)&file_face[head.face.count];
@@ -559,6 +564,7 @@ static void FaceLoad(void)
 #ifdef TARGET_PC
                     {
                         s32 k;
+                        byteswap_u32(&new_face_strip->strip.count);
                         for (k = 0; k < new_face_strip->strip.count; k++) {
                             byteswap_s16(&new_face_strip->strip.data[k]);
                         }
@@ -592,9 +598,9 @@ static void DispObject(HsfObject *parent, HsfObject *object)
             data = &object->data;
             new_object = temp_object = object;
             new_object->data.childrenCount = data->childrenCount;
-            new_object->data.children = (HsfObject **)&NSymIndex[(u32)data->children];
+            new_object->data.children = (HsfObject **)&NSymIndex[(uintptr_t)data->children];
             for(i=0; i<new_object->data.childrenCount; i++) {
-                child_obj = &objtop[(u32)new_object->data.children[i]];
+                child_obj = &objtop[(uintptr_t)new_object->data.children[i]];
                 new_object->data.children[i] = child_obj;
             }
             new_object->data.parent = parent;
@@ -607,14 +613,14 @@ static void DispObject(HsfObject *parent, HsfObject *object)
             new_object->data.st = SearchStPtr((s32)data->st);
             new_object->data.color = SearchColorPtr((s32)data->color);
             new_object->data.face = SearchFacePtr((s32)data->face);
-            new_object->data.vertexShape = (HsfBuffer **)&NSymIndex[(u32)data->vertexShape];
+            new_object->data.vertexShape = (HsfBuffer **)&NSymIndex[(uintptr_t)data->vertexShape];
             for(i=0; i<new_object->data.vertexShapeCnt; i++) {
-                temp.shape = &vtxtop[(u32)new_object->data.vertexShape[i]];
+                temp.shape = &vtxtop[(uintptr_t)new_object->data.vertexShape[i]];
                 new_object->data.vertexShape[i] = temp.shape;
             }
-            new_object->data.cluster = (HsfCluster **)&NSymIndex[(u32)data->cluster];
+            new_object->data.cluster = (HsfCluster **)&NSymIndex[(uintptr_t)data->cluster];
             for(i=0; i<new_object->data.clusterCnt; i++) {
-                temp.cluster = &ClusterTop[(u32)new_object->data.cluster[i]];
+                temp.cluster = &ClusterTop[(uintptr_t)new_object->data.cluster[i]];
                 new_object->data.cluster[i] = temp.cluster;
             }
             new_object->data.cenv = SearchCenvPtr((s32)data->cenv);
@@ -624,8 +630,8 @@ static void DispObject(HsfObject *parent, HsfObject *object)
             } else {
                 new_object->data.attribute = NULL;
             }
-            new_object->data.file[0] = (void *)((uintptr_t)fileptr+(u32)data->file[0]);
-            new_object->data.file[1] = (void *)((uintptr_t)fileptr+(u32)data->file[1]);
+            new_object->data.file[0] = (void *)((uintptr_t)fileptr + (uintptr_t)data->file[0]);
+            new_object->data.file[1] = (void *)((uintptr_t)fileptr + (uintptr_t)data->file[1]);
             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;
@@ -655,9 +661,9 @@ static void DispObject(HsfObject *parent, HsfObject *object)
             new_object = temp_object = object;
             new_object->data.parent = parent;
             new_object->data.childrenCount = data->childrenCount;
-            new_object->data.children = (HsfObject **)&NSymIndex[(u32)data->children];
+            new_object->data.children = (HsfObject **)&NSymIndex[(uintptr_t)data->children];
             for(i=0; i<new_object->data.childrenCount; i++) {
-                child_obj = &objtop[(u32)new_object->data.children[i]];
+                child_obj = &objtop[(uintptr_t)new_object->data.children[i]];
                 new_object->data.children[i] = child_obj;
             }
             if(Model.root == NULL) {
@@ -677,15 +683,15 @@ static void DispObject(HsfObject *parent, HsfObject *object)
             new_object = temp_object = object;
             new_object->data.parent = parent;
             new_object->data.childrenCount = data->childrenCount;
-            new_object->data.children = (HsfObject **)&NSymIndex[(u32)data->children];
+            new_object->data.children = (HsfObject **)&NSymIndex[(uintptr_t)data->children];
             for(i=0; i<new_object->data.childrenCount; i++) {
-                child_obj = &objtop[(u32)new_object->data.children[i]];
+                child_obj = &objtop[(uintptr_t)new_object->data.children[i]];
                 new_object->data.children[i] = child_obj;
             }
             if(Model.root == NULL) {
                 Model.root = temp_object;
             }
-            new_object->data.replica = &objtop[(u32)new_object->data.replica];
+            new_object->data.replica = &objtop[(uintptr_t)new_object->data.replica];
             for(i=0; i<data->childrenCount; i++) {
                 DispObject(new_object, new_object->data.children[i]);
             }
@@ -821,9 +827,10 @@ static void ObjectLoad(void)
 
     if(head.object.count) {
 #ifdef TARGET_PC
+        HsfObject32b *file_object_real = (HsfObject32b *)((uintptr_t)fileptr + head.object.ofs);
         objtop = object = HuMemDirectMallocNum(HEAP_DATA, sizeof(HsfObject) * head.object.count, MEMORY_DEFAULT_NUM);
         for (i = 0; i < head.object.count; i++) {
-            byteswap_hsfobject(&((HsfObject32b *)((uintptr_t)fileptr + head.object.ofs))[i], &objtop[i]);
+            byteswap_hsfobject(&file_object_real[i], &objtop[i]);
         }
 #else
         objtop = object = (HsfObject *)((u32)fileptr+head.object.ofs);
@@ -866,11 +873,12 @@ static void CenvLoad(void)
     
     if(head.cenv.count) {
 #ifdef TARGET_PC
+        HsfCenv32b *file_cenv_real = (HsfCenv32b *)((uintptr_t)fileptr + head.cenv.ofs);
         cenv_file = CenvTop = HuMemDirectMallocNum(HEAP_DATA, sizeof(HsfCenv) * head.cenv.count, MEMORY_DEFAULT_NUM);
         for (i = 0; i < head.cenv.count; i++) {
-            byteswap_hsfcenv(&((HsfCenv32b *)((uintptr_t)fileptr + head.cenv.ofs))[i], &cenv_file[i]);
+            byteswap_hsfcenv(&file_cenv_real[i], &cenv_file[i]);
         }
-        data_base = &((HsfCenv *)((uintptr_t)fileptr + head.cenv.ofs))[head.cenv.count];
+        data_base = &file_cenv_real[head.cenv.count];
 #else
         cenv_file = (HsfCenv *)((u32)fileptr+head.cenv.ofs);
         data_base = &cenv_file[head.cenv.count];
@@ -892,8 +900,8 @@ static void CenvLoad(void)
             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_hsfcenvsingle(cenv_new[i].singleData);
-            // TODO pc malloc dual, multi etc and byteswap them
+            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++) {
@@ -944,9 +952,10 @@ static void SkeletonLoad(void)
     
     if(head.skeleton.count) {
 #ifdef TARGET_PC
+        HsfSkeleton32b *file_skeleton_real = (HsfSkeleton32b *)((uintptr_t)fileptr + head.skeleton.ofs);
         skeleton_new = skeleton_file = HuMemDirectMallocNum(HEAP_DATA, sizeof(HsfSkeleton) * head.skeleton.count, MEMORY_DEFAULT_NUM);
         for (i = 0; i < head.skeleton.count; i++) {
-            byteswap_hsfskeleton(&((HsfSkeleton32b *)((uintptr_t)fileptr + head.skeleton.ofs))[i], &skeleton_file[i]);
+            byteswap_hsfskeleton(&file_skeleton_real[i], &skeleton_file[i]);
         }
 #else
         skeleton_new = skeleton_file = (HsfSkeleton *)((u32)fileptr+head.skeleton.ofs);
@@ -978,9 +987,10 @@ static void PartLoad(void)
     
     if(head.part.count) {
 #ifdef TARGET_PC
+        HsfPart32b *file_part_real = (HsfPart32b *)((uintptr_t)fileptr + head.part.ofs);
         part_new = part_file = PartTop = HuMemDirectMallocNum(HEAP_DATA, sizeof(HsfPart) * head.part.count, MEMORY_DEFAULT_NUM);
         for (i = 0; i < head.part.count; i++) {
-            byteswap_hsfpart(&((HsfPart32b *)((uintptr_t)fileptr + head.part.ofs))[i], &part_file[i]);
+            byteswap_hsfpart(&file_part_real[i], &part_file[i]);
         }
 #else
         part_new = part_file = (HsfPart *)((u32)fileptr+head.part.ofs);
@@ -988,7 +998,7 @@ static void PartLoad(void)
         Model.partCnt = head.part.count;
         Model.part = part_file;
 #ifdef TARGET_PC
-        data = (u16 *)&((HsfPart32b *)((uintptr_t)fileptr + head.part.ofs))[head.part.count];
+        data = (u16 *)&file_part_real[head.part.count];
 #else
         data = (u16 *)&part_file[head.part.count];
 #endif
@@ -1049,9 +1059,10 @@ static void ShapeLoad(void)
 
     if(head.shape.count) {
 #ifdef TARGET_PC
+        HsfShape32b *file_shape_real = (HsfShape32b *)((uintptr_t)fileptr + head.shape.ofs);
         shape_new = shape_file = HuMemDirectMallocNum(HEAP_DATA, sizeof(HsfShape) * head.shape.count, MEMORY_DEFAULT_NUM);
         for (i = 0; i < head.shape.count; i++) {
-            byteswap_hsfshape(&((HsfShape32b *)((uintptr_t)fileptr + head.shape.ofs))[i], &shape_file[i]);
+            byteswap_hsfshape(&file_shape_real[i], &shape_file[i]);
         }
 #else
         shape_new = shape_file = (HsfShape *)((u32)fileptr+head.shape.ofs);
@@ -1085,9 +1096,10 @@ static void MapAttrLoad(void)
     
     if(head.mapAttr.count) {
 #ifdef TARGET_PC
+        HsfMapAttr32b *file_mapattr_real = (HsfMapAttr32b *)((uintptr_t)fileptr + head.mapAttr.ofs);
         mapattr_file = mapattr_base = HuMemDirectMallocNum(HEAP_DATA, sizeof(HsfMapAttr) * head.mapAttr.count, MEMORY_DEFAULT_NUM);
         for (i = 0; i < head.mapAttr.count; i++) {
-            byteswap_hsfmapattr(&((HsfMapAttr32b *)((uintptr_t)fileptr + head.mapAttr.ofs))[i], &mapattr_base[i]);
+            byteswap_hsfmapattr(&file_mapattr_real[i], &mapattr_base[i]);
         }
 #else
         mapattr_file = mapattr_base = (HsfMapAttr *)((u32)fileptr+head.mapAttr.ofs);
@@ -1096,7 +1108,7 @@ static void MapAttrLoad(void)
         Model.mapAttrCnt = head.mapAttr.count;
         Model.mapAttr = mapattr_base;
 #ifdef TARGET_PC
-        data = (u16 *)&((HsfPart32b *)((uintptr_t)fileptr + head.part.ofs))[head.part.count];
+        data = (u16 *)&file_mapattr_real[head.part.count];
 #else
         data = (u16 *)&mapattr_base[head.mapAttr.count];
 #endif
@@ -1117,9 +1129,10 @@ static void BitmapLoad(void)
     
     if(head.bitmap.count) {
 #ifdef TARGET_PC
+        HsfBitmap32b *file_bitmap_real = (HsfBitmap32b *)((uintptr_t)fileptr + head.bitmap.ofs);
         bitmap_temp = bitmap_file = BitmapTop = HuMemDirectMallocNum(HEAP_DATA, sizeof(HsfBitmap) * head.bitmap.count, MEMORY_DEFAULT_NUM);
         for (i = 0; i < head.bitmap.count; i++) {
-            byteswap_hsfbitmap(&((HsfBitmap32b *)((uintptr_t)fileptr + head.bitmap.ofs))[i], &bitmap_file[i]);
+            byteswap_hsfbitmap(&file_bitmap_real[i], &bitmap_file[i]);
         }
 #else
         bitmap_temp = bitmap_file = (HsfBitmap *)((u32)fileptr+head.bitmap.ofs);
@@ -1130,7 +1143,7 @@ static void BitmapLoad(void)
         Model.bitmap = bitmap_file;
         Model.bitmapCnt = head.bitmap.count;
 #ifdef TARGET_PC
-        data = (void *)&((HsfBitmap32b *)((uintptr_t)fileptr + head.st.ofs))[head.st.count];
+        data = (void *)&file_bitmap_real[head.st.count];
 #else
         bitmap_file = (HsfBitmap *)((u32)fileptr+head.bitmap.ofs);
         data = &bitmap_file[head.bitmap.count];
@@ -1165,9 +1178,10 @@ static void PaletteLoad(void)
     
     if(head.palette.count) {
 #ifdef TARGET_PC
+        HsfPalette32b *file_palette_real = (HsfPalette32b *)((uintptr_t)fileptr + head.palette.ofs);
         palette_temp = palette_file = HuMemDirectMallocNum(HEAP_DATA, sizeof(HsfPalette) * head.palette.count, MEMORY_DEFAULT_NUM);
         for (i = 0; i < head.palette.count; i++) {
-            byteswap_hsfpalette(&((HsfPalette32b *)((uintptr_t)fileptr + head.palette.ofs))[i], &palette_file[i]);
+            byteswap_hsfpalette(&file_palette_real[i], &palette_file[i]);
         }
 #else
         palette_temp = palette_file = (HsfPalette *)((u32)fileptr+head.palette.ofs);
@@ -1180,7 +1194,7 @@ static void PaletteLoad(void)
         Model.paletteCnt = head.palette.count;
         palette_new = palette_temp;
 #ifdef TARGET_PC
-        data_base = (u16 *)&((HsfPalette32b *)((uintptr_t)fileptr + head.palette.ofs))[head.palette.count];
+        data_base = (u16 *)&file_palette_real[head.palette.count];
 #else
         palette_file = (HsfPalette *)((u32)fileptr+head.palette.ofs);
         data_base = (u16 *)&palette_file[head.palette.count];
@@ -1342,21 +1356,21 @@ static inline void MotionLoadTransform(HsfTrack *track, void *data)
     switch(track->curveType) {
         case HSF_CURVE_STEP:
         {
-            step_data = (float *)((u32)data+(u32)track->data);
+            step_data = (float *)((uintptr_t)data + (uintptr_t)track->data);
             out_track->data = step_data;
         }
         break;
         
         case HSF_CURVE_LINEAR:
         {
-            linear_data = (float *)((u32)data+(u32)track->data);
+            linear_data = (float *)((uintptr_t)data + (uintptr_t)track->data);
             out_track->data = linear_data;
         }
         break;
         
         case HSF_CURVE_BEZIER:
         {
-            bezier_data = (float *)((u32)data+(u32)track->data);
+            bezier_data = (float *)((uintptr_t)data + (uintptr_t)track->data);
             out_track->data = bezier_data;
         }
         break;
@@ -1387,21 +1401,21 @@ static inline void MotionLoadCluster(HsfTrack *track, void *data)
     switch(track->curveType) {
         case HSF_CURVE_STEP:
         {
-            step_data = (float *)((u32)data+(u32)track->data);
+            step_data = (float *)((uintptr_t)data + (uintptr_t)track->data);
             out_track->data = step_data;
         }
         break;
         
         case HSF_CURVE_LINEAR:
         {
-            linear_data = (float *)((u32)data+(u32)track->data);
+            linear_data = (float *)((uintptr_t)data + (uintptr_t)track->data);
             out_track->data = linear_data;
         }
         break;
         
         case HSF_CURVE_BEZIER:
         {
-            bezier_data = (float *)((u32)data+(u32)track->data);
+            bezier_data = (float *)((uintptr_t)data + (uintptr_t)track->data);
             out_track->data = bezier_data;
         }
         break;
@@ -1432,21 +1446,21 @@ static inline void MotionLoadClusterWeight(HsfTrack *track, void *data)
     switch(track->curveType) {
         case HSF_CURVE_STEP:
         {
-            step_data = (float *)((u32)data+(u32)track->data);
+            step_data = (float *)((uintptr_t)data + (uintptr_t)track->data);
             out_track->data = step_data;
         }
         break;
         
         case HSF_CURVE_LINEAR:
         {
-            linear_data = (float *)((u32)data+(u32)track->data);
+            linear_data = (float *)((uintptr_t)data + (uintptr_t)track->data);
             out_track->data = linear_data;
         }
         break;
         
         case HSF_CURVE_BEZIER:
         {
-            bezier_data = (float *)((u32)data+(u32)track->data);
+            bezier_data = (float *)((uintptr_t)data + (uintptr_t)track->data);
             out_track->data = bezier_data;
         }
         break;
@@ -1468,21 +1482,21 @@ static inline void MotionLoadMaterial(HsfTrack *track, void *data)
     switch(track->curveType) {
         case HSF_CURVE_STEP:
         {
-            step_data = (float *)((u32)data+(u32)track->data);
+            step_data = (float *)((uintptr_t)data + (uintptr_t)track->data);
             out_track->data = step_data;
         }
         break;
         
         case HSF_CURVE_LINEAR:
         {
-            linear_data = (float *)((u32)data+(u32)track->data);
+            linear_data = (float *)((uintptr_t)data + (uintptr_t)track->data);
             out_track->data = linear_data;
         }
         break;
         
         case HSF_CURVE_BEZIER:
         {
-            bezier_data = (float *)((u32)data+(u32)track->data);
+            bezier_data = (float *)((uintptr_t)data + (uintptr_t)track->data);
             out_track->data = bezier_data;
         }
         break;
@@ -1515,30 +1529,38 @@ static inline void MotionLoadAttribute(HsfTrack *track, void *data)
     switch(track->curveType) {
         case HSF_CURVE_STEP:
         {
-            step_data = (float *)((u32)data+(u32)track->data);
+            step_data = (float *)((uintptr_t)data + (uintptr_t)track->data);
             out_track->data = step_data;
         }
         break;
         
         case HSF_CURVE_LINEAR:
         {
-            linear_data = (float *)((u32)data+(u32)track->data);
+            linear_data = (float *)((uintptr_t)data + (uintptr_t)track->data);
             out_track->data = linear_data;
         }
         break;
         
         case HSF_CURVE_BEZIER:
         {
-            bezier_data = (float *)((u32)data+(u32)track->data);
+            bezier_data = (float *)((uintptr_t)data + (uintptr_t)track->data);
             out_track->data = bezier_data;
         }
         break;
         
         case HSF_CURVE_BITMAP:
         {
-            new_frame = file_frame = (HsfBitmapKey *)((u32)data+(u32)track->data);
+#ifdef TARGET_PC
+            HsfBitmapKey32b *file_frame_real = (HsfBitmapKey32b *)((uintptr_t)data + (uintptr_t)track->data);
+            new_frame = file_frame = HuMemDirectMallocNum(HEAP_DATA, sizeof(HsfBitmapKey) * track->numKeyframes, MEMORY_DEFAULT_NUM);
+#else
+            new_frame = file_frame = (HsfBitmapKey *)((uintptr_t)data + (uintptr_t)track->data);
             out_track->data = file_frame;
+#endif
             for(i=0; i<out_track->numKeyframes; i++, file_frame++, new_frame++) {
+#ifdef TARGET_PC
+                byteswap_hsfbitmapkey(&file_frame_real[i], new_frame);
+#endif
                 new_frame->data = SearchBitmapPtr((s32)file_frame->data);
             }
         }
@@ -1560,12 +1582,31 @@ static void MotionLoad(void)
     MotionOnly = FALSE;
     MotionModel = NULL;
     if(head.motion.count) {
+#ifdef TARGET_PC
+        HsfMotion32b *file_motion_real = (HsfMotion32b *)((uintptr_t)fileptr + head.motion.ofs);
+        temp_motion = file_motion = HuMemDirectMallocNum(HEAP_DATA, sizeof(HsfMotion) * head.motion.count, MEMORY_DEFAULT_NUM);
+        for (i = 0; i < head.motion.count; i++) {
+            byteswap_hsfmotion(&file_motion_real[i], &file_motion[i]);
+        }
+#else
         temp_motion = file_motion = (HsfMotion *)((uintptr_t)fileptr+head.motion.ofs);
+#endif
         new_motion = temp_motion;
         Model.motion = new_motion;
         Model.motionCnt = file_motion->numTracks;
+#ifdef TARGET_PC
+        {
+            HsfTrack32b *track_base_real = (HsfTrack32b *)&file_motion_real[head.motion.count];
+            track_base = HuMemDirectMallocNum(HEAP_DATA, sizeof(HsfTrack) * file_motion->numTracks, MEMORY_DEFAULT_NUM);
+            track_data = &track_base_real[file_motion->numTracks];
+            for (i = 0; i < file_motion->numTracks; i++) {
+                byteswap_hsftrack(&track_base_real[i], &track_base[i]);
+            }
+        }
+#else
         track_base = (HsfTrack *)&file_motion[head.motion.count];
         track_data = &track_base[file_motion->numTracks];
+#endif
         new_motion->track = track_base;
         for(i=0; i<(s32)file_motion->numTracks; i++) {
             switch(track_base[i].type) {
@@ -1793,3 +1834,41 @@ static char *GetMotionString(u16 *str_ofs)
     char *ret = &StringTable[*str_ofs];
     return ret;
 }
+
+#ifdef TARGET_PC
+void KillHSF(HsfData *data)
+{
+    s32 i, j;
+    HuMemDirectFree(data->attribute);
+    HuMemDirectFree(data->bitmap);
+    HuMemDirectFree(data->cenv);
+    HuMemDirectFree(data->skeleton);
+    HuMemDirectFree(data->face);
+    HuMemDirectFree(data->material);
+    for (i = 0; i < data->motionCnt; i++) {
+        HsfMotion *motion = &data->motion[i];
+        for (j = 0; j < motion->numTracks; j++) {
+            HsfTrack *track = data->motion[i].track;
+            if (track->type == HSF_TRACK_ATTRIBUTE && track->curveType == HSF_CURVE_BITMAP) {
+                // in this case we needed to allocate space for HsfBitmapKey structs
+                HuMemDirectFree(track->data);
+            }
+        }
+        HuMemDirectFree(motion->track);
+    }
+    HuMemDirectFree(data->motion);
+    HuMemDirectFree(data->normal);
+    HuMemDirectFree(data->object);
+    HuMemDirectFree(data->matrix);
+    HuMemDirectFree(data->palette);
+    HuMemDirectFree(data->st);
+    HuMemDirectFree(data->vertex);
+    HuMemDirectFree(data->cenv);
+    HuMemDirectFree(data->cluster);
+    HuMemDirectFree(data->part);
+    HuMemDirectFree(data->shape);
+    HuMemDirectFree(data->mapAttr);
+    HuMemDirectFree(data->symbol);
+    // TODO PC free embedded data
+}
+#endif
diff --git a/src/game/hsfman.c b/src/game/hsfman.c
index 7ef634ac..a82748e3 100644
--- a/src/game/hsfman.c
+++ b/src/game/hsfman.c
@@ -453,7 +453,7 @@ s16 Hu3DModelLink(s16 arg0) {
     for (i = 0; i < 4; i++) {
         var_r31->unk_10[i] = temp_r30->unk_10[i];
         if (var_r31->unk_10[i] != -1) {
-            ClusterAdjustObject(var_r31->hsfData, Hu3DMotion[var_r31->unk_10[i]].unk_04);
+            ClusterAdjustObject(var_r31->hsfData, Hu3DMotion[var_r31->unk_10[i]].hsfData);
             var_r31->attr |= HU3D_ATTR_CLUSTER_ON;
         }
     }
@@ -564,6 +564,9 @@ void Hu3DModelKill(s16 arg0) {
         }
         Hu3DAnimModelKill(arg0);
         if (temp_r31->unk_24 != -1) {
+#ifdef TARGET_PC
+            KillHSF(temp_r31->hsfData);
+#endif
             HuMemDirectFree(temp_r31->hsfData);
             HuMemDirectFreeNum(HEAP_DATA, temp_r31->unk_4C);
             var_r28 = temp_r31->unk_C8;
@@ -581,7 +584,7 @@ void Hu3DModelKill(s16 arg0) {
             if (temp_r31->unk_20 != -1) {
                 for (i = 0; i < HU3D_MODEL_MAX; i++, var_r30++) {
                     if (var_r30->hsfData != 0 && var_r30->unk_24 != -1 && var_r30->unk_C8 == var_r28) {
-                        Hu3DMotion[temp_r31->unk_20].unk_02 = i;
+                        Hu3DMotion[temp_r31->unk_20].modelId = i;
                         break;
                     }
                 }
@@ -592,7 +595,7 @@ void Hu3DModelKill(s16 arg0) {
             return;
         }
         if (temp_r31->unk_20 != -1 && Hu3DMotionKill(temp_r31->unk_20) == 0) {
-            Hu3DMotion[temp_r31->unk_20].unk_02 = -1;
+            Hu3DMotion[temp_r31->unk_20].modelId = -1;
             HuMemDirectFreeNum(HEAP_DATA, temp_r31->unk_48);
             temp_r31->hsfData = NULL;
             if (modelKillAllF == 0) {
@@ -600,6 +603,9 @@ void Hu3DModelKill(s16 arg0) {
             }
             return;
         }
+#ifdef TARGET_PC
+        KillHSF(temp_r31->hsfData);
+#endif
         HuMemDirectFree(temp_r31->hsfData);
         HuMemDirectFreeNum(HEAP_DATA, temp_r31->unk_48);
         for (i = 0; i < temp_r31->unk_26; i++) {
diff --git a/src/game/hsfmotion.c b/src/game/hsfmotion.c
index 68dc376d..45f9b575 100644
--- a/src/game/hsfmotion.c
+++ b/src/game/hsfmotion.c
@@ -29,7 +29,7 @@ void Hu3DMotionInit(void)
 
     var_r31 = (MotionData *)Hu3DData;
     for (i = 0; i < HU3D_MOTION_MAX; i++, var_r31++) {
-        var_r31->unk_04 = 0;
+        var_r31->hsfData = 0;
     }
 }
 
@@ -40,7 +40,7 @@ s16 Hu3DMotionCreate(void *arg0)
 
     var_r31 = Hu3DMotion;
     for (i = 0; i < HU3D_MOTION_MAX; i++, var_r31++) {
-        if (var_r31->unk_04 == 0) {
+        if (var_r31->hsfData == 0) {
             break;
         }
     }
@@ -48,9 +48,9 @@ s16 Hu3DMotionCreate(void *arg0)
         OSReport("Error: Create Motion Over!\n");
         return -1;
     }
-    var_r31->unk_04 = LoadHSF(arg0);
-    var_r31->unk_00 = 0;
-    var_r31->unk_02 = -1;
+    var_r31->hsfData = LoadHSF(arg0);
+    var_r31->attr = 0;
+    var_r31->modelId = -1;
     return i;
 }
 
@@ -62,7 +62,7 @@ s16 Hu3DMotionModelCreate(s16 arg0)
 
     var_r31 = Hu3DMotion;
     for (i = 0; i < HU3D_MOTION_MAX; i++, var_r31++) {
-        if (var_r31->unk_04 == 0) {
+        if (var_r31->hsfData == 0) {
             break;
         }
     }
@@ -70,9 +70,9 @@ s16 Hu3DMotionModelCreate(s16 arg0)
         OSReport("Error: Create Motion Over!\n");
         return -1;
     }
-    var_r31->unk_04 = temp_r29->hsfData;
-    var_r31->unk_00 = 0;
-    var_r31->unk_02 = arg0;
+    var_r31->hsfData = temp_r29->hsfData;
+    var_r31->attr = 0;
+    var_r31->modelId = arg0;
     temp_r29->unk_20 = i;
     return i;
 }
@@ -84,25 +84,28 @@ s32 Hu3DMotionKill(s16 arg0)
     s16 i;
 
     temp_r31 = &Hu3DMotion[arg0];
-    if (temp_r31->unk_04 == 0) {
+    if (temp_r31->hsfData == 0) {
         return 0;
     }
     var_r30 = Hu3DData;
     for (i = 0; i < 512; i++, var_r30++) {
-        if (var_r30->hsfData && var_r30->unk_08 == arg0 && temp_r31->unk_02 != i) {
+        if (var_r30->hsfData && var_r30->unk_08 == arg0 && temp_r31->modelId != i) {
             break;
         }
     }
     if (i != 512) {
         return 0;
     }
-    if (temp_r31->unk_02 == -1) {
-        HuMemDirectFree(temp_r31->unk_04);
+    if (temp_r31->modelId == -1) {
+#ifdef TARGET_PC
+        KillHSF(temp_r31->hsfData);
+#endif
+        HuMemDirectFree(temp_r31->hsfData);
     }
     else {
-        Hu3DData[temp_r31->unk_02].unk_20 = -1;
+        Hu3DData[temp_r31->modelId].unk_20 = -1;
     }
-    temp_r31->unk_04 = NULL;
+    temp_r31->hsfData = NULL;
     return 1;
 }
 
@@ -113,7 +116,7 @@ void Hu3DMotionAllKill(void)
 
     var_r27 = Hu3DMotion;
     for (i = 0; i < HU3D_MOTION_MAX; i++, var_r27++) {
-        if (var_r27->unk_04) {
+        if (var_r27->hsfData) {
             Hu3DMotionKill(i);
         }
     }
@@ -259,7 +262,7 @@ s16 Hu3DMotionClusterSet(s16 arg0, s16 arg1)
             temp_r31->unk_B4[i] = 1.0f;
             temp_r31->cluster_attr[i] = HU3D_ATTR_NONE;
             temp_r31->attr |= HU3D_ATTR_CLUSTER_ON;
-            ClusterAdjustObject(temp_r31->hsfData, Hu3DMotion[arg1].unk_04);
+            ClusterAdjustObject(temp_r31->hsfData, Hu3DMotion[arg1].hsfData);
             return i;
         }
     }
@@ -276,7 +279,7 @@ s16 Hu3DMotionClusterNoSet(s16 arg0, s16 arg1, s16 arg2)
     temp_r31->unk_A4[arg2] = 0.0f;
     temp_r31->unk_B4[arg2] = 1.0f;
     temp_r31->attr |= HU3D_ATTR_CLUSTER_ON;
-    ClusterAdjustObject(temp_r31->hsfData, Hu3DMotion[arg1].unk_04);
+    ClusterAdjustObject(temp_r31->hsfData, Hu3DMotion[arg1].hsfData);
     return arg2;
 }
 
@@ -366,7 +369,7 @@ float Hu3DMotionMaxTimeGet(s16 arg0)
         return 0.0f;
     }
     temp_r30 = &Hu3DMotion[temp_r31->unk_08];
-    temp_r29 = temp_r30->unk_04->motion;
+    temp_r29 = temp_r30->hsfData->motion;
     temp_r28 = 0.0001 + temp_r29->len;
     return temp_r28;
 }
@@ -382,7 +385,7 @@ float Hu3DMotionShiftMaxTimeGet(s16 arg0)
         return 0.0f;
     }
     temp_r30 = &Hu3DMotion[temp_r31->unk_0C];
-    temp_r29 = temp_r30->unk_04->motion;
+    temp_r29 = temp_r30->hsfData->motion;
     temp_r28 = 0.0001 + temp_r29->len;
     return temp_r28;
 }
@@ -401,10 +404,10 @@ float Hu3DMotionMotionMaxTimeGet(s16 arg0)
     HsfMotion *temp_r30;
     s16 temp_r29;
 
-    if (temp_r31->unk_04 == 0) {
+    if (temp_r31->hsfData == 0) {
         return 0.0f;
     }
-    temp_r30 = temp_r31->unk_04->motion;
+    temp_r30 = temp_r31->hsfData->motion;
     temp_r29 = 0.0001 + temp_r30->len;
     return temp_r29;
 }
@@ -526,7 +529,7 @@ void Hu3DMotionNext(s16 arg0)
     s16 i;
 
     temp_r27 = &Hu3DMotion[temp_r31->unk_08];
-    temp_r29 = temp_r27->unk_04->motion;
+    temp_r29 = temp_r27->hsfData->motion;
     temp_r28 = temp_r31->motion_attr;
     if (temp_r31->unk_08 != -1) {
         temp_r27 = &Hu3DMotion[temp_r31->unk_08];
@@ -555,7 +558,7 @@ void Hu3DMotionNext(s16 arg0)
     }
     if (temp_r31->unk_0A != -1) {
         temp_r27 = &Hu3DMotion[temp_r31->unk_0A];
-        temp_r29 = temp_r27->unk_04->motion;
+        temp_r29 = temp_r27->hsfData->motion;
         if (!(temp_r28 & HU3D_MOTATTR_OVL_PAUSE)) {
             if (!(temp_r28 & HU3D_MOTATTR_OVL_REV)) {
                 temp_r31->unk_74 += temp_r31->unk_78 * minimumVcountf;
@@ -629,7 +632,7 @@ void Hu3DMotionNext(s16 arg0)
     }
     if (temp_r31->unk_0E != -1 && !(temp_r28 & HU3D_MOTATTR_SHAPE_PAUSE)) {
         temp_r27 = &Hu3DMotion[temp_r31->unk_0E];
-        temp_r29 = temp_r27->unk_04->motion;
+        temp_r29 = temp_r27->hsfData->motion;
         if (!(temp_r28 & HU3D_MOTATTR_SHAPE_REV)) {
             temp_r31->unk_94 += temp_r31->unk_98 * minimumVcountf;
         }
@@ -655,7 +658,7 @@ void Hu3DMotionNext(s16 arg0)
         for (i = 0; i < 4; i++) {
             if (temp_r31->unk_10[i] != -1 && !(temp_r31->cluster_attr[i] & HU3D_CLUSTER_ATTR_PAUSE)) {
                 temp_r27 = &Hu3DMotion[temp_r31->unk_10[i]];
-                temp_r29 = temp_r27->unk_04->motion;
+                temp_r29 = temp_r27->hsfData->motion;
                 if (!(temp_r31->cluster_attr[i] & HU3D_CLUSTER_ATTR_REV)) {
                     temp_r31->unk_A4[i] += temp_r31->unk_B4[i] * minimumVcountf;
                 }
@@ -692,7 +695,7 @@ void Hu3DMotionExec(s16 arg0, s16 arg1, float arg2, s32 arg3)
     HsfObject *temp_r31;
     HsfObject *var_r19;
     HsfCluster *var_r23;
-    HsfTrack *var_r30;
+    HsfTrack *track;
     HsfTrack *temp_r25;
     HsfTrack *temp_r22;
     HsfTrack *var_r26;
@@ -704,9 +707,9 @@ void Hu3DMotionExec(s16 arg0, s16 arg1, float arg2, s32 arg3)
     temp_r27 = &Hu3DData[arg0];
     sp18 = &Hu3DMotion[arg1];
     temp_r29 = temp_r27->hsfData;
-    sp14 = sp18->unk_04;
+    sp14 = sp18->hsfData;
     temp_r21 = sp14->motion;
-    var_r30 = temp_r21->track;
+    track = temp_r21->track;
     var_r19 = temp_r29->object;
     if (arg3 == 0) {
         for (var_r18 = 0; var_r18 < temp_r29->objectCnt; var_r19++, var_r18++) {
@@ -743,27 +746,27 @@ void Hu3DMotionExec(s16 arg0, s16 arg1, float arg2, s32 arg3)
             }
         }
     }
-    sp10 = &var_r30[temp_r21->numTracks];
-    for (; var_r30 < sp10; var_r30++) {
-        switch (var_r30->type) {
-            case 2:
-                if (var_r30->target < temp_r29->objectCnt && var_r30->target != -1) {
-                    temp_r31 = &temp_r29->object[var_r30->target];
-                    if (var_r30->channel == 0x28) {
-                        temp_r31->data.mesh.baseMorph = GetCurve(var_r30, arg2);
+    sp10 = &track[temp_r21->numTracks];
+    for (; track < sp10; track++) {
+        switch (track->type) {
+            case HSF_TRACK_TRANSFORM:
+                if (track->target < temp_r29->objectCnt && track->target != -1) {
+                    temp_r31 = &temp_r29->object[track->target];
+                    if (track->channel == 0x28) {
+                        temp_r31->data.mesh.baseMorph = GetCurve(track, arg2);
                     }
                     else if (temp_r31->type == 7) {
                         if (temp_r27->attr & HU3D_ATTR_CAMERA_MOTON) {
-                            SetObjCameraMotion(arg0, var_r30, GetCurve(var_r30, arg2));
+                            SetObjCameraMotion(arg0, track, GetCurve(track, arg2));
                         }
                     }
                     else if (temp_r31->type == 8) {
-                        SetObjLightMotion(arg0, var_r30, GetCurve(var_r30, arg2));
+                        SetObjLightMotion(arg0, track, GetCurve(track, arg2));
                     }
-                    else if (var_r30->channel == 0x18) {
+                    else if (track->channel == 0x18) {
                         if (temp_r31->constData) {
                             temp_r28 = temp_r31->constData;
-                            if (GetCurve(var_r30, arg2) == 1.0f) {
+                            if (GetCurve(track, arg2) == 1.0f) {
                                 temp_r28->flags &= ~0x1000;
                             }
                             else {
@@ -771,10 +774,10 @@ void Hu3DMotionExec(s16 arg0, s16 arg1, float arg2, s32 arg3)
                             }
                         }
                     }
-                    else if (var_r30->channel == 0x1A) {
+                    else if (track->channel == 0x1A) {
                         if (temp_r31->constData) {
                             temp_r28 = temp_r31->constData;
-                            if (GetCurve(var_r30, arg2) == 1.0f) {
+                            if (GetCurve(track, arg2) == 1.0f) {
                                 temp_r28->flags &= ~0x2000;
                             }
                             else {
@@ -783,42 +786,42 @@ void Hu3DMotionExec(s16 arg0, s16 arg1, float arg2, s32 arg3)
                         }
                     }
                     else {
-                        temp_r17 = GetObjTRXPtr(temp_r31, var_r30->channel);
+                        temp_r17 = GetObjTRXPtr(temp_r31, track->channel);
                         if (temp_r17 != (float *)-1) {
-                            *temp_r17 = GetCurve(var_r30, arg2);
+                            *temp_r17 = GetCurve(track, arg2);
                         }
                     }
                 }
                 break;
-            case 3:
-                temp_r25 = var_r30;
+            case HSF_TRACK_MORPH:
+                temp_r25 = track;
                 if (temp_r25->target < temp_r29->objectCnt) {
                     temp_r31 = &temp_r29->object[temp_r25->target];
                     temp_r31->data.mesh.morphWeight[temp_r25->channel_s16] = GetCurve(temp_r25, arg2);
                 }
                 break;
-            case 9:
+            case HSF_TRACK_MATERIAL:
                 if (!(temp_r27->attr & HU3D_ATTR_CURVE_MOTOFF)) {
-                    if (var_r30->param < temp_r29->materialCnt) {
-                        SetObjMatMotion(arg0, var_r30, GetCurve(var_r30, arg2));
+                    if (track->param < temp_r29->materialCnt) {
+                        SetObjMatMotion(arg0, track, GetCurve(track, arg2));
                     }
                 }
                 break;
-            case 5:
+            case HSF_TRACK_CLUSTER:
                 if (!(temp_r27->attr & HU3D_ATTR_CURVE_MOTOFF)) {
-                    var_r23 = &temp_r29->cluster[var_r30->target_s16];
-                    var_r23->index = GetClusterCurve(var_r30, arg2);
+                    var_r23 = &temp_r29->cluster[track->target_s16];
+                    var_r23->index = GetClusterCurve(track, arg2);
                 }
                 break;
-            case 6:
+            case HSF_TRACK_CLUSTER_WEIGHT:
                 if (!(temp_r27->attr & HU3D_ATTR_CURVE_MOTOFF)) {
-                    temp_r22 = var_r30;
+                    temp_r22 = track;
                     var_r23 = &temp_r29->cluster[temp_r22->target_s16];
                     var_r23->weight[temp_r22->unk04] = GetClusterWeightCurve(temp_r22, arg2);
                 }
                 break;
-            case 10:
-                var_r26 = var_r30;
+            case HSF_TRACK_ATTRIBUTE:
+                var_r26 = track;
                 if (var_r26->target_s16 != -1 || !(temp_r27->attr & HU3D_ATTR_CURVE_MOTOFF)) {
                     if (var_r26->param != -1 && var_r26->param < temp_r29->attributeCnt) {
                         SetObjAttrMotion(arg0, var_r26, GetCurve(var_r26, arg2));
@@ -834,20 +837,20 @@ void Hu3DCameraMotionExec(s16 arg0)
     ModelData *temp_r30;
     MotionData *temp_r28;
     HsfData *temp_r27;
-    HsfMotion *temp_r29;
-    HsfTrack *var_r31;
+    HsfMotion *motion;
+    HsfTrack *track;
     HsfTrack *temp_r26;
 
     temp_r30 = &Hu3DData[arg0];
     temp_r28 = &Hu3DMotion[temp_r30->unk_08];
-    temp_r27 = temp_r28->unk_04;
-    temp_r29 = temp_r27->motion;
-    var_r31 = temp_r29->track;
+    temp_r27 = temp_r28->hsfData;
+    motion = temp_r27->motion;
+    track = motion->track;
     if (temp_r30->attr & HU3D_ATTR_CAMERA_MOTON) {
-        temp_r26 = &var_r31[temp_r29->numTracks];
-        for (; var_r31 < temp_r26; var_r31++) {
-            if (var_r31->type == 2 && var_r31->param_u16 == 7) {
-                SetObjCameraMotion(arg0, var_r31, GetCurve(var_r31, temp_r30->unk_64));
+        temp_r26 = &track[motion->numTracks];
+        for (; track < temp_r26; track++) {
+            if (track->type == HSF_TRACK_TRANSFORM && track->param_u16 == 7) {
+                SetObjCameraMotion(arg0, track, GetCurve(track, temp_r30->unk_64));
             }
         }
     }
@@ -859,8 +862,8 @@ void Hu3DSubMotionExec(s16 arg0)
     MotionData *temp_r22;
     HsfData *temp_r28;
     HsfData *temp_r21;
-    HsfMotion *temp_r25;
-    HsfTrack *var_r29;
+    HsfMotion *motion;
+    HsfTrack *track;
     HsfObject *var_r23;
     HsfObject *temp_r26;
     float *temp_r31;
@@ -872,9 +875,9 @@ void Hu3DSubMotionExec(s16 arg0)
     temp_r30 = &Hu3DData[arg0];
     temp_r22 = &Hu3DMotion[temp_r30->unk_0C];
     temp_r28 = temp_r30->hsfData;
-    temp_r21 = temp_r22->unk_04;
-    temp_r25 = temp_r21->motion;
-    var_r29 = temp_r25->track;
+    temp_r21 = temp_r22->hsfData;
+    motion = temp_r21->motion;
+    track = motion->track;
     var_r23 = temp_r28->object;
     if (temp_r30->unk_08 == -1) {
         for (var_r27 = 0; var_r27 < temp_r28->objectCnt; var_r23++, var_r27++) {
@@ -888,16 +891,16 @@ void Hu3DSubMotionExec(s16 arg0)
     else {
         var_f30 = 1.0f;
     }
-    for (var_r27 = 0; var_r27 < temp_r25->numTracks; var_r27++, var_r29++) {
-        switch (var_r29->type) {
-            case 2:
-                if (var_r29->target < temp_r28->objectCnt && var_r29->target != -1) {
-                    temp_r26 = &temp_r28->object[var_r29->target];
-                    temp_r24 = var_r29->channel;
+    for (var_r27 = 0; var_r27 < motion->numTracks; var_r27++, track++) {
+        switch (track->type) {
+            case HSF_TRACK_TRANSFORM:
+                if (track->target < temp_r28->objectCnt && track->target != -1) {
+                    temp_r26 = &temp_r28->object[track->target];
+                    temp_r24 = track->channel;
                     temp_r31 = GetObjTRXPtr(temp_r26, temp_r24);
                     if (temp_r31 != (float *)-1) {
                         if (temp_r24 == 0x1C || temp_r24 == 0x1D || temp_r24 == 0x1E) {
-                            var_f31 = GetCurve(var_r29, temp_r30->unk_84);
+                            var_f31 = GetCurve(track, temp_r30->unk_84);
                             if (var_f31 < 0.0f) {
                                 var_f31 += 360.0f;
                             }
@@ -915,7 +918,7 @@ void Hu3DSubMotionExec(s16 arg0)
                             *temp_r31 = (1.0f - var_f30) * *temp_r31 + var_f30 * var_f31;
                         }
                         else {
-                            *temp_r31 = (1.0f - var_f30) * *temp_r31 + var_f30 * GetCurve(var_r29, temp_r30->unk_84);
+                            *temp_r31 = (1.0f - var_f30) * *temp_r31 + var_f30 * GetCurve(track, temp_r30->unk_84);
                         }
                     }
                 }
@@ -1232,7 +1235,7 @@ void SetObjLightMotion(s16 arg0, HsfTrack *arg1, float arg2)
     var_r26 = temp_r28->object;
     for (i = var_r29 = 0; i < temp_r28->objectCnt; i++, var_r26++) {
         var_r24 = var_r26;
-        if (var_r24->type == 8) {
+        if (var_r24->type == HSF_OBJ_NONE2) {
             if (i != arg1->target) {
                 var_r29++;
             }
@@ -1276,23 +1279,23 @@ void SetObjLightMotion(s16 arg0, HsfTrack *arg1, float arg2)
     }
 }
 
-float GetCurve(HsfTrack *arg0, float arg1)
+float GetCurve(HsfTrack *track, float arg1)
 {
     float *var_r30;
 
-    switch (arg0->curveType) {
-        case 1:
-            return GetLinear(arg0->numKeyframes, arg0->data, arg1);
-        case 2:
-            return GetBezier(arg0->numKeyframes, arg0, arg1);
-        case 3:
-            bitMapPtr = GetBitMap(arg0->numKeyframes, arg0->data, arg1);
+    switch (track->curveType) {
+        case HSF_CURVE_LINEAR:
+            return GetLinear(track->numKeyframes, track->data, arg1);
+        case HSF_CURVE_BEZIER:
+            return GetBezier(track->numKeyframes, track, arg1);
+        case HSF_CURVE_BITMAP:
+            bitMapPtr = GetBitMap(track->numKeyframes, track->data, arg1);
             break;
-        case 4:
-            var_r30 = &arg0->value;
+        case HSF_CURVE_CONST:
+            var_r30 = &track->value;
             return *var_r30;
-        case 0:
-            return GetConstant(arg0->numKeyframes, arg0->data, arg1);
+        case HSF_CURVE_STEP:
+            return GetConstant(track->numKeyframes, track->data, arg1);
     }
     return 0.0f;
 }
@@ -1427,8 +1430,8 @@ void JointModel_Motion(s16 arg0, s16 arg1)
     MotionData *temp_r23;
     HsfData *temp_r26;
     HsfData *temp_r22;
-    HsfMotion *temp_r29;
-    HsfTrack *var_r30;
+    HsfMotion *motion;
+    HsfTrack *track;
     HsfTrack *var_r28;
     HsfTrack *var_r27;
     HsfTrack *var_r31;
@@ -1438,21 +1441,21 @@ void JointModel_Motion(s16 arg0, s16 arg1)
     temp_r24 = &Hu3DData[arg0];
     temp_r23 = &Hu3DMotion[arg1];
     temp_r26 = temp_r24->hsfData;
-    temp_r22 = temp_r23->unk_04;
-    temp_r29 = temp_r22->motion;
-    var_r30 = temp_r29->track;
-    for (i = 0; i < temp_r29->numTracks; i++, var_r30++) {
-        switch (var_r30->type) {
-            case 2:
-                var_r28 = var_r30;
+    temp_r22 = temp_r23->hsfData;
+    motion = temp_r22->motion;
+    track = motion->track;
+    for (i = 0; i < motion->numTracks; i++, track++) {
+        switch (track->type) {
+            case HSF_TRACK_TRANSFORM:
+                var_r28 = track;
                 var_r28->target = SearchObjectIndex(temp_r26, var_r28->target);
                 break;
-            case 3:
-                var_r27 = var_r30;
+            case HSF_TRACK_MORPH:
+                var_r27 = track;
                 var_r27->target = SearchObjectIndex(temp_r26, var_r27->target);
                 break;
-            case 10:
-                var_r31 = var_r30;
+            case HSF_TRACK_ATTRIBUTE:
+                var_r31 = track;
                 if (var_r31->param == -1) {
                     temp_r21 = SearchAttributeIndex(temp_r26, var_r31->target_s16);
                     if (temp_r21 != -1) {
diff --git a/src/port/byteswap.cpp b/src/port/byteswap.cpp
index 4c6b901f..f7ed6a16 100644
--- a/src/port/byteswap.cpp
+++ b/src/port/byteswap.cpp
@@ -45,7 +45,6 @@ typedef struct AnimBmpData32b {
     u32 palData;
     u32 data;
 } AnimBmpData32b;
-
 }
 
 template <typename T> [[nodiscard]] constexpr T bswap16(T val) noexcept
@@ -208,6 +207,13 @@ template <typename B> void bswap(B &base, Vec2f &vec)
     bswap(base, vec.y);
 }
 
+template <typename B> void bswap(B &base, HsfVector3f &vec)
+{
+    bswap(base, vec.x);
+    bswap(base, vec.y);
+    bswap(base, vec.z);
+}
+
 template <typename B> void bswap(B &base, AnimData32b &obj, AnimData &dest)
 {
     bswap(base, obj.bankNum);
@@ -459,7 +465,7 @@ template <typename B> void bswap(B &base, HsfMatrix &obj)
             bswap_flat(base, obj.data[i][j], 4);
         }
     }
-}   
+}
 
 template <typename B> void bswap(B &base, HsfPalette32b &obj, HsfPalette &dest)
 {
@@ -582,6 +588,74 @@ template <typename B> void bswap(B &base, HsfCenv32b &obj, HsfCenv &dest)
     dest.copyCount = obj.copyCount;
 }
 
+template <typename B> void bswap(B &base, HsfObjectData32b &obj, HsfObjectData &dest, u32 type)
+{
+    bswap(base, obj.parent);
+    bswap(base, obj.childrenCount);
+    bswap(base, obj.children);
+    bswap(base, obj.base);
+    bswap(base, obj.curr);
+    bswap(base, obj.face);
+    bswap(base, obj.vertex);
+    bswap(base, obj.normal);
+    bswap(base, obj.color);
+    bswap(base, obj.st);
+    bswap(base, obj.material);
+    bswap(base, obj.attribute);
+    bswap(base, obj.vertexShapeCnt);
+    bswap(base, obj.vertexShape);
+    bswap(base, obj.clusterCnt);
+    bswap(base, obj.cluster);
+    bswap(base, obj.cenvCnt);
+    bswap(base, obj.cenv);
+    bswap_flat(base, obj.file, sizeof(obj.file) / sizeof(u32));
+
+    dest.parent = reinterpret_cast<struct hsf_object *>(obj.parent);
+    dest.childrenCount = obj.childrenCount;
+    dest.children = reinterpret_cast<struct hsf_object **>(obj.children);
+    dest.base = obj.base;
+    dest.curr = obj.curr;
+    dest.face = reinterpret_cast<HsfBuffer *>(obj.face);
+    dest.vertex = reinterpret_cast<HsfBuffer *>(obj.vertex);
+    dest.normal = reinterpret_cast<HsfBuffer *>(obj.normal);
+    dest.color = reinterpret_cast<HsfBuffer *>(obj.color);
+    dest.st = reinterpret_cast<HsfBuffer *>(obj.st);
+    dest.material = reinterpret_cast<HsfMaterial *>(obj.material);
+    dest.attribute = reinterpret_cast<HsfAttribute *>(obj.attribute);
+    std::copy(std::begin(obj.unk120), std::end(obj.unk120), dest.unk120);
+    dest.shapeType = obj.shapeType;
+    dest.unk123 = obj.unk123;
+    dest.vertexShapeCnt = obj.vertexShapeCnt;
+    dest.vertexShape = reinterpret_cast<HsfBuffer **>(obj.vertexShape);
+    dest.clusterCnt = obj.clusterCnt;
+    dest.cluster = reinterpret_cast<HsfCluster **>(obj.cluster);
+    dest.cenvCnt = obj.cenvCnt;
+    dest.cenv = reinterpret_cast<HsfCenv *>(obj.cenv);
+    dest.file[0] = reinterpret_cast<void *>(obj.file[0]);
+    dest.file[1] = reinterpret_cast<void *>(obj.file[1]);
+
+    switch (type) {
+        case HSF_OBJ_MESH:
+            bswap(base, obj.mesh.min);
+            bswap(base, obj.mesh.max);
+            bswap(base, obj.mesh.baseMorph);
+            bswap_flat(base, obj.mesh.morphWeight, std::size(obj.mesh.morphWeight));
+
+            dest.mesh.min = obj.mesh.min;
+            dest.mesh.max = obj.mesh.max;
+            dest.mesh.baseMorph = obj.mesh.baseMorph;
+            std::copy(std::begin(obj.mesh.morphWeight), std::end(obj.mesh.morphWeight), dest.mesh.morphWeight);
+            break;
+        case HSF_OBJ_REPLICA:
+            bswap(base, obj.replica);
+
+            dest.replica = obj.replica;
+            break;
+        default:
+            break;
+    }
+}
+
 template <typename B> void bswap(B &base, HsfObject32b &obj, HsfObject &dest)
 {
     bswap(base, obj.name);
@@ -593,6 +667,58 @@ template <typename B> void bswap(B &base, HsfObject32b &obj, HsfObject &dest)
     dest.type = obj.type;
     dest.constData = reinterpret_cast<void *>(obj.constData);
     dest.flags = obj.flags;
+
+    bswap(base, obj.data, dest.data, obj.type);
+}
+
+template <typename B> void bswap(B &base, HsfBitmapKey32b &obj, HsfBitmapKey &dest)
+{
+    bswap(base, obj.time);
+    bswap(base, obj.data);
+
+    dest.time = obj.time;
+    dest.data = reinterpret_cast<HsfBitmap *>(obj.data);
+}
+
+template <typename B> void bswap(B &base, HsfTrack32b &obj, HsfTrack &dest)
+{
+    bswap(base, obj.type);
+    bswap(base, obj.start);
+    bswap(base, obj.curveType);
+    bswap(base, obj.numKeyframes);
+    bswap(base, obj.data); // this byteswaps "value" too
+
+    dest.type = obj.type;
+    dest.start = obj.start;
+    dest.curveType = obj.curveType;
+    dest.numKeyframes = obj.numKeyframes;
+    dest.data = reinterpret_cast<void *>(obj.data); // this correctly sets "value" too
+
+    if (obj.type = HSF_TRACK_CLUSTER_WEIGHT) {
+        bswap(base, obj.unk04);
+
+        dest.unk04 = obj.unk04;
+    }
+    else {
+        bswap(base, obj.param);
+        bswap(base, obj.channel);
+
+        dest.param = obj.param;
+        dest.channel = obj.channel;
+    }
+}
+
+template <typename B> void bswap(B &base, HsfMotion32b &obj, HsfMotion &dest)
+{
+    bswap(base, obj.name);
+    bswap(base, obj.numTracks);
+    bswap(base, obj.track);
+    bswap(base, obj.len);
+
+    dest.name = reinterpret_cast<char *>(obj.name);
+    dest.numTracks = obj.numTracks;
+    dest.track = reinterpret_cast<HsfTrack *>(obj.track);
+    dest.len = obj.len;
 }
 
 void byteswap_u16(u16 *src)
@@ -621,8 +747,7 @@ void byteswap_s32(s32 *src)
 
 void byteswap_hsfvec3f(HsfVector3f *src)
 {
-    auto *vec = reinterpret_cast<Vec *>(src);
-    bswap(*vec, *vec);
+    bswap(*src, *src);
     sVisitedPtrs.clear();
 }
 
@@ -751,7 +876,7 @@ void byteswap_hsfshape(HsfShape32b *src, HsfShape *dest)
     sVisitedPtrs.clear();
 }
 
-void byteswap_hsfcenvsingle(HsfCenvSingle *src)
+void byteswap_hsfcenv_single(HsfCenvSingle *src)
 {
     bswap(*src, *src);
     sVisitedPtrs.clear();
@@ -764,6 +889,26 @@ void byteswap_hsfcenv(HsfCenv32b *src, HsfCenv *dest)
 }
 
 void byteswap_hsfobject(HsfObject32b *src, HsfObject *dest)
+{
+    bswap(*src, *src, *dest);
+    sVisitedPtrs.clear();
+}
+
+
+void byteswap_hsfbitmapkey(HsfBitmapKey32b *src, HsfBitmapKey *dest)
+{
+    bswap(*src, *src, *dest);
+    sVisitedPtrs.clear();
+}
+
+
+void byteswap_hsftrack(HsfTrack32b *src, HsfTrack *dest)
+{
+    bswap(*src, *src, *dest);
+    sVisitedPtrs.clear();
+}
+
+void byteswap_hsfmotion(HsfMotion32b *src, HsfMotion *dest)
 {
     bswap(*src, *src, *dest);
     sVisitedPtrs.clear();