Port most of hsfload to PC (#581)

* Port some of hsfload.c

* More byteswaps in hsfload.c

* Finish hsfload besides cenv

* hsfload fixes

include/game/hsfdraw.h

@@ -57,7 +57,7 @@ void Hu3DDrawPreInit(void);
 void Hu3DDraw(ModelData *arg0, Mtx arg1, Vec *arg2);
 s32 ObjCullCheck(HsfData *arg0, HsfObject *arg1, Mtx arg2);
 void Hu3DDrawPost(void);
-void MakeDisplayList(s16 arg0, u32 arg1);
+void MakeDisplayList(s16 arg0, uintptr_t arg1);
 HsfConstData *ObjConstantMake(HsfObject *arg0, u32 arg1);
 void mtxTransCat(Mtx arg0, float arg1, float arg2, float arg3);
 void mtxRotCat(Mtx arg0, float arg1, float arg2, float arg3);

include/game/hsfformat.h

@@ -227,9 +227,8 @@ typedef struct hsf_cluster {
         s32 target;
     };
     HsfPart *part;
-    float unk10;
-    float unk14[1]; // unknown array size
-    u8 unk18[124];
+    float index;
+    float weight[32]; // unknown array size
     u8 adjusted;
     u8 unk95;
     u16 type;
@@ -261,7 +260,7 @@ typedef struct hsf_object_data {
         } mesh;
         struct hsf_object *replica;
     };
-    
+
     HsfBuffer *face;
     HsfBuffer *vertex;
     HsfBuffer *normal;
@@ -351,6 +350,9 @@ typedef struct hsf_track {
         float value;
         void *data;
     };
+#ifdef TARGET_PC
+    void *dataTop;
+#endif
 } HsfTrack;
 
 typedef struct hsf_motion {
@@ -397,6 +399,9 @@ typedef struct hsf_data {
     HsfObject *object;
     HsfMapAttr *mapAttr;
     HsfMatrix *matrix;
+#ifdef TARGET_PC
+    void **symbol;
+#endif
     s16 sceneCnt;
     s16 attributeCnt;
     s16 materialCnt;

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

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 {

include/game/memory.h

@@ -19,9 +19,9 @@ void *HuMemInit(void *ptr, s32 size);
 void HuMemDCFlushAll();
 void HuMemDCFlush(HeapID heap);
 void *HuMemDirectMalloc(HeapID heap, s32 size);
-void *HuMemDirectMallocNum(HeapID heap, s32 size, u32 num);
+void *HuMemDirectMallocNum(HeapID heap, s32 size, uintptr_t num);
 void HuMemDirectFree(void *ptr);
-void HuMemDirectFreeNum(HeapID heap, u32 num);
+void HuMemDirectFreeNum(HeapID heap, uintptr_t num);
 s32 HuMemUsedMallocSizeGet(HeapID heap);
 s32 HuMemUsedMallocBlockGet(HeapID heap);
 u32 HuMemHeapSizeGet(HeapID heap);
@@ -29,9 +29,9 @@ void *HuMemHeapPtrGet(HeapID heap);
 
 void *HuMemHeapInit(void *ptr, s32 size);
 void *HuMemMemoryAlloc(void *heap_ptr, s32 size, uintptr_t retaddr);
-void *HuMemMemoryAllocNum(void *heap_ptr, s32 size, u32 num, uintptr_t retaddr);
+void *HuMemMemoryAllocNum(void *heap_ptr, s32 size, uintptr_t num, uintptr_t retaddr);
 void HuMemMemoryFree(void *ptr, uintptr_t retaddr);
-void HuMemMemoryFreeNum(void *heap_ptr, u32 num, uintptr_t retaddr);
+void HuMemMemoryFreeNum(void *heap_ptr, uintptr_t num, uintptr_t retaddr);
 s32 HuMemUsedMemorySizeGet(void *heap_ptr);
 s32 HuMemUsedMemoryBlockGet(void *heap_ptr);
 s32 HuMemMemorySizeGet(void *ptr);

include/port/byteswap.h

@@ -9,8 +9,233 @@ extern "C"
 #include "game/animdata.h"
 #include "game/hsfformat.h"
 
+typedef struct HsfCluster32b {
+    u32 name[2];
+    u32 targetName;
+    u32 part;
+    float index;
+    float weight[32];
+    u8 adjusted;
+    u8 unk95;
+    u16 type;
+    u32 vertexCnt;
+    u32 vertex;
+} HsfCluster32b;
+
+typedef struct HsfAttribute32b {
+    u32 name;
+    u32 unk04;
+    u8 unk8[4];
+    float unk0C;
+    u8 unk10[4];
+    float unk14;
+    u8 unk18[8];
+    float unk20;
+    u8 unk24[4];
+    float unk28;
+    float unk2C;
+    float unk30;
+    float unk34;
+    u8 unk38[44];
+    u32 wrap_s;
+    u32 wrap_t;
+    u8 unk6C[12];
+    u32 unk78;
+    u32 flag;
+    u32 bitmap;
+} HsfAttribute32b;
+
+typedef struct HsfMaterial32b {
+    u32 name;
+    u8 unk4[4];
+    u16 pass;
+    u8 vtxMode;
+    u8 litColor[3];
+    u8 color[3];
+    u8 shadowColor[3];
+    float hilite_scale;
+    float unk18;
+    float invAlpha;
+    float unk20[2];
+    float refAlpha;
+    float unk2C;
+    u32 flags;
+    u32 numAttrs;
+    u32 attrs;
+} HsfMaterial32b;
+
+typedef struct HsfMapAttr32b {
+    float minX;
+    float minZ;
+    float maxX;
+    float maxZ;
+    u32 data;
+    u32 dataLen;
+} HsfMapAttr32b;
+
+typedef struct HsfBuffer32b {
+    u32 name;
+    s32 count;
+    u32 data;
+} HsfBuffer32b;
+
+typedef struct HsfPalette32b {
+    u32 name;
+    s32 unk;
+    u32 palSize;
+    u32 data;
+} HsfPalette32b;
+
+typedef struct HsfBitmap32b {
+    u32 name;
+    u32 maxLod;
+    u8 dataFmt;
+    u8 pixSize;
+    s16 sizeX;
+    s16 sizeY;
+    s16 palSize;
+    GXColor tint;
+    u32 palData;
+    u32 unk;
+    u32 data;
+} HsfBitmap32b;
+
+typedef struct HsfPart32b {
+    u32 name;
+    u32 count;
+    u32 vertex;
+} HsfPart32b;
+
+typedef struct HsfSkeleton32b {
+    u32 name;
+    HsfTransform transform;
+} HsfSkeleton32b;
+
+typedef struct HsfShape32b {
+    u32 name;
+    union {
+        u16 count16[2];
+        u32 vertexCnt;
+    };
+    u32 vertex;
+} HsfShape32b;
+
+typedef struct HsfCenv32b {
+    u32 name;
+    u32 singleData;
+    u32 dualData;
+    u32 multiData;
+    u32 singleCount;
+    u32 dualCount;
+    u32 multiCount;
+    u32 vtxCount;
+    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;
+    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;
+
+typedef struct HsfFace32b {
+    s16 type;
+    s16 mat;
+    union {
+        struct {
+            s16 indices[3][4];
+            u32 count;
+            u32 data;
+        } strip;
+        s16 indices[4][4];
+    };
+    Vec nbt;
+} HsfFace32b;
+
+void byteswap_u16(u16 *src);
+void byteswap_s16(s16 *src);
 void byteswap_u32(u32 *src);
 void byteswap_s32(s32 *src);
+void byteswap_hsfvec3f(HsfVector3f *src);
+void byteswap_hsfvec2f(HsfVector2f *src);
+
 void byteswap_animdata(void *src, AnimData* dest);
 void byteswap_animbankdata(void *src, AnimBankData *dest);
 void byteswap_animpatdata(void *src, AnimPatData *dest);
@@ -18,8 +243,26 @@ void byteswap_animbmpdata(void *src, AnimBmpData *dest);
 void byteswap_animframedata(AnimFrameData *src);
 void byteswap_animlayerdata(AnimLayerData *src);
 
-
 void byteswap_hsfheader(HsfHeader *src);
+void byteswap_hsfcluster(HsfCluster32b *src, HsfCluster *dest);
+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);
+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(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);
+void byteswap_hsfface(HsfFace32b *src, HsfFace *dest);
 
 #ifdef __cplusplus
 }